1  // File automatically generated by Parser/asdl_c.py.
2  
3  #include "Python.h"
4  #include "pycore_ast.h"
5  #include "pycore_ast_state.h"     // struct ast_state
6  #include "pycore_ceval.h"         // _Py_EnterRecursiveCall
7  #include "pycore_interp.h"        // _PyInterpreterState.ast
8  #include "pycore_pystate.h"       // _PyInterpreterState_GET()
9  #include "structmember.h"
10  #include <stddef.h>
11  
12  // Forward declaration
13  static int init_types(struct ast_state *state);
14  
15  static struct ast_state*
get_ast_state(void)16  get_ast_state(void)
17  {
18      PyInterpreterState *interp = _PyInterpreterState_GET();
19      struct ast_state *state = &interp->ast;
20      if (!init_types(state)) {
21          return NULL;
22      }
23      return state;
24  }
25  
_PyAST_Fini(PyInterpreterState * interp)26  void _PyAST_Fini(PyInterpreterState *interp)
27  {
28      struct ast_state *state = &interp->ast;
29  
30      Py_CLEAR(state->AST_type);
31      Py_CLEAR(state->Add_singleton);
32      Py_CLEAR(state->Add_type);
33      Py_CLEAR(state->And_singleton);
34      Py_CLEAR(state->And_type);
35      Py_CLEAR(state->AnnAssign_type);
36      Py_CLEAR(state->Assert_type);
37      Py_CLEAR(state->Assign_type);
38      Py_CLEAR(state->AsyncFor_type);
39      Py_CLEAR(state->AsyncFunctionDef_type);
40      Py_CLEAR(state->AsyncWith_type);
41      Py_CLEAR(state->Attribute_type);
42      Py_CLEAR(state->AugAssign_type);
43      Py_CLEAR(state->Await_type);
44      Py_CLEAR(state->BinOp_type);
45      Py_CLEAR(state->BitAnd_singleton);
46      Py_CLEAR(state->BitAnd_type);
47      Py_CLEAR(state->BitOr_singleton);
48      Py_CLEAR(state->BitOr_type);
49      Py_CLEAR(state->BitXor_singleton);
50      Py_CLEAR(state->BitXor_type);
51      Py_CLEAR(state->BoolOp_type);
52      Py_CLEAR(state->Break_type);
53      Py_CLEAR(state->Call_type);
54      Py_CLEAR(state->ClassDef_type);
55      Py_CLEAR(state->Compare_type);
56      Py_CLEAR(state->Constant_type);
57      Py_CLEAR(state->Continue_type);
58      Py_CLEAR(state->Del_singleton);
59      Py_CLEAR(state->Del_type);
60      Py_CLEAR(state->Delete_type);
61      Py_CLEAR(state->DictComp_type);
62      Py_CLEAR(state->Dict_type);
63      Py_CLEAR(state->Div_singleton);
64      Py_CLEAR(state->Div_type);
65      Py_CLEAR(state->Eq_singleton);
66      Py_CLEAR(state->Eq_type);
67      Py_CLEAR(state->ExceptHandler_type);
68      Py_CLEAR(state->Expr_type);
69      Py_CLEAR(state->Expression_type);
70      Py_CLEAR(state->FloorDiv_singleton);
71      Py_CLEAR(state->FloorDiv_type);
72      Py_CLEAR(state->For_type);
73      Py_CLEAR(state->FormattedValue_type);
74      Py_CLEAR(state->FunctionDef_type);
75      Py_CLEAR(state->FunctionType_type);
76      Py_CLEAR(state->GeneratorExp_type);
77      Py_CLEAR(state->Global_type);
78      Py_CLEAR(state->GtE_singleton);
79      Py_CLEAR(state->GtE_type);
80      Py_CLEAR(state->Gt_singleton);
81      Py_CLEAR(state->Gt_type);
82      Py_CLEAR(state->IfExp_type);
83      Py_CLEAR(state->If_type);
84      Py_CLEAR(state->ImportFrom_type);
85      Py_CLEAR(state->Import_type);
86      Py_CLEAR(state->In_singleton);
87      Py_CLEAR(state->In_type);
88      Py_CLEAR(state->Interactive_type);
89      Py_CLEAR(state->Invert_singleton);
90      Py_CLEAR(state->Invert_type);
91      Py_CLEAR(state->IsNot_singleton);
92      Py_CLEAR(state->IsNot_type);
93      Py_CLEAR(state->Is_singleton);
94      Py_CLEAR(state->Is_type);
95      Py_CLEAR(state->JoinedStr_type);
96      Py_CLEAR(state->LShift_singleton);
97      Py_CLEAR(state->LShift_type);
98      Py_CLEAR(state->Lambda_type);
99      Py_CLEAR(state->ListComp_type);
100      Py_CLEAR(state->List_type);
101      Py_CLEAR(state->Load_singleton);
102      Py_CLEAR(state->Load_type);
103      Py_CLEAR(state->LtE_singleton);
104      Py_CLEAR(state->LtE_type);
105      Py_CLEAR(state->Lt_singleton);
106      Py_CLEAR(state->Lt_type);
107      Py_CLEAR(state->MatMult_singleton);
108      Py_CLEAR(state->MatMult_type);
109      Py_CLEAR(state->MatchAs_type);
110      Py_CLEAR(state->MatchClass_type);
111      Py_CLEAR(state->MatchMapping_type);
112      Py_CLEAR(state->MatchOr_type);
113      Py_CLEAR(state->MatchSequence_type);
114      Py_CLEAR(state->MatchSingleton_type);
115      Py_CLEAR(state->MatchStar_type);
116      Py_CLEAR(state->MatchValue_type);
117      Py_CLEAR(state->Match_type);
118      Py_CLEAR(state->Mod_singleton);
119      Py_CLEAR(state->Mod_type);
120      Py_CLEAR(state->Module_type);
121      Py_CLEAR(state->Mult_singleton);
122      Py_CLEAR(state->Mult_type);
123      Py_CLEAR(state->Name_type);
124      Py_CLEAR(state->NamedExpr_type);
125      Py_CLEAR(state->Nonlocal_type);
126      Py_CLEAR(state->NotEq_singleton);
127      Py_CLEAR(state->NotEq_type);
128      Py_CLEAR(state->NotIn_singleton);
129      Py_CLEAR(state->NotIn_type);
130      Py_CLEAR(state->Not_singleton);
131      Py_CLEAR(state->Not_type);
132      Py_CLEAR(state->Or_singleton);
133      Py_CLEAR(state->Or_type);
134      Py_CLEAR(state->Pass_type);
135      Py_CLEAR(state->Pow_singleton);
136      Py_CLEAR(state->Pow_type);
137      Py_CLEAR(state->RShift_singleton);
138      Py_CLEAR(state->RShift_type);
139      Py_CLEAR(state->Raise_type);
140      Py_CLEAR(state->Return_type);
141      Py_CLEAR(state->SetComp_type);
142      Py_CLEAR(state->Set_type);
143      Py_CLEAR(state->Slice_type);
144      Py_CLEAR(state->Starred_type);
145      Py_CLEAR(state->Store_singleton);
146      Py_CLEAR(state->Store_type);
147      Py_CLEAR(state->Sub_singleton);
148      Py_CLEAR(state->Sub_type);
149      Py_CLEAR(state->Subscript_type);
150      Py_CLEAR(state->TryStar_type);
151      Py_CLEAR(state->Try_type);
152      Py_CLEAR(state->Tuple_type);
153      Py_CLEAR(state->TypeIgnore_type);
154      Py_CLEAR(state->UAdd_singleton);
155      Py_CLEAR(state->UAdd_type);
156      Py_CLEAR(state->USub_singleton);
157      Py_CLEAR(state->USub_type);
158      Py_CLEAR(state->UnaryOp_type);
159      Py_CLEAR(state->While_type);
160      Py_CLEAR(state->With_type);
161      Py_CLEAR(state->YieldFrom_type);
162      Py_CLEAR(state->Yield_type);
163      Py_CLEAR(state->__dict__);
164      Py_CLEAR(state->__doc__);
165      Py_CLEAR(state->__match_args__);
166      Py_CLEAR(state->__module__);
167      Py_CLEAR(state->_attributes);
168      Py_CLEAR(state->_fields);
169      Py_CLEAR(state->alias_type);
170      Py_CLEAR(state->annotation);
171      Py_CLEAR(state->arg);
172      Py_CLEAR(state->arg_type);
173      Py_CLEAR(state->args);
174      Py_CLEAR(state->argtypes);
175      Py_CLEAR(state->arguments_type);
176      Py_CLEAR(state->asname);
177      Py_CLEAR(state->ast);
178      Py_CLEAR(state->attr);
179      Py_CLEAR(state->bases);
180      Py_CLEAR(state->body);
181      Py_CLEAR(state->boolop_type);
182      Py_CLEAR(state->cases);
183      Py_CLEAR(state->cause);
184      Py_CLEAR(state->cls);
185      Py_CLEAR(state->cmpop_type);
186      Py_CLEAR(state->col_offset);
187      Py_CLEAR(state->comparators);
188      Py_CLEAR(state->comprehension_type);
189      Py_CLEAR(state->context_expr);
190      Py_CLEAR(state->conversion);
191      Py_CLEAR(state->ctx);
192      Py_CLEAR(state->decorator_list);
193      Py_CLEAR(state->defaults);
194      Py_CLEAR(state->elt);
195      Py_CLEAR(state->elts);
196      Py_CLEAR(state->end_col_offset);
197      Py_CLEAR(state->end_lineno);
198      Py_CLEAR(state->exc);
199      Py_CLEAR(state->excepthandler_type);
200      Py_CLEAR(state->expr_context_type);
201      Py_CLEAR(state->expr_type);
202      Py_CLEAR(state->finalbody);
203      Py_CLEAR(state->format_spec);
204      Py_CLEAR(state->func);
205      Py_CLEAR(state->generators);
206      Py_CLEAR(state->guard);
207      Py_CLEAR(state->handlers);
208      Py_CLEAR(state->id);
209      Py_CLEAR(state->ifs);
210      Py_CLEAR(state->is_async);
211      Py_CLEAR(state->items);
212      Py_CLEAR(state->iter);
213      Py_CLEAR(state->key);
214      Py_CLEAR(state->keys);
215      Py_CLEAR(state->keyword_type);
216      Py_CLEAR(state->keywords);
217      Py_CLEAR(state->kind);
218      Py_CLEAR(state->kw_defaults);
219      Py_CLEAR(state->kwarg);
220      Py_CLEAR(state->kwd_attrs);
221      Py_CLEAR(state->kwd_patterns);
222      Py_CLEAR(state->kwonlyargs);
223      Py_CLEAR(state->left);
224      Py_CLEAR(state->level);
225      Py_CLEAR(state->lineno);
226      Py_CLEAR(state->lower);
227      Py_CLEAR(state->match_case_type);
228      Py_CLEAR(state->mod_type);
229      Py_CLEAR(state->module);
230      Py_CLEAR(state->msg);
231      Py_CLEAR(state->name);
232      Py_CLEAR(state->names);
233      Py_CLEAR(state->op);
234      Py_CLEAR(state->operand);
235      Py_CLEAR(state->operator_type);
236      Py_CLEAR(state->ops);
237      Py_CLEAR(state->optional_vars);
238      Py_CLEAR(state->orelse);
239      Py_CLEAR(state->pattern);
240      Py_CLEAR(state->pattern_type);
241      Py_CLEAR(state->patterns);
242      Py_CLEAR(state->posonlyargs);
243      Py_CLEAR(state->rest);
244      Py_CLEAR(state->returns);
245      Py_CLEAR(state->right);
246      Py_CLEAR(state->simple);
247      Py_CLEAR(state->slice);
248      Py_CLEAR(state->step);
249      Py_CLEAR(state->stmt_type);
250      Py_CLEAR(state->subject);
251      Py_CLEAR(state->tag);
252      Py_CLEAR(state->target);
253      Py_CLEAR(state->targets);
254      Py_CLEAR(state->test);
255      Py_CLEAR(state->type);
256      Py_CLEAR(state->type_comment);
257      Py_CLEAR(state->type_ignore_type);
258      Py_CLEAR(state->type_ignores);
259      Py_CLEAR(state->unaryop_type);
260      Py_CLEAR(state->upper);
261      Py_CLEAR(state->value);
262      Py_CLEAR(state->values);
263      Py_CLEAR(state->vararg);
264      Py_CLEAR(state->withitem_type);
265  
266  #if !defined(NDEBUG)
267      state->initialized = -1;
268  #else
269      state->initialized = 0;
270  #endif
271  }
272  
init_identifiers(struct ast_state * state)273  static int init_identifiers(struct ast_state *state)
274  {
275      if ((state->__dict__ = PyUnicode_InternFromString("__dict__")) == NULL) return 0;
276      if ((state->__doc__ = PyUnicode_InternFromString("__doc__")) == NULL) return 0;
277      if ((state->__match_args__ = PyUnicode_InternFromString("__match_args__")) == NULL) return 0;
278      if ((state->__module__ = PyUnicode_InternFromString("__module__")) == NULL) return 0;
279      if ((state->_attributes = PyUnicode_InternFromString("_attributes")) == NULL) return 0;
280      if ((state->_fields = PyUnicode_InternFromString("_fields")) == NULL) return 0;
281      if ((state->annotation = PyUnicode_InternFromString("annotation")) == NULL) return 0;
282      if ((state->arg = PyUnicode_InternFromString("arg")) == NULL) return 0;
283      if ((state->args = PyUnicode_InternFromString("args")) == NULL) return 0;
284      if ((state->argtypes = PyUnicode_InternFromString("argtypes")) == NULL) return 0;
285      if ((state->asname = PyUnicode_InternFromString("asname")) == NULL) return 0;
286      if ((state->ast = PyUnicode_InternFromString("ast")) == NULL) return 0;
287      if ((state->attr = PyUnicode_InternFromString("attr")) == NULL) return 0;
288      if ((state->bases = PyUnicode_InternFromString("bases")) == NULL) return 0;
289      if ((state->body = PyUnicode_InternFromString("body")) == NULL) return 0;
290      if ((state->cases = PyUnicode_InternFromString("cases")) == NULL) return 0;
291      if ((state->cause = PyUnicode_InternFromString("cause")) == NULL) return 0;
292      if ((state->cls = PyUnicode_InternFromString("cls")) == NULL) return 0;
293      if ((state->col_offset = PyUnicode_InternFromString("col_offset")) == NULL) return 0;
294      if ((state->comparators = PyUnicode_InternFromString("comparators")) == NULL) return 0;
295      if ((state->context_expr = PyUnicode_InternFromString("context_expr")) == NULL) return 0;
296      if ((state->conversion = PyUnicode_InternFromString("conversion")) == NULL) return 0;
297      if ((state->ctx = PyUnicode_InternFromString("ctx")) == NULL) return 0;
298      if ((state->decorator_list = PyUnicode_InternFromString("decorator_list")) == NULL) return 0;
299      if ((state->defaults = PyUnicode_InternFromString("defaults")) == NULL) return 0;
300      if ((state->elt = PyUnicode_InternFromString("elt")) == NULL) return 0;
301      if ((state->elts = PyUnicode_InternFromString("elts")) == NULL) return 0;
302      if ((state->end_col_offset = PyUnicode_InternFromString("end_col_offset")) == NULL) return 0;
303      if ((state->end_lineno = PyUnicode_InternFromString("end_lineno")) == NULL) return 0;
304      if ((state->exc = PyUnicode_InternFromString("exc")) == NULL) return 0;
305      if ((state->finalbody = PyUnicode_InternFromString("finalbody")) == NULL) return 0;
306      if ((state->format_spec = PyUnicode_InternFromString("format_spec")) == NULL) return 0;
307      if ((state->func = PyUnicode_InternFromString("func")) == NULL) return 0;
308      if ((state->generators = PyUnicode_InternFromString("generators")) == NULL) return 0;
309      if ((state->guard = PyUnicode_InternFromString("guard")) == NULL) return 0;
310      if ((state->handlers = PyUnicode_InternFromString("handlers")) == NULL) return 0;
311      if ((state->id = PyUnicode_InternFromString("id")) == NULL) return 0;
312      if ((state->ifs = PyUnicode_InternFromString("ifs")) == NULL) return 0;
313      if ((state->is_async = PyUnicode_InternFromString("is_async")) == NULL) return 0;
314      if ((state->items = PyUnicode_InternFromString("items")) == NULL) return 0;
315      if ((state->iter = PyUnicode_InternFromString("iter")) == NULL) return 0;
316      if ((state->key = PyUnicode_InternFromString("key")) == NULL) return 0;
317      if ((state->keys = PyUnicode_InternFromString("keys")) == NULL) return 0;
318      if ((state->keywords = PyUnicode_InternFromString("keywords")) == NULL) return 0;
319      if ((state->kind = PyUnicode_InternFromString("kind")) == NULL) return 0;
320      if ((state->kw_defaults = PyUnicode_InternFromString("kw_defaults")) == NULL) return 0;
321      if ((state->kwarg = PyUnicode_InternFromString("kwarg")) == NULL) return 0;
322      if ((state->kwd_attrs = PyUnicode_InternFromString("kwd_attrs")) == NULL) return 0;
323      if ((state->kwd_patterns = PyUnicode_InternFromString("kwd_patterns")) == NULL) return 0;
324      if ((state->kwonlyargs = PyUnicode_InternFromString("kwonlyargs")) == NULL) return 0;
325      if ((state->left = PyUnicode_InternFromString("left")) == NULL) return 0;
326      if ((state->level = PyUnicode_InternFromString("level")) == NULL) return 0;
327      if ((state->lineno = PyUnicode_InternFromString("lineno")) == NULL) return 0;
328      if ((state->lower = PyUnicode_InternFromString("lower")) == NULL) return 0;
329      if ((state->module = PyUnicode_InternFromString("module")) == NULL) return 0;
330      if ((state->msg = PyUnicode_InternFromString("msg")) == NULL) return 0;
331      if ((state->name = PyUnicode_InternFromString("name")) == NULL) return 0;
332      if ((state->names = PyUnicode_InternFromString("names")) == NULL) return 0;
333      if ((state->op = PyUnicode_InternFromString("op")) == NULL) return 0;
334      if ((state->operand = PyUnicode_InternFromString("operand")) == NULL) return 0;
335      if ((state->ops = PyUnicode_InternFromString("ops")) == NULL) return 0;
336      if ((state->optional_vars = PyUnicode_InternFromString("optional_vars")) == NULL) return 0;
337      if ((state->orelse = PyUnicode_InternFromString("orelse")) == NULL) return 0;
338      if ((state->pattern = PyUnicode_InternFromString("pattern")) == NULL) return 0;
339      if ((state->patterns = PyUnicode_InternFromString("patterns")) == NULL) return 0;
340      if ((state->posonlyargs = PyUnicode_InternFromString("posonlyargs")) == NULL) return 0;
341      if ((state->rest = PyUnicode_InternFromString("rest")) == NULL) return 0;
342      if ((state->returns = PyUnicode_InternFromString("returns")) == NULL) return 0;
343      if ((state->right = PyUnicode_InternFromString("right")) == NULL) return 0;
344      if ((state->simple = PyUnicode_InternFromString("simple")) == NULL) return 0;
345      if ((state->slice = PyUnicode_InternFromString("slice")) == NULL) return 0;
346      if ((state->step = PyUnicode_InternFromString("step")) == NULL) return 0;
347      if ((state->subject = PyUnicode_InternFromString("subject")) == NULL) return 0;
348      if ((state->tag = PyUnicode_InternFromString("tag")) == NULL) return 0;
349      if ((state->target = PyUnicode_InternFromString("target")) == NULL) return 0;
350      if ((state->targets = PyUnicode_InternFromString("targets")) == NULL) return 0;
351      if ((state->test = PyUnicode_InternFromString("test")) == NULL) return 0;
352      if ((state->type = PyUnicode_InternFromString("type")) == NULL) return 0;
353      if ((state->type_comment = PyUnicode_InternFromString("type_comment")) == NULL) return 0;
354      if ((state->type_ignores = PyUnicode_InternFromString("type_ignores")) == NULL) return 0;
355      if ((state->upper = PyUnicode_InternFromString("upper")) == NULL) return 0;
356      if ((state->value = PyUnicode_InternFromString("value")) == NULL) return 0;
357      if ((state->values = PyUnicode_InternFromString("values")) == NULL) return 0;
358      if ((state->vararg = PyUnicode_InternFromString("vararg")) == NULL) return 0;
359      return 1;
360  };
361  
362  GENERATE_ASDL_SEQ_CONSTRUCTOR(mod, mod_ty)
363  GENERATE_ASDL_SEQ_CONSTRUCTOR(stmt, stmt_ty)
364  GENERATE_ASDL_SEQ_CONSTRUCTOR(expr, expr_ty)
365  GENERATE_ASDL_SEQ_CONSTRUCTOR(comprehension, comprehension_ty)
366  GENERATE_ASDL_SEQ_CONSTRUCTOR(excepthandler, excepthandler_ty)
367  GENERATE_ASDL_SEQ_CONSTRUCTOR(arguments, arguments_ty)
368  GENERATE_ASDL_SEQ_CONSTRUCTOR(arg, arg_ty)
369  GENERATE_ASDL_SEQ_CONSTRUCTOR(keyword, keyword_ty)
370  GENERATE_ASDL_SEQ_CONSTRUCTOR(alias, alias_ty)
371  GENERATE_ASDL_SEQ_CONSTRUCTOR(withitem, withitem_ty)
372  GENERATE_ASDL_SEQ_CONSTRUCTOR(match_case, match_case_ty)
373  GENERATE_ASDL_SEQ_CONSTRUCTOR(pattern, pattern_ty)
374  GENERATE_ASDL_SEQ_CONSTRUCTOR(type_ignore, type_ignore_ty)
375  
376  static PyObject* ast2obj_mod(struct ast_state *state, void*);
377  static const char * const Module_fields[]={
378      "body",
379      "type_ignores",
380  };
381  static const char * const Interactive_fields[]={
382      "body",
383  };
384  static const char * const Expression_fields[]={
385      "body",
386  };
387  static const char * const FunctionType_fields[]={
388      "argtypes",
389      "returns",
390  };
391  static const char * const stmt_attributes[] = {
392      "lineno",
393      "col_offset",
394      "end_lineno",
395      "end_col_offset",
396  };
397  static PyObject* ast2obj_stmt(struct ast_state *state, void*);
398  static const char * const FunctionDef_fields[]={
399      "name",
400      "args",
401      "body",
402      "decorator_list",
403      "returns",
404      "type_comment",
405  };
406  static const char * const AsyncFunctionDef_fields[]={
407      "name",
408      "args",
409      "body",
410      "decorator_list",
411      "returns",
412      "type_comment",
413  };
414  static const char * const ClassDef_fields[]={
415      "name",
416      "bases",
417      "keywords",
418      "body",
419      "decorator_list",
420  };
421  static const char * const Return_fields[]={
422      "value",
423  };
424  static const char * const Delete_fields[]={
425      "targets",
426  };
427  static const char * const Assign_fields[]={
428      "targets",
429      "value",
430      "type_comment",
431  };
432  static const char * const AugAssign_fields[]={
433      "target",
434      "op",
435      "value",
436  };
437  static const char * const AnnAssign_fields[]={
438      "target",
439      "annotation",
440      "value",
441      "simple",
442  };
443  static const char * const For_fields[]={
444      "target",
445      "iter",
446      "body",
447      "orelse",
448      "type_comment",
449  };
450  static const char * const AsyncFor_fields[]={
451      "target",
452      "iter",
453      "body",
454      "orelse",
455      "type_comment",
456  };
457  static const char * const While_fields[]={
458      "test",
459      "body",
460      "orelse",
461  };
462  static const char * const If_fields[]={
463      "test",
464      "body",
465      "orelse",
466  };
467  static const char * const With_fields[]={
468      "items",
469      "body",
470      "type_comment",
471  };
472  static const char * const AsyncWith_fields[]={
473      "items",
474      "body",
475      "type_comment",
476  };
477  static const char * const Match_fields[]={
478      "subject",
479      "cases",
480  };
481  static const char * const Raise_fields[]={
482      "exc",
483      "cause",
484  };
485  static const char * const Try_fields[]={
486      "body",
487      "handlers",
488      "orelse",
489      "finalbody",
490  };
491  static const char * const TryStar_fields[]={
492      "body",
493      "handlers",
494      "orelse",
495      "finalbody",
496  };
497  static const char * const Assert_fields[]={
498      "test",
499      "msg",
500  };
501  static const char * const Import_fields[]={
502      "names",
503  };
504  static const char * const ImportFrom_fields[]={
505      "module",
506      "names",
507      "level",
508  };
509  static const char * const Global_fields[]={
510      "names",
511  };
512  static const char * const Nonlocal_fields[]={
513      "names",
514  };
515  static const char * const Expr_fields[]={
516      "value",
517  };
518  static const char * const expr_attributes[] = {
519      "lineno",
520      "col_offset",
521      "end_lineno",
522      "end_col_offset",
523  };
524  static PyObject* ast2obj_expr(struct ast_state *state, void*);
525  static const char * const BoolOp_fields[]={
526      "op",
527      "values",
528  };
529  static const char * const NamedExpr_fields[]={
530      "target",
531      "value",
532  };
533  static const char * const BinOp_fields[]={
534      "left",
535      "op",
536      "right",
537  };
538  static const char * const UnaryOp_fields[]={
539      "op",
540      "operand",
541  };
542  static const char * const Lambda_fields[]={
543      "args",
544      "body",
545  };
546  static const char * const IfExp_fields[]={
547      "test",
548      "body",
549      "orelse",
550  };
551  static const char * const Dict_fields[]={
552      "keys",
553      "values",
554  };
555  static const char * const Set_fields[]={
556      "elts",
557  };
558  static const char * const ListComp_fields[]={
559      "elt",
560      "generators",
561  };
562  static const char * const SetComp_fields[]={
563      "elt",
564      "generators",
565  };
566  static const char * const DictComp_fields[]={
567      "key",
568      "value",
569      "generators",
570  };
571  static const char * const GeneratorExp_fields[]={
572      "elt",
573      "generators",
574  };
575  static const char * const Await_fields[]={
576      "value",
577  };
578  static const char * const Yield_fields[]={
579      "value",
580  };
581  static const char * const YieldFrom_fields[]={
582      "value",
583  };
584  static const char * const Compare_fields[]={
585      "left",
586      "ops",
587      "comparators",
588  };
589  static const char * const Call_fields[]={
590      "func",
591      "args",
592      "keywords",
593  };
594  static const char * const FormattedValue_fields[]={
595      "value",
596      "conversion",
597      "format_spec",
598  };
599  static const char * const JoinedStr_fields[]={
600      "values",
601  };
602  static const char * const Constant_fields[]={
603      "value",
604      "kind",
605  };
606  static const char * const Attribute_fields[]={
607      "value",
608      "attr",
609      "ctx",
610  };
611  static const char * const Subscript_fields[]={
612      "value",
613      "slice",
614      "ctx",
615  };
616  static const char * const Starred_fields[]={
617      "value",
618      "ctx",
619  };
620  static const char * const Name_fields[]={
621      "id",
622      "ctx",
623  };
624  static const char * const List_fields[]={
625      "elts",
626      "ctx",
627  };
628  static const char * const Tuple_fields[]={
629      "elts",
630      "ctx",
631  };
632  static const char * const Slice_fields[]={
633      "lower",
634      "upper",
635      "step",
636  };
637  static PyObject* ast2obj_expr_context(struct ast_state *state, expr_context_ty);
638  static PyObject* ast2obj_boolop(struct ast_state *state, boolop_ty);
639  static PyObject* ast2obj_operator(struct ast_state *state, operator_ty);
640  static PyObject* ast2obj_unaryop(struct ast_state *state, unaryop_ty);
641  static PyObject* ast2obj_cmpop(struct ast_state *state, cmpop_ty);
642  static PyObject* ast2obj_comprehension(struct ast_state *state, void*);
643  static const char * const comprehension_fields[]={
644      "target",
645      "iter",
646      "ifs",
647      "is_async",
648  };
649  static const char * const excepthandler_attributes[] = {
650      "lineno",
651      "col_offset",
652      "end_lineno",
653      "end_col_offset",
654  };
655  static PyObject* ast2obj_excepthandler(struct ast_state *state, void*);
656  static const char * const ExceptHandler_fields[]={
657      "type",
658      "name",
659      "body",
660  };
661  static PyObject* ast2obj_arguments(struct ast_state *state, void*);
662  static const char * const arguments_fields[]={
663      "posonlyargs",
664      "args",
665      "vararg",
666      "kwonlyargs",
667      "kw_defaults",
668      "kwarg",
669      "defaults",
670  };
671  static PyObject* ast2obj_arg(struct ast_state *state, void*);
672  static const char * const arg_attributes[] = {
673      "lineno",
674      "col_offset",
675      "end_lineno",
676      "end_col_offset",
677  };
678  static const char * const arg_fields[]={
679      "arg",
680      "annotation",
681      "type_comment",
682  };
683  static PyObject* ast2obj_keyword(struct ast_state *state, void*);
684  static const char * const keyword_attributes[] = {
685      "lineno",
686      "col_offset",
687      "end_lineno",
688      "end_col_offset",
689  };
690  static const char * const keyword_fields[]={
691      "arg",
692      "value",
693  };
694  static PyObject* ast2obj_alias(struct ast_state *state, void*);
695  static const char * const alias_attributes[] = {
696      "lineno",
697      "col_offset",
698      "end_lineno",
699      "end_col_offset",
700  };
701  static const char * const alias_fields[]={
702      "name",
703      "asname",
704  };
705  static PyObject* ast2obj_withitem(struct ast_state *state, void*);
706  static const char * const withitem_fields[]={
707      "context_expr",
708      "optional_vars",
709  };
710  static PyObject* ast2obj_match_case(struct ast_state *state, void*);
711  static const char * const match_case_fields[]={
712      "pattern",
713      "guard",
714      "body",
715  };
716  static const char * const pattern_attributes[] = {
717      "lineno",
718      "col_offset",
719      "end_lineno",
720      "end_col_offset",
721  };
722  static PyObject* ast2obj_pattern(struct ast_state *state, void*);
723  static const char * const MatchValue_fields[]={
724      "value",
725  };
726  static const char * const MatchSingleton_fields[]={
727      "value",
728  };
729  static const char * const MatchSequence_fields[]={
730      "patterns",
731  };
732  static const char * const MatchMapping_fields[]={
733      "keys",
734      "patterns",
735      "rest",
736  };
737  static const char * const MatchClass_fields[]={
738      "cls",
739      "patterns",
740      "kwd_attrs",
741      "kwd_patterns",
742  };
743  static const char * const MatchStar_fields[]={
744      "name",
745  };
746  static const char * const MatchAs_fields[]={
747      "pattern",
748      "name",
749  };
750  static const char * const MatchOr_fields[]={
751      "patterns",
752  };
753  static PyObject* ast2obj_type_ignore(struct ast_state *state, void*);
754  static const char * const TypeIgnore_fields[]={
755      "lineno",
756      "tag",
757  };
758  
759  
760  
761  typedef struct {
762      PyObject_HEAD
763      PyObject *dict;
764  } AST_object;
765  
766  static void
ast_dealloc(AST_object * self)767  ast_dealloc(AST_object *self)
768  {
769      /* bpo-31095: UnTrack is needed before calling any callbacks */
770      PyTypeObject *tp = Py_TYPE(self);
771      PyObject_GC_UnTrack(self);
772      Py_CLEAR(self->dict);
773      freefunc free_func = PyType_GetSlot(tp, Py_tp_free);
774      assert(free_func != NULL);
775      free_func(self);
776      Py_DECREF(tp);
777  }
778  
779  static int
ast_traverse(AST_object * self,visitproc visit,void * arg)780  ast_traverse(AST_object *self, visitproc visit, void *arg)
781  {
782      Py_VISIT(Py_TYPE(self));
783      Py_VISIT(self->dict);
784      return 0;
785  }
786  
787  static int
ast_clear(AST_object * self)788  ast_clear(AST_object *self)
789  {
790      Py_CLEAR(self->dict);
791      return 0;
792  }
793  
794  static int
ast_type_init(PyObject * self,PyObject * args,PyObject * kw)795  ast_type_init(PyObject *self, PyObject *args, PyObject *kw)
796  {
797      struct ast_state *state = get_ast_state();
798      if (state == NULL) {
799          return -1;
800      }
801  
802      Py_ssize_t i, numfields = 0;
803      int res = -1;
804      PyObject *key, *value, *fields;
805      if (_PyObject_LookupAttr((PyObject*)Py_TYPE(self), state->_fields, &fields) < 0) {
806          goto cleanup;
807      }
808      if (fields) {
809          numfields = PySequence_Size(fields);
810          if (numfields == -1) {
811              goto cleanup;
812          }
813      }
814  
815      res = 0; /* if no error occurs, this stays 0 to the end */
816      if (numfields < PyTuple_GET_SIZE(args)) {
817          PyErr_Format(PyExc_TypeError, "%.400s constructor takes at most "
818                       "%zd positional argument%s",
819                       _PyType_Name(Py_TYPE(self)),
820                       numfields, numfields == 1 ? "" : "s");
821          res = -1;
822          goto cleanup;
823      }
824      for (i = 0; i < PyTuple_GET_SIZE(args); i++) {
825          /* cannot be reached when fields is NULL */
826          PyObject *name = PySequence_GetItem(fields, i);
827          if (!name) {
828              res = -1;
829              goto cleanup;
830          }
831          res = PyObject_SetAttr(self, name, PyTuple_GET_ITEM(args, i));
832          Py_DECREF(name);
833          if (res < 0) {
834              goto cleanup;
835          }
836      }
837      if (kw) {
838          i = 0;  /* needed by PyDict_Next */
839          while (PyDict_Next(kw, &i, &key, &value)) {
840              int contains = PySequence_Contains(fields, key);
841              if (contains == -1) {
842                  res = -1;
843                  goto cleanup;
844              } else if (contains == 1) {
845                  Py_ssize_t p = PySequence_Index(fields, key);
846                  if (p == -1) {
847                      res = -1;
848                      goto cleanup;
849                  }
850                  if (p < PyTuple_GET_SIZE(args)) {
851                      PyErr_Format(PyExc_TypeError,
852                          "%.400s got multiple values for argument '%U'",
853                          Py_TYPE(self)->tp_name, key);
854                      res = -1;
855                      goto cleanup;
856                  }
857              }
858              res = PyObject_SetAttr(self, key, value);
859              if (res < 0) {
860                  goto cleanup;
861              }
862          }
863      }
864    cleanup:
865      Py_XDECREF(fields);
866      return res;
867  }
868  
869  /* Pickling support */
870  static PyObject *
ast_type_reduce(PyObject * self,PyObject * unused)871  ast_type_reduce(PyObject *self, PyObject *unused)
872  {
873      struct ast_state *state = get_ast_state();
874      if (state == NULL) {
875          return NULL;
876      }
877  
878      PyObject *dict;
879      if (_PyObject_LookupAttr(self, state->__dict__, &dict) < 0) {
880          return NULL;
881      }
882      if (dict) {
883          return Py_BuildValue("O()N", Py_TYPE(self), dict);
884      }
885      return Py_BuildValue("O()", Py_TYPE(self));
886  }
887  
888  static PyMemberDef ast_type_members[] = {
889      {"__dictoffset__", T_PYSSIZET, offsetof(AST_object, dict), READONLY},
890      {NULL}  /* Sentinel */
891  };
892  
893  static PyMethodDef ast_type_methods[] = {
894      {"__reduce__", ast_type_reduce, METH_NOARGS, NULL},
895      {NULL}
896  };
897  
898  static PyGetSetDef ast_type_getsets[] = {
899      {"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict},
900      {NULL}
901  };
902  
903  static PyType_Slot AST_type_slots[] = {
904      {Py_tp_dealloc, ast_dealloc},
905      {Py_tp_getattro, PyObject_GenericGetAttr},
906      {Py_tp_setattro, PyObject_GenericSetAttr},
907      {Py_tp_traverse, ast_traverse},
908      {Py_tp_clear, ast_clear},
909      {Py_tp_members, ast_type_members},
910      {Py_tp_methods, ast_type_methods},
911      {Py_tp_getset, ast_type_getsets},
912      {Py_tp_init, ast_type_init},
913      {Py_tp_alloc, PyType_GenericAlloc},
914      {Py_tp_new, PyType_GenericNew},
915      {Py_tp_free, PyObject_GC_Del},
916      {0, 0},
917  };
918  
919  static PyType_Spec AST_type_spec = {
920      "ast.AST",
921      sizeof(AST_object),
922      0,
923      Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
924      AST_type_slots
925  };
926  
927  static PyObject *
make_type(struct ast_state * state,const char * type,PyObject * base,const char * const * fields,int num_fields,const char * doc)928  make_type(struct ast_state *state, const char *type, PyObject* base,
929            const char* const* fields, int num_fields, const char *doc)
930  {
931      PyObject *fnames, *result;
932      int i;
933      fnames = PyTuple_New(num_fields);
934      if (!fnames) return NULL;
935      for (i = 0; i < num_fields; i++) {
936          PyObject *field = PyUnicode_InternFromString(fields[i]);
937          if (!field) {
938              Py_DECREF(fnames);
939              return NULL;
940          }
941          PyTuple_SET_ITEM(fnames, i, field);
942      }
943      result = PyObject_CallFunction((PyObject*)&PyType_Type, "s(O){OOOOOOOs}",
944                      type, base,
945                      state->_fields, fnames,
946                      state->__match_args__, fnames,
947                      state->__module__,
948                      state->ast,
949                      state->__doc__, doc);
950      Py_DECREF(fnames);
951      return result;
952  }
953  
954  static int
add_attributes(struct ast_state * state,PyObject * type,const char * const * attrs,int num_fields)955  add_attributes(struct ast_state *state, PyObject *type, const char * const *attrs, int num_fields)
956  {
957      int i, result;
958      PyObject *s, *l = PyTuple_New(num_fields);
959      if (!l)
960          return 0;
961      for (i = 0; i < num_fields; i++) {
962          s = PyUnicode_InternFromString(attrs[i]);
963          if (!s) {
964              Py_DECREF(l);
965              return 0;
966          }
967          PyTuple_SET_ITEM(l, i, s);
968      }
969      result = PyObject_SetAttr(type, state->_attributes, l) >= 0;
970      Py_DECREF(l);
971      return result;
972  }
973  
974  /* Conversion AST -> Python */
975  
ast2obj_list(struct ast_state * state,asdl_seq * seq,PyObject * (* func)(struct ast_state * state,void *))976  static PyObject* ast2obj_list(struct ast_state *state, asdl_seq *seq, PyObject* (*func)(struct ast_state *state, void*))
977  {
978      Py_ssize_t i, n = asdl_seq_LEN(seq);
979      PyObject *result = PyList_New(n);
980      PyObject *value;
981      if (!result)
982          return NULL;
983      for (i = 0; i < n; i++) {
984          value = func(state, asdl_seq_GET_UNTYPED(seq, i));
985          if (!value) {
986              Py_DECREF(result);
987              return NULL;
988          }
989          PyList_SET_ITEM(result, i, value);
990      }
991      return result;
992  }
993  
ast2obj_object(struct ast_state * Py_UNUSED (state),void * o)994  static PyObject* ast2obj_object(struct ast_state *Py_UNUSED(state), void *o)
995  {
996      if (!o)
997          o = Py_None;
998      Py_INCREF((PyObject*)o);
999      return (PyObject*)o;
1000  }
1001  #define ast2obj_constant ast2obj_object
1002  #define ast2obj_identifier ast2obj_object
1003  #define ast2obj_string ast2obj_object
1004  
ast2obj_int(struct ast_state * Py_UNUSED (state),long b)1005  static PyObject* ast2obj_int(struct ast_state *Py_UNUSED(state), long b)
1006  {
1007      return PyLong_FromLong(b);
1008  }
1009  
1010  /* Conversion Python -> AST */
1011  
obj2ast_object(struct ast_state * Py_UNUSED (state),PyObject * obj,PyObject ** out,PyArena * arena)1012  static int obj2ast_object(struct ast_state *Py_UNUSED(state), PyObject* obj, PyObject** out, PyArena* arena)
1013  {
1014      if (obj == Py_None)
1015          obj = NULL;
1016      if (obj) {
1017          if (_PyArena_AddPyObject(arena, obj) < 0) {
1018              *out = NULL;
1019              return -1;
1020          }
1021          Py_INCREF(obj);
1022      }
1023      *out = obj;
1024      return 0;
1025  }
1026  
obj2ast_constant(struct ast_state * Py_UNUSED (state),PyObject * obj,PyObject ** out,PyArena * arena)1027  static int obj2ast_constant(struct ast_state *Py_UNUSED(state), PyObject* obj, PyObject** out, PyArena* arena)
1028  {
1029      if (_PyArena_AddPyObject(arena, obj) < 0) {
1030          *out = NULL;
1031          return -1;
1032      }
1033      Py_INCREF(obj);
1034      *out = obj;
1035      return 0;
1036  }
1037  
obj2ast_identifier(struct ast_state * state,PyObject * obj,PyObject ** out,PyArena * arena)1038  static int obj2ast_identifier(struct ast_state *state, PyObject* obj, PyObject** out, PyArena* arena)
1039  {
1040      if (!PyUnicode_CheckExact(obj) && obj != Py_None) {
1041          PyErr_SetString(PyExc_TypeError, "AST identifier must be of type str");
1042          return 1;
1043      }
1044      return obj2ast_object(state, obj, out, arena);
1045  }
1046  
obj2ast_string(struct ast_state * state,PyObject * obj,PyObject ** out,PyArena * arena)1047  static int obj2ast_string(struct ast_state *state, PyObject* obj, PyObject** out, PyArena* arena)
1048  {
1049      if (!PyUnicode_CheckExact(obj) && !PyBytes_CheckExact(obj)) {
1050          PyErr_SetString(PyExc_TypeError, "AST string must be of type str");
1051          return 1;
1052      }
1053      return obj2ast_object(state, obj, out, arena);
1054  }
1055  
obj2ast_int(struct ast_state * Py_UNUSED (state),PyObject * obj,int * out,PyArena * arena)1056  static int obj2ast_int(struct ast_state* Py_UNUSED(state), PyObject* obj, int* out, PyArena* arena)
1057  {
1058      int i;
1059      if (!PyLong_Check(obj)) {
1060          PyErr_Format(PyExc_ValueError, "invalid integer value: %R", obj);
1061          return 1;
1062      }
1063  
1064      i = _PyLong_AsInt(obj);
1065      if (i == -1 && PyErr_Occurred())
1066          return 1;
1067      *out = i;
1068      return 0;
1069  }
1070  
add_ast_fields(struct ast_state * state)1071  static int add_ast_fields(struct ast_state *state)
1072  {
1073      PyObject *empty_tuple;
1074      empty_tuple = PyTuple_New(0);
1075      if (!empty_tuple ||
1076          PyObject_SetAttrString(state->AST_type, "_fields", empty_tuple) < 0 ||
1077          PyObject_SetAttrString(state->AST_type, "__match_args__", empty_tuple) < 0 ||
1078          PyObject_SetAttrString(state->AST_type, "_attributes", empty_tuple) < 0) {
1079          Py_XDECREF(empty_tuple);
1080          return -1;
1081      }
1082      Py_DECREF(empty_tuple);
1083      return 0;
1084  }
1085  
1086  
1087  
1088  static int
init_types(struct ast_state * state)1089  init_types(struct ast_state *state)
1090  {
1091      // init_types() must not be called after _PyAST_Fini()
1092      // has been called
1093      assert(state->initialized >= 0);
1094  
1095      if (state->initialized) {
1096          return 1;
1097      }
1098      if (init_identifiers(state) < 0) {
1099          return 0;
1100      }
1101      state->AST_type = PyType_FromSpec(&AST_type_spec);
1102      if (!state->AST_type) {
1103          return 0;
1104      }
1105      if (add_ast_fields(state) < 0) {
1106          return 0;
1107      }
1108      state->mod_type = make_type(state, "mod", state->AST_type, NULL, 0,
1109          "mod = Module(stmt* body, type_ignore* type_ignores)\n"
1110          "    | Interactive(stmt* body)\n"
1111          "    | Expression(expr body)\n"
1112          "    | FunctionType(expr* argtypes, expr returns)");
1113      if (!state->mod_type) return 0;
1114      if (!add_attributes(state, state->mod_type, NULL, 0)) return 0;
1115      state->Module_type = make_type(state, "Module", state->mod_type,
1116                                     Module_fields, 2,
1117          "Module(stmt* body, type_ignore* type_ignores)");
1118      if (!state->Module_type) return 0;
1119      state->Interactive_type = make_type(state, "Interactive", state->mod_type,
1120                                          Interactive_fields, 1,
1121          "Interactive(stmt* body)");
1122      if (!state->Interactive_type) return 0;
1123      state->Expression_type = make_type(state, "Expression", state->mod_type,
1124                                         Expression_fields, 1,
1125          "Expression(expr body)");
1126      if (!state->Expression_type) return 0;
1127      state->FunctionType_type = make_type(state, "FunctionType",
1128                                           state->mod_type, FunctionType_fields,
1129                                           2,
1130          "FunctionType(expr* argtypes, expr returns)");
1131      if (!state->FunctionType_type) return 0;
1132      state->stmt_type = make_type(state, "stmt", state->AST_type, NULL, 0,
1133          "stmt = FunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)\n"
1134          "     | AsyncFunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)\n"
1135          "     | ClassDef(identifier name, expr* bases, keyword* keywords, stmt* body, expr* decorator_list)\n"
1136          "     | Return(expr? value)\n"
1137          "     | Delete(expr* targets)\n"
1138          "     | Assign(expr* targets, expr value, string? type_comment)\n"
1139          "     | AugAssign(expr target, operator op, expr value)\n"
1140          "     | AnnAssign(expr target, expr annotation, expr? value, int simple)\n"
1141          "     | For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)\n"
1142          "     | AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)\n"
1143          "     | While(expr test, stmt* body, stmt* orelse)\n"
1144          "     | If(expr test, stmt* body, stmt* orelse)\n"
1145          "     | With(withitem* items, stmt* body, string? type_comment)\n"
1146          "     | AsyncWith(withitem* items, stmt* body, string? type_comment)\n"
1147          "     | Match(expr subject, match_case* cases)\n"
1148          "     | Raise(expr? exc, expr? cause)\n"
1149          "     | Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)\n"
1150          "     | TryStar(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)\n"
1151          "     | Assert(expr test, expr? msg)\n"
1152          "     | Import(alias* names)\n"
1153          "     | ImportFrom(identifier? module, alias* names, int? level)\n"
1154          "     | Global(identifier* names)\n"
1155          "     | Nonlocal(identifier* names)\n"
1156          "     | Expr(expr value)\n"
1157          "     | Pass\n"
1158          "     | Break\n"
1159          "     | Continue");
1160      if (!state->stmt_type) return 0;
1161      if (!add_attributes(state, state->stmt_type, stmt_attributes, 4)) return 0;
1162      if (PyObject_SetAttr(state->stmt_type, state->end_lineno, Py_None) == -1)
1163          return 0;
1164      if (PyObject_SetAttr(state->stmt_type, state->end_col_offset, Py_None) ==
1165          -1)
1166          return 0;
1167      state->FunctionDef_type = make_type(state, "FunctionDef", state->stmt_type,
1168                                          FunctionDef_fields, 6,
1169          "FunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)");
1170      if (!state->FunctionDef_type) return 0;
1171      if (PyObject_SetAttr(state->FunctionDef_type, state->returns, Py_None) ==
1172          -1)
1173          return 0;
1174      if (PyObject_SetAttr(state->FunctionDef_type, state->type_comment, Py_None)
1175          == -1)
1176          return 0;
1177      state->AsyncFunctionDef_type = make_type(state, "AsyncFunctionDef",
1178                                               state->stmt_type,
1179                                               AsyncFunctionDef_fields, 6,
1180          "AsyncFunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)");
1181      if (!state->AsyncFunctionDef_type) return 0;
1182      if (PyObject_SetAttr(state->AsyncFunctionDef_type, state->returns, Py_None)
1183          == -1)
1184          return 0;
1185      if (PyObject_SetAttr(state->AsyncFunctionDef_type, state->type_comment,
1186          Py_None) == -1)
1187          return 0;
1188      state->ClassDef_type = make_type(state, "ClassDef", state->stmt_type,
1189                                       ClassDef_fields, 5,
1190          "ClassDef(identifier name, expr* bases, keyword* keywords, stmt* body, expr* decorator_list)");
1191      if (!state->ClassDef_type) return 0;
1192      state->Return_type = make_type(state, "Return", state->stmt_type,
1193                                     Return_fields, 1,
1194          "Return(expr? value)");
1195      if (!state->Return_type) return 0;
1196      if (PyObject_SetAttr(state->Return_type, state->value, Py_None) == -1)
1197          return 0;
1198      state->Delete_type = make_type(state, "Delete", state->stmt_type,
1199                                     Delete_fields, 1,
1200          "Delete(expr* targets)");
1201      if (!state->Delete_type) return 0;
1202      state->Assign_type = make_type(state, "Assign", state->stmt_type,
1203                                     Assign_fields, 3,
1204          "Assign(expr* targets, expr value, string? type_comment)");
1205      if (!state->Assign_type) return 0;
1206      if (PyObject_SetAttr(state->Assign_type, state->type_comment, Py_None) ==
1207          -1)
1208          return 0;
1209      state->AugAssign_type = make_type(state, "AugAssign", state->stmt_type,
1210                                        AugAssign_fields, 3,
1211          "AugAssign(expr target, operator op, expr value)");
1212      if (!state->AugAssign_type) return 0;
1213      state->AnnAssign_type = make_type(state, "AnnAssign", state->stmt_type,
1214                                        AnnAssign_fields, 4,
1215          "AnnAssign(expr target, expr annotation, expr? value, int simple)");
1216      if (!state->AnnAssign_type) return 0;
1217      if (PyObject_SetAttr(state->AnnAssign_type, state->value, Py_None) == -1)
1218          return 0;
1219      state->For_type = make_type(state, "For", state->stmt_type, For_fields, 5,
1220          "For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)");
1221      if (!state->For_type) return 0;
1222      if (PyObject_SetAttr(state->For_type, state->type_comment, Py_None) == -1)
1223          return 0;
1224      state->AsyncFor_type = make_type(state, "AsyncFor", state->stmt_type,
1225                                       AsyncFor_fields, 5,
1226          "AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)");
1227      if (!state->AsyncFor_type) return 0;
1228      if (PyObject_SetAttr(state->AsyncFor_type, state->type_comment, Py_None) ==
1229          -1)
1230          return 0;
1231      state->While_type = make_type(state, "While", state->stmt_type,
1232                                    While_fields, 3,
1233          "While(expr test, stmt* body, stmt* orelse)");
1234      if (!state->While_type) return 0;
1235      state->If_type = make_type(state, "If", state->stmt_type, If_fields, 3,
1236          "If(expr test, stmt* body, stmt* orelse)");
1237      if (!state->If_type) return 0;
1238      state->With_type = make_type(state, "With", state->stmt_type, With_fields,
1239                                   3,
1240          "With(withitem* items, stmt* body, string? type_comment)");
1241      if (!state->With_type) return 0;
1242      if (PyObject_SetAttr(state->With_type, state->type_comment, Py_None) == -1)
1243          return 0;
1244      state->AsyncWith_type = make_type(state, "AsyncWith", state->stmt_type,
1245                                        AsyncWith_fields, 3,
1246          "AsyncWith(withitem* items, stmt* body, string? type_comment)");
1247      if (!state->AsyncWith_type) return 0;
1248      if (PyObject_SetAttr(state->AsyncWith_type, state->type_comment, Py_None)
1249          == -1)
1250          return 0;
1251      state->Match_type = make_type(state, "Match", state->stmt_type,
1252                                    Match_fields, 2,
1253          "Match(expr subject, match_case* cases)");
1254      if (!state->Match_type) return 0;
1255      state->Raise_type = make_type(state, "Raise", state->stmt_type,
1256                                    Raise_fields, 2,
1257          "Raise(expr? exc, expr? cause)");
1258      if (!state->Raise_type) return 0;
1259      if (PyObject_SetAttr(state->Raise_type, state->exc, Py_None) == -1)
1260          return 0;
1261      if (PyObject_SetAttr(state->Raise_type, state->cause, Py_None) == -1)
1262          return 0;
1263      state->Try_type = make_type(state, "Try", state->stmt_type, Try_fields, 4,
1264          "Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)");
1265      if (!state->Try_type) return 0;
1266      state->TryStar_type = make_type(state, "TryStar", state->stmt_type,
1267                                      TryStar_fields, 4,
1268          "TryStar(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)");
1269      if (!state->TryStar_type) return 0;
1270      state->Assert_type = make_type(state, "Assert", state->stmt_type,
1271                                     Assert_fields, 2,
1272          "Assert(expr test, expr? msg)");
1273      if (!state->Assert_type) return 0;
1274      if (PyObject_SetAttr(state->Assert_type, state->msg, Py_None) == -1)
1275          return 0;
1276      state->Import_type = make_type(state, "Import", state->stmt_type,
1277                                     Import_fields, 1,
1278          "Import(alias* names)");
1279      if (!state->Import_type) return 0;
1280      state->ImportFrom_type = make_type(state, "ImportFrom", state->stmt_type,
1281                                         ImportFrom_fields, 3,
1282          "ImportFrom(identifier? module, alias* names, int? level)");
1283      if (!state->ImportFrom_type) return 0;
1284      if (PyObject_SetAttr(state->ImportFrom_type, state->module, Py_None) == -1)
1285          return 0;
1286      if (PyObject_SetAttr(state->ImportFrom_type, state->level, Py_None) == -1)
1287          return 0;
1288      state->Global_type = make_type(state, "Global", state->stmt_type,
1289                                     Global_fields, 1,
1290          "Global(identifier* names)");
1291      if (!state->Global_type) return 0;
1292      state->Nonlocal_type = make_type(state, "Nonlocal", state->stmt_type,
1293                                       Nonlocal_fields, 1,
1294          "Nonlocal(identifier* names)");
1295      if (!state->Nonlocal_type) return 0;
1296      state->Expr_type = make_type(state, "Expr", state->stmt_type, Expr_fields,
1297                                   1,
1298          "Expr(expr value)");
1299      if (!state->Expr_type) return 0;
1300      state->Pass_type = make_type(state, "Pass", state->stmt_type, NULL, 0,
1301          "Pass");
1302      if (!state->Pass_type) return 0;
1303      state->Break_type = make_type(state, "Break", state->stmt_type, NULL, 0,
1304          "Break");
1305      if (!state->Break_type) return 0;
1306      state->Continue_type = make_type(state, "Continue", state->stmt_type, NULL,
1307                                       0,
1308          "Continue");
1309      if (!state->Continue_type) return 0;
1310      state->expr_type = make_type(state, "expr", state->AST_type, NULL, 0,
1311          "expr = BoolOp(boolop op, expr* values)\n"
1312          "     | NamedExpr(expr target, expr value)\n"
1313          "     | BinOp(expr left, operator op, expr right)\n"
1314          "     | UnaryOp(unaryop op, expr operand)\n"
1315          "     | Lambda(arguments args, expr body)\n"
1316          "     | IfExp(expr test, expr body, expr orelse)\n"
1317          "     | Dict(expr* keys, expr* values)\n"
1318          "     | Set(expr* elts)\n"
1319          "     | ListComp(expr elt, comprehension* generators)\n"
1320          "     | SetComp(expr elt, comprehension* generators)\n"
1321          "     | DictComp(expr key, expr value, comprehension* generators)\n"
1322          "     | GeneratorExp(expr elt, comprehension* generators)\n"
1323          "     | Await(expr value)\n"
1324          "     | Yield(expr? value)\n"
1325          "     | YieldFrom(expr value)\n"
1326          "     | Compare(expr left, cmpop* ops, expr* comparators)\n"
1327          "     | Call(expr func, expr* args, keyword* keywords)\n"
1328          "     | FormattedValue(expr value, int conversion, expr? format_spec)\n"
1329          "     | JoinedStr(expr* values)\n"
1330          "     | Constant(constant value, string? kind)\n"
1331          "     | Attribute(expr value, identifier attr, expr_context ctx)\n"
1332          "     | Subscript(expr value, expr slice, expr_context ctx)\n"
1333          "     | Starred(expr value, expr_context ctx)\n"
1334          "     | Name(identifier id, expr_context ctx)\n"
1335          "     | List(expr* elts, expr_context ctx)\n"
1336          "     | Tuple(expr* elts, expr_context ctx)\n"
1337          "     | Slice(expr? lower, expr? upper, expr? step)");
1338      if (!state->expr_type) return 0;
1339      if (!add_attributes(state, state->expr_type, expr_attributes, 4)) return 0;
1340      if (PyObject_SetAttr(state->expr_type, state->end_lineno, Py_None) == -1)
1341          return 0;
1342      if (PyObject_SetAttr(state->expr_type, state->end_col_offset, Py_None) ==
1343          -1)
1344          return 0;
1345      state->BoolOp_type = make_type(state, "BoolOp", state->expr_type,
1346                                     BoolOp_fields, 2,
1347          "BoolOp(boolop op, expr* values)");
1348      if (!state->BoolOp_type) return 0;
1349      state->NamedExpr_type = make_type(state, "NamedExpr", state->expr_type,
1350                                        NamedExpr_fields, 2,
1351          "NamedExpr(expr target, expr value)");
1352      if (!state->NamedExpr_type) return 0;
1353      state->BinOp_type = make_type(state, "BinOp", state->expr_type,
1354                                    BinOp_fields, 3,
1355          "BinOp(expr left, operator op, expr right)");
1356      if (!state->BinOp_type) return 0;
1357      state->UnaryOp_type = make_type(state, "UnaryOp", state->expr_type,
1358                                      UnaryOp_fields, 2,
1359          "UnaryOp(unaryop op, expr operand)");
1360      if (!state->UnaryOp_type) return 0;
1361      state->Lambda_type = make_type(state, "Lambda", state->expr_type,
1362                                     Lambda_fields, 2,
1363          "Lambda(arguments args, expr body)");
1364      if (!state->Lambda_type) return 0;
1365      state->IfExp_type = make_type(state, "IfExp", state->expr_type,
1366                                    IfExp_fields, 3,
1367          "IfExp(expr test, expr body, expr orelse)");
1368      if (!state->IfExp_type) return 0;
1369      state->Dict_type = make_type(state, "Dict", state->expr_type, Dict_fields,
1370                                   2,
1371          "Dict(expr* keys, expr* values)");
1372      if (!state->Dict_type) return 0;
1373      state->Set_type = make_type(state, "Set", state->expr_type, Set_fields, 1,
1374          "Set(expr* elts)");
1375      if (!state->Set_type) return 0;
1376      state->ListComp_type = make_type(state, "ListComp", state->expr_type,
1377                                       ListComp_fields, 2,
1378          "ListComp(expr elt, comprehension* generators)");
1379      if (!state->ListComp_type) return 0;
1380      state->SetComp_type = make_type(state, "SetComp", state->expr_type,
1381                                      SetComp_fields, 2,
1382          "SetComp(expr elt, comprehension* generators)");
1383      if (!state->SetComp_type) return 0;
1384      state->DictComp_type = make_type(state, "DictComp", state->expr_type,
1385                                       DictComp_fields, 3,
1386          "DictComp(expr key, expr value, comprehension* generators)");
1387      if (!state->DictComp_type) return 0;
1388      state->GeneratorExp_type = make_type(state, "GeneratorExp",
1389                                           state->expr_type, GeneratorExp_fields,
1390                                           2,
1391          "GeneratorExp(expr elt, comprehension* generators)");
1392      if (!state->GeneratorExp_type) return 0;
1393      state->Await_type = make_type(state, "Await", state->expr_type,
1394                                    Await_fields, 1,
1395          "Await(expr value)");
1396      if (!state->Await_type) return 0;
1397      state->Yield_type = make_type(state, "Yield", state->expr_type,
1398                                    Yield_fields, 1,
1399          "Yield(expr? value)");
1400      if (!state->Yield_type) return 0;
1401      if (PyObject_SetAttr(state->Yield_type, state->value, Py_None) == -1)
1402          return 0;
1403      state->YieldFrom_type = make_type(state, "YieldFrom", state->expr_type,
1404                                        YieldFrom_fields, 1,
1405          "YieldFrom(expr value)");
1406      if (!state->YieldFrom_type) return 0;
1407      state->Compare_type = make_type(state, "Compare", state->expr_type,
1408                                      Compare_fields, 3,
1409          "Compare(expr left, cmpop* ops, expr* comparators)");
1410      if (!state->Compare_type) return 0;
1411      state->Call_type = make_type(state, "Call", state->expr_type, Call_fields,
1412                                   3,
1413          "Call(expr func, expr* args, keyword* keywords)");
1414      if (!state->Call_type) return 0;
1415      state->FormattedValue_type = make_type(state, "FormattedValue",
1416                                             state->expr_type,
1417                                             FormattedValue_fields, 3,
1418          "FormattedValue(expr value, int conversion, expr? format_spec)");
1419      if (!state->FormattedValue_type) return 0;
1420      if (PyObject_SetAttr(state->FormattedValue_type, state->format_spec,
1421          Py_None) == -1)
1422          return 0;
1423      state->JoinedStr_type = make_type(state, "JoinedStr", state->expr_type,
1424                                        JoinedStr_fields, 1,
1425          "JoinedStr(expr* values)");
1426      if (!state->JoinedStr_type) return 0;
1427      state->Constant_type = make_type(state, "Constant", state->expr_type,
1428                                       Constant_fields, 2,
1429          "Constant(constant value, string? kind)");
1430      if (!state->Constant_type) return 0;
1431      if (PyObject_SetAttr(state->Constant_type, state->kind, Py_None) == -1)
1432          return 0;
1433      state->Attribute_type = make_type(state, "Attribute", state->expr_type,
1434                                        Attribute_fields, 3,
1435          "Attribute(expr value, identifier attr, expr_context ctx)");
1436      if (!state->Attribute_type) return 0;
1437      state->Subscript_type = make_type(state, "Subscript", state->expr_type,
1438                                        Subscript_fields, 3,
1439          "Subscript(expr value, expr slice, expr_context ctx)");
1440      if (!state->Subscript_type) return 0;
1441      state->Starred_type = make_type(state, "Starred", state->expr_type,
1442                                      Starred_fields, 2,
1443          "Starred(expr value, expr_context ctx)");
1444      if (!state->Starred_type) return 0;
1445      state->Name_type = make_type(state, "Name", state->expr_type, Name_fields,
1446                                   2,
1447          "Name(identifier id, expr_context ctx)");
1448      if (!state->Name_type) return 0;
1449      state->List_type = make_type(state, "List", state->expr_type, List_fields,
1450                                   2,
1451          "List(expr* elts, expr_context ctx)");
1452      if (!state->List_type) return 0;
1453      state->Tuple_type = make_type(state, "Tuple", state->expr_type,
1454                                    Tuple_fields, 2,
1455          "Tuple(expr* elts, expr_context ctx)");
1456      if (!state->Tuple_type) return 0;
1457      state->Slice_type = make_type(state, "Slice", state->expr_type,
1458                                    Slice_fields, 3,
1459          "Slice(expr? lower, expr? upper, expr? step)");
1460      if (!state->Slice_type) return 0;
1461      if (PyObject_SetAttr(state->Slice_type, state->lower, Py_None) == -1)
1462          return 0;
1463      if (PyObject_SetAttr(state->Slice_type, state->upper, Py_None) == -1)
1464          return 0;
1465      if (PyObject_SetAttr(state->Slice_type, state->step, Py_None) == -1)
1466          return 0;
1467      state->expr_context_type = make_type(state, "expr_context",
1468                                           state->AST_type, NULL, 0,
1469          "expr_context = Load | Store | Del");
1470      if (!state->expr_context_type) return 0;
1471      if (!add_attributes(state, state->expr_context_type, NULL, 0)) return 0;
1472      state->Load_type = make_type(state, "Load", state->expr_context_type, NULL,
1473                                   0,
1474          "Load");
1475      if (!state->Load_type) return 0;
1476      state->Load_singleton = PyType_GenericNew((PyTypeObject *)state->Load_type,
1477                                                NULL, NULL);
1478      if (!state->Load_singleton) return 0;
1479      state->Store_type = make_type(state, "Store", state->expr_context_type,
1480                                    NULL, 0,
1481          "Store");
1482      if (!state->Store_type) return 0;
1483      state->Store_singleton = PyType_GenericNew((PyTypeObject
1484                                                 *)state->Store_type, NULL, NULL);
1485      if (!state->Store_singleton) return 0;
1486      state->Del_type = make_type(state, "Del", state->expr_context_type, NULL, 0,
1487          "Del");
1488      if (!state->Del_type) return 0;
1489      state->Del_singleton = PyType_GenericNew((PyTypeObject *)state->Del_type,
1490                                               NULL, NULL);
1491      if (!state->Del_singleton) return 0;
1492      state->boolop_type = make_type(state, "boolop", state->AST_type, NULL, 0,
1493          "boolop = And | Or");
1494      if (!state->boolop_type) return 0;
1495      if (!add_attributes(state, state->boolop_type, NULL, 0)) return 0;
1496      state->And_type = make_type(state, "And", state->boolop_type, NULL, 0,
1497          "And");
1498      if (!state->And_type) return 0;
1499      state->And_singleton = PyType_GenericNew((PyTypeObject *)state->And_type,
1500                                               NULL, NULL);
1501      if (!state->And_singleton) return 0;
1502      state->Or_type = make_type(state, "Or", state->boolop_type, NULL, 0,
1503          "Or");
1504      if (!state->Or_type) return 0;
1505      state->Or_singleton = PyType_GenericNew((PyTypeObject *)state->Or_type,
1506                                              NULL, NULL);
1507      if (!state->Or_singleton) return 0;
1508      state->operator_type = make_type(state, "operator", state->AST_type, NULL,
1509                                       0,
1510          "operator = Add | Sub | Mult | MatMult | Div | Mod | Pow | LShift | RShift | BitOr | BitXor | BitAnd | FloorDiv");
1511      if (!state->operator_type) return 0;
1512      if (!add_attributes(state, state->operator_type, NULL, 0)) return 0;
1513      state->Add_type = make_type(state, "Add", state->operator_type, NULL, 0,
1514          "Add");
1515      if (!state->Add_type) return 0;
1516      state->Add_singleton = PyType_GenericNew((PyTypeObject *)state->Add_type,
1517                                               NULL, NULL);
1518      if (!state->Add_singleton) return 0;
1519      state->Sub_type = make_type(state, "Sub", state->operator_type, NULL, 0,
1520          "Sub");
1521      if (!state->Sub_type) return 0;
1522      state->Sub_singleton = PyType_GenericNew((PyTypeObject *)state->Sub_type,
1523                                               NULL, NULL);
1524      if (!state->Sub_singleton) return 0;
1525      state->Mult_type = make_type(state, "Mult", state->operator_type, NULL, 0,
1526          "Mult");
1527      if (!state->Mult_type) return 0;
1528      state->Mult_singleton = PyType_GenericNew((PyTypeObject *)state->Mult_type,
1529                                                NULL, NULL);
1530      if (!state->Mult_singleton) return 0;
1531      state->MatMult_type = make_type(state, "MatMult", state->operator_type,
1532                                      NULL, 0,
1533          "MatMult");
1534      if (!state->MatMult_type) return 0;
1535      state->MatMult_singleton = PyType_GenericNew((PyTypeObject
1536                                                   *)state->MatMult_type, NULL,
1537                                                   NULL);
1538      if (!state->MatMult_singleton) return 0;
1539      state->Div_type = make_type(state, "Div", state->operator_type, NULL, 0,
1540          "Div");
1541      if (!state->Div_type) return 0;
1542      state->Div_singleton = PyType_GenericNew((PyTypeObject *)state->Div_type,
1543                                               NULL, NULL);
1544      if (!state->Div_singleton) return 0;
1545      state->Mod_type = make_type(state, "Mod", state->operator_type, NULL, 0,
1546          "Mod");
1547      if (!state->Mod_type) return 0;
1548      state->Mod_singleton = PyType_GenericNew((PyTypeObject *)state->Mod_type,
1549                                               NULL, NULL);
1550      if (!state->Mod_singleton) return 0;
1551      state->Pow_type = make_type(state, "Pow", state->operator_type, NULL, 0,
1552          "Pow");
1553      if (!state->Pow_type) return 0;
1554      state->Pow_singleton = PyType_GenericNew((PyTypeObject *)state->Pow_type,
1555                                               NULL, NULL);
1556      if (!state->Pow_singleton) return 0;
1557      state->LShift_type = make_type(state, "LShift", state->operator_type, NULL,
1558                                     0,
1559          "LShift");
1560      if (!state->LShift_type) return 0;
1561      state->LShift_singleton = PyType_GenericNew((PyTypeObject
1562                                                  *)state->LShift_type, NULL,
1563                                                  NULL);
1564      if (!state->LShift_singleton) return 0;
1565      state->RShift_type = make_type(state, "RShift", state->operator_type, NULL,
1566                                     0,
1567          "RShift");
1568      if (!state->RShift_type) return 0;
1569      state->RShift_singleton = PyType_GenericNew((PyTypeObject
1570                                                  *)state->RShift_type, NULL,
1571                                                  NULL);
1572      if (!state->RShift_singleton) return 0;
1573      state->BitOr_type = make_type(state, "BitOr", state->operator_type, NULL, 0,
1574          "BitOr");
1575      if (!state->BitOr_type) return 0;
1576      state->BitOr_singleton = PyType_GenericNew((PyTypeObject
1577                                                 *)state->BitOr_type, NULL, NULL);
1578      if (!state->BitOr_singleton) return 0;
1579      state->BitXor_type = make_type(state, "BitXor", state->operator_type, NULL,
1580                                     0,
1581          "BitXor");
1582      if (!state->BitXor_type) return 0;
1583      state->BitXor_singleton = PyType_GenericNew((PyTypeObject
1584                                                  *)state->BitXor_type, NULL,
1585                                                  NULL);
1586      if (!state->BitXor_singleton) return 0;
1587      state->BitAnd_type = make_type(state, "BitAnd", state->operator_type, NULL,
1588                                     0,
1589          "BitAnd");
1590      if (!state->BitAnd_type) return 0;
1591      state->BitAnd_singleton = PyType_GenericNew((PyTypeObject
1592                                                  *)state->BitAnd_type, NULL,
1593                                                  NULL);
1594      if (!state->BitAnd_singleton) return 0;
1595      state->FloorDiv_type = make_type(state, "FloorDiv", state->operator_type,
1596                                       NULL, 0,
1597          "FloorDiv");
1598      if (!state->FloorDiv_type) return 0;
1599      state->FloorDiv_singleton = PyType_GenericNew((PyTypeObject
1600                                                    *)state->FloorDiv_type, NULL,
1601                                                    NULL);
1602      if (!state->FloorDiv_singleton) return 0;
1603      state->unaryop_type = make_type(state, "unaryop", state->AST_type, NULL, 0,
1604          "unaryop = Invert | Not | UAdd | USub");
1605      if (!state->unaryop_type) return 0;
1606      if (!add_attributes(state, state->unaryop_type, NULL, 0)) return 0;
1607      state->Invert_type = make_type(state, "Invert", state->unaryop_type, NULL,
1608                                     0,
1609          "Invert");
1610      if (!state->Invert_type) return 0;
1611      state->Invert_singleton = PyType_GenericNew((PyTypeObject
1612                                                  *)state->Invert_type, NULL,
1613                                                  NULL);
1614      if (!state->Invert_singleton) return 0;
1615      state->Not_type = make_type(state, "Not", state->unaryop_type, NULL, 0,
1616          "Not");
1617      if (!state->Not_type) return 0;
1618      state->Not_singleton = PyType_GenericNew((PyTypeObject *)state->Not_type,
1619                                               NULL, NULL);
1620      if (!state->Not_singleton) return 0;
1621      state->UAdd_type = make_type(state, "UAdd", state->unaryop_type, NULL, 0,
1622          "UAdd");
1623      if (!state->UAdd_type) return 0;
1624      state->UAdd_singleton = PyType_GenericNew((PyTypeObject *)state->UAdd_type,
1625                                                NULL, NULL);
1626      if (!state->UAdd_singleton) return 0;
1627      state->USub_type = make_type(state, "USub", state->unaryop_type, NULL, 0,
1628          "USub");
1629      if (!state->USub_type) return 0;
1630      state->USub_singleton = PyType_GenericNew((PyTypeObject *)state->USub_type,
1631                                                NULL, NULL);
1632      if (!state->USub_singleton) return 0;
1633      state->cmpop_type = make_type(state, "cmpop", state->AST_type, NULL, 0,
1634          "cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn");
1635      if (!state->cmpop_type) return 0;
1636      if (!add_attributes(state, state->cmpop_type, NULL, 0)) return 0;
1637      state->Eq_type = make_type(state, "Eq", state->cmpop_type, NULL, 0,
1638          "Eq");
1639      if (!state->Eq_type) return 0;
1640      state->Eq_singleton = PyType_GenericNew((PyTypeObject *)state->Eq_type,
1641                                              NULL, NULL);
1642      if (!state->Eq_singleton) return 0;
1643      state->NotEq_type = make_type(state, "NotEq", state->cmpop_type, NULL, 0,
1644          "NotEq");
1645      if (!state->NotEq_type) return 0;
1646      state->NotEq_singleton = PyType_GenericNew((PyTypeObject
1647                                                 *)state->NotEq_type, NULL, NULL);
1648      if (!state->NotEq_singleton) return 0;
1649      state->Lt_type = make_type(state, "Lt", state->cmpop_type, NULL, 0,
1650          "Lt");
1651      if (!state->Lt_type) return 0;
1652      state->Lt_singleton = PyType_GenericNew((PyTypeObject *)state->Lt_type,
1653                                              NULL, NULL);
1654      if (!state->Lt_singleton) return 0;
1655      state->LtE_type = make_type(state, "LtE", state->cmpop_type, NULL, 0,
1656          "LtE");
1657      if (!state->LtE_type) return 0;
1658      state->LtE_singleton = PyType_GenericNew((PyTypeObject *)state->LtE_type,
1659                                               NULL, NULL);
1660      if (!state->LtE_singleton) return 0;
1661      state->Gt_type = make_type(state, "Gt", state->cmpop_type, NULL, 0,
1662          "Gt");
1663      if (!state->Gt_type) return 0;
1664      state->Gt_singleton = PyType_GenericNew((PyTypeObject *)state->Gt_type,
1665                                              NULL, NULL);
1666      if (!state->Gt_singleton) return 0;
1667      state->GtE_type = make_type(state, "GtE", state->cmpop_type, NULL, 0,
1668          "GtE");
1669      if (!state->GtE_type) return 0;
1670      state->GtE_singleton = PyType_GenericNew((PyTypeObject *)state->GtE_type,
1671                                               NULL, NULL);
1672      if (!state->GtE_singleton) return 0;
1673      state->Is_type = make_type(state, "Is", state->cmpop_type, NULL, 0,
1674          "Is");
1675      if (!state->Is_type) return 0;
1676      state->Is_singleton = PyType_GenericNew((PyTypeObject *)state->Is_type,
1677                                              NULL, NULL);
1678      if (!state->Is_singleton) return 0;
1679      state->IsNot_type = make_type(state, "IsNot", state->cmpop_type, NULL, 0,
1680          "IsNot");
1681      if (!state->IsNot_type) return 0;
1682      state->IsNot_singleton = PyType_GenericNew((PyTypeObject
1683                                                 *)state->IsNot_type, NULL, NULL);
1684      if (!state->IsNot_singleton) return 0;
1685      state->In_type = make_type(state, "In", state->cmpop_type, NULL, 0,
1686          "In");
1687      if (!state->In_type) return 0;
1688      state->In_singleton = PyType_GenericNew((PyTypeObject *)state->In_type,
1689                                              NULL, NULL);
1690      if (!state->In_singleton) return 0;
1691      state->NotIn_type = make_type(state, "NotIn", state->cmpop_type, NULL, 0,
1692          "NotIn");
1693      if (!state->NotIn_type) return 0;
1694      state->NotIn_singleton = PyType_GenericNew((PyTypeObject
1695                                                 *)state->NotIn_type, NULL, NULL);
1696      if (!state->NotIn_singleton) return 0;
1697      state->comprehension_type = make_type(state, "comprehension",
1698                                            state->AST_type,
1699                                            comprehension_fields, 4,
1700          "comprehension(expr target, expr iter, expr* ifs, int is_async)");
1701      if (!state->comprehension_type) return 0;
1702      if (!add_attributes(state, state->comprehension_type, NULL, 0)) return 0;
1703      state->excepthandler_type = make_type(state, "excepthandler",
1704                                            state->AST_type, NULL, 0,
1705          "excepthandler = ExceptHandler(expr? type, identifier? name, stmt* body)");
1706      if (!state->excepthandler_type) return 0;
1707      if (!add_attributes(state, state->excepthandler_type,
1708          excepthandler_attributes, 4)) return 0;
1709      if (PyObject_SetAttr(state->excepthandler_type, state->end_lineno, Py_None)
1710          == -1)
1711          return 0;
1712      if (PyObject_SetAttr(state->excepthandler_type, state->end_col_offset,
1713          Py_None) == -1)
1714          return 0;
1715      state->ExceptHandler_type = make_type(state, "ExceptHandler",
1716                                            state->excepthandler_type,
1717                                            ExceptHandler_fields, 3,
1718          "ExceptHandler(expr? type, identifier? name, stmt* body)");
1719      if (!state->ExceptHandler_type) return 0;
1720      if (PyObject_SetAttr(state->ExceptHandler_type, state->type, Py_None) == -1)
1721          return 0;
1722      if (PyObject_SetAttr(state->ExceptHandler_type, state->name, Py_None) == -1)
1723          return 0;
1724      state->arguments_type = make_type(state, "arguments", state->AST_type,
1725                                        arguments_fields, 7,
1726          "arguments(arg* posonlyargs, arg* args, arg? vararg, arg* kwonlyargs, expr* kw_defaults, arg? kwarg, expr* defaults)");
1727      if (!state->arguments_type) return 0;
1728      if (!add_attributes(state, state->arguments_type, NULL, 0)) return 0;
1729      if (PyObject_SetAttr(state->arguments_type, state->vararg, Py_None) == -1)
1730          return 0;
1731      if (PyObject_SetAttr(state->arguments_type, state->kwarg, Py_None) == -1)
1732          return 0;
1733      state->arg_type = make_type(state, "arg", state->AST_type, arg_fields, 3,
1734          "arg(identifier arg, expr? annotation, string? type_comment)");
1735      if (!state->arg_type) return 0;
1736      if (!add_attributes(state, state->arg_type, arg_attributes, 4)) return 0;
1737      if (PyObject_SetAttr(state->arg_type, state->annotation, Py_None) == -1)
1738          return 0;
1739      if (PyObject_SetAttr(state->arg_type, state->type_comment, Py_None) == -1)
1740          return 0;
1741      if (PyObject_SetAttr(state->arg_type, state->end_lineno, Py_None) == -1)
1742          return 0;
1743      if (PyObject_SetAttr(state->arg_type, state->end_col_offset, Py_None) == -1)
1744          return 0;
1745      state->keyword_type = make_type(state, "keyword", state->AST_type,
1746                                      keyword_fields, 2,
1747          "keyword(identifier? arg, expr value)");
1748      if (!state->keyword_type) return 0;
1749      if (!add_attributes(state, state->keyword_type, keyword_attributes, 4))
1750          return 0;
1751      if (PyObject_SetAttr(state->keyword_type, state->arg, Py_None) == -1)
1752          return 0;
1753      if (PyObject_SetAttr(state->keyword_type, state->end_lineno, Py_None) == -1)
1754          return 0;
1755      if (PyObject_SetAttr(state->keyword_type, state->end_col_offset, Py_None)
1756          == -1)
1757          return 0;
1758      state->alias_type = make_type(state, "alias", state->AST_type,
1759                                    alias_fields, 2,
1760          "alias(identifier name, identifier? asname)");
1761      if (!state->alias_type) return 0;
1762      if (!add_attributes(state, state->alias_type, alias_attributes, 4)) return
1763          0;
1764      if (PyObject_SetAttr(state->alias_type, state->asname, Py_None) == -1)
1765          return 0;
1766      if (PyObject_SetAttr(state->alias_type, state->end_lineno, Py_None) == -1)
1767          return 0;
1768      if (PyObject_SetAttr(state->alias_type, state->end_col_offset, Py_None) ==
1769          -1)
1770          return 0;
1771      state->withitem_type = make_type(state, "withitem", state->AST_type,
1772                                       withitem_fields, 2,
1773          "withitem(expr context_expr, expr? optional_vars)");
1774      if (!state->withitem_type) return 0;
1775      if (!add_attributes(state, state->withitem_type, NULL, 0)) return 0;
1776      if (PyObject_SetAttr(state->withitem_type, state->optional_vars, Py_None)
1777          == -1)
1778          return 0;
1779      state->match_case_type = make_type(state, "match_case", state->AST_type,
1780                                         match_case_fields, 3,
1781          "match_case(pattern pattern, expr? guard, stmt* body)");
1782      if (!state->match_case_type) return 0;
1783      if (!add_attributes(state, state->match_case_type, NULL, 0)) return 0;
1784      if (PyObject_SetAttr(state->match_case_type, state->guard, Py_None) == -1)
1785          return 0;
1786      state->pattern_type = make_type(state, "pattern", state->AST_type, NULL, 0,
1787          "pattern = MatchValue(expr value)\n"
1788          "        | MatchSingleton(constant value)\n"
1789          "        | MatchSequence(pattern* patterns)\n"
1790          "        | MatchMapping(expr* keys, pattern* patterns, identifier? rest)\n"
1791          "        | MatchClass(expr cls, pattern* patterns, identifier* kwd_attrs, pattern* kwd_patterns)\n"
1792          "        | MatchStar(identifier? name)\n"
1793          "        | MatchAs(pattern? pattern, identifier? name)\n"
1794          "        | MatchOr(pattern* patterns)");
1795      if (!state->pattern_type) return 0;
1796      if (!add_attributes(state, state->pattern_type, pattern_attributes, 4))
1797          return 0;
1798      state->MatchValue_type = make_type(state, "MatchValue",
1799                                         state->pattern_type, MatchValue_fields,
1800                                         1,
1801          "MatchValue(expr value)");
1802      if (!state->MatchValue_type) return 0;
1803      state->MatchSingleton_type = make_type(state, "MatchSingleton",
1804                                             state->pattern_type,
1805                                             MatchSingleton_fields, 1,
1806          "MatchSingleton(constant value)");
1807      if (!state->MatchSingleton_type) return 0;
1808      state->MatchSequence_type = make_type(state, "MatchSequence",
1809                                            state->pattern_type,
1810                                            MatchSequence_fields, 1,
1811          "MatchSequence(pattern* patterns)");
1812      if (!state->MatchSequence_type) return 0;
1813      state->MatchMapping_type = make_type(state, "MatchMapping",
1814                                           state->pattern_type,
1815                                           MatchMapping_fields, 3,
1816          "MatchMapping(expr* keys, pattern* patterns, identifier? rest)");
1817      if (!state->MatchMapping_type) return 0;
1818      if (PyObject_SetAttr(state->MatchMapping_type, state->rest, Py_None) == -1)
1819          return 0;
1820      state->MatchClass_type = make_type(state, "MatchClass",
1821                                         state->pattern_type, MatchClass_fields,
1822                                         4,
1823          "MatchClass(expr cls, pattern* patterns, identifier* kwd_attrs, pattern* kwd_patterns)");
1824      if (!state->MatchClass_type) return 0;
1825      state->MatchStar_type = make_type(state, "MatchStar", state->pattern_type,
1826                                        MatchStar_fields, 1,
1827          "MatchStar(identifier? name)");
1828      if (!state->MatchStar_type) return 0;
1829      if (PyObject_SetAttr(state->MatchStar_type, state->name, Py_None) == -1)
1830          return 0;
1831      state->MatchAs_type = make_type(state, "MatchAs", state->pattern_type,
1832                                      MatchAs_fields, 2,
1833          "MatchAs(pattern? pattern, identifier? name)");
1834      if (!state->MatchAs_type) return 0;
1835      if (PyObject_SetAttr(state->MatchAs_type, state->pattern, Py_None) == -1)
1836          return 0;
1837      if (PyObject_SetAttr(state->MatchAs_type, state->name, Py_None) == -1)
1838          return 0;
1839      state->MatchOr_type = make_type(state, "MatchOr", state->pattern_type,
1840                                      MatchOr_fields, 1,
1841          "MatchOr(pattern* patterns)");
1842      if (!state->MatchOr_type) return 0;
1843      state->type_ignore_type = make_type(state, "type_ignore", state->AST_type,
1844                                          NULL, 0,
1845          "type_ignore = TypeIgnore(int lineno, string tag)");
1846      if (!state->type_ignore_type) return 0;
1847      if (!add_attributes(state, state->type_ignore_type, NULL, 0)) return 0;
1848      state->TypeIgnore_type = make_type(state, "TypeIgnore",
1849                                         state->type_ignore_type,
1850                                         TypeIgnore_fields, 2,
1851          "TypeIgnore(int lineno, string tag)");
1852      if (!state->TypeIgnore_type) return 0;
1853  
1854      state->recursion_depth = 0;
1855      state->recursion_limit = 0;
1856      state->initialized = 1;
1857      return 1;
1858  }
1859  
1860  static int obj2ast_mod(struct ast_state *state, PyObject* obj, mod_ty* out,
1861                         PyArena* arena);
1862  static int obj2ast_stmt(struct ast_state *state, PyObject* obj, stmt_ty* out,
1863                          PyArena* arena);
1864  static int obj2ast_expr(struct ast_state *state, PyObject* obj, expr_ty* out,
1865                          PyArena* arena);
1866  static int obj2ast_expr_context(struct ast_state *state, PyObject* obj,
1867                                  expr_context_ty* out, PyArena* arena);
1868  static int obj2ast_boolop(struct ast_state *state, PyObject* obj, boolop_ty*
1869                            out, PyArena* arena);
1870  static int obj2ast_operator(struct ast_state *state, PyObject* obj,
1871                              operator_ty* out, PyArena* arena);
1872  static int obj2ast_unaryop(struct ast_state *state, PyObject* obj, unaryop_ty*
1873                             out, PyArena* arena);
1874  static int obj2ast_cmpop(struct ast_state *state, PyObject* obj, cmpop_ty* out,
1875                           PyArena* arena);
1876  static int obj2ast_comprehension(struct ast_state *state, PyObject* obj,
1877                                   comprehension_ty* out, PyArena* arena);
1878  static int obj2ast_excepthandler(struct ast_state *state, PyObject* obj,
1879                                   excepthandler_ty* out, PyArena* arena);
1880  static int obj2ast_arguments(struct ast_state *state, PyObject* obj,
1881                               arguments_ty* out, PyArena* arena);
1882  static int obj2ast_arg(struct ast_state *state, PyObject* obj, arg_ty* out,
1883                         PyArena* arena);
1884  static int obj2ast_keyword(struct ast_state *state, PyObject* obj, keyword_ty*
1885                             out, PyArena* arena);
1886  static int obj2ast_alias(struct ast_state *state, PyObject* obj, alias_ty* out,
1887                           PyArena* arena);
1888  static int obj2ast_withitem(struct ast_state *state, PyObject* obj,
1889                              withitem_ty* out, PyArena* arena);
1890  static int obj2ast_match_case(struct ast_state *state, PyObject* obj,
1891                                match_case_ty* out, PyArena* arena);
1892  static int obj2ast_pattern(struct ast_state *state, PyObject* obj, pattern_ty*
1893                             out, PyArena* arena);
1894  static int obj2ast_type_ignore(struct ast_state *state, PyObject* obj,
1895                                 type_ignore_ty* out, PyArena* arena);
1896  
1897  mod_ty
_PyAST_Module(asdl_stmt_seq * body,asdl_type_ignore_seq * type_ignores,PyArena * arena)1898  _PyAST_Module(asdl_stmt_seq * body, asdl_type_ignore_seq * type_ignores,
1899                PyArena *arena)
1900  {
1901      mod_ty p;
1902      p = (mod_ty)_PyArena_Malloc(arena, sizeof(*p));
1903      if (!p)
1904          return NULL;
1905      p->kind = Module_kind;
1906      p->v.Module.body = body;
1907      p->v.Module.type_ignores = type_ignores;
1908      return p;
1909  }
1910  
1911  mod_ty
_PyAST_Interactive(asdl_stmt_seq * body,PyArena * arena)1912  _PyAST_Interactive(asdl_stmt_seq * body, PyArena *arena)
1913  {
1914      mod_ty p;
1915      p = (mod_ty)_PyArena_Malloc(arena, sizeof(*p));
1916      if (!p)
1917          return NULL;
1918      p->kind = Interactive_kind;
1919      p->v.Interactive.body = body;
1920      return p;
1921  }
1922  
1923  mod_ty
_PyAST_Expression(expr_ty body,PyArena * arena)1924  _PyAST_Expression(expr_ty body, PyArena *arena)
1925  {
1926      mod_ty p;
1927      if (!body) {
1928          PyErr_SetString(PyExc_ValueError,
1929                          "field 'body' is required for Expression");
1930          return NULL;
1931      }
1932      p = (mod_ty)_PyArena_Malloc(arena, sizeof(*p));
1933      if (!p)
1934          return NULL;
1935      p->kind = Expression_kind;
1936      p->v.Expression.body = body;
1937      return p;
1938  }
1939  
1940  mod_ty
_PyAST_FunctionType(asdl_expr_seq * argtypes,expr_ty returns,PyArena * arena)1941  _PyAST_FunctionType(asdl_expr_seq * argtypes, expr_ty returns, PyArena *arena)
1942  {
1943      mod_ty p;
1944      if (!returns) {
1945          PyErr_SetString(PyExc_ValueError,
1946                          "field 'returns' is required for FunctionType");
1947          return NULL;
1948      }
1949      p = (mod_ty)_PyArena_Malloc(arena, sizeof(*p));
1950      if (!p)
1951          return NULL;
1952      p->kind = FunctionType_kind;
1953      p->v.FunctionType.argtypes = argtypes;
1954      p->v.FunctionType.returns = returns;
1955      return p;
1956  }
1957  
1958  stmt_ty
_PyAST_FunctionDef(identifier name,arguments_ty args,asdl_stmt_seq * body,asdl_expr_seq * decorator_list,expr_ty returns,string type_comment,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)1959  _PyAST_FunctionDef(identifier name, arguments_ty args, asdl_stmt_seq * body,
1960                     asdl_expr_seq * decorator_list, expr_ty returns, string
1961                     type_comment, int lineno, int col_offset, int end_lineno,
1962                     int end_col_offset, PyArena *arena)
1963  {
1964      stmt_ty p;
1965      if (!name) {
1966          PyErr_SetString(PyExc_ValueError,
1967                          "field 'name' is required for FunctionDef");
1968          return NULL;
1969      }
1970      if (!args) {
1971          PyErr_SetString(PyExc_ValueError,
1972                          "field 'args' is required for FunctionDef");
1973          return NULL;
1974      }
1975      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
1976      if (!p)
1977          return NULL;
1978      p->kind = FunctionDef_kind;
1979      p->v.FunctionDef.name = name;
1980      p->v.FunctionDef.args = args;
1981      p->v.FunctionDef.body = body;
1982      p->v.FunctionDef.decorator_list = decorator_list;
1983      p->v.FunctionDef.returns = returns;
1984      p->v.FunctionDef.type_comment = type_comment;
1985      p->lineno = lineno;
1986      p->col_offset = col_offset;
1987      p->end_lineno = end_lineno;
1988      p->end_col_offset = end_col_offset;
1989      return p;
1990  }
1991  
1992  stmt_ty
_PyAST_AsyncFunctionDef(identifier name,arguments_ty args,asdl_stmt_seq * body,asdl_expr_seq * decorator_list,expr_ty returns,string type_comment,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)1993  _PyAST_AsyncFunctionDef(identifier name, arguments_ty args, asdl_stmt_seq *
1994                          body, asdl_expr_seq * decorator_list, expr_ty returns,
1995                          string type_comment, int lineno, int col_offset, int
1996                          end_lineno, int end_col_offset, PyArena *arena)
1997  {
1998      stmt_ty p;
1999      if (!name) {
2000          PyErr_SetString(PyExc_ValueError,
2001                          "field 'name' is required for AsyncFunctionDef");
2002          return NULL;
2003      }
2004      if (!args) {
2005          PyErr_SetString(PyExc_ValueError,
2006                          "field 'args' is required for AsyncFunctionDef");
2007          return NULL;
2008      }
2009      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2010      if (!p)
2011          return NULL;
2012      p->kind = AsyncFunctionDef_kind;
2013      p->v.AsyncFunctionDef.name = name;
2014      p->v.AsyncFunctionDef.args = args;
2015      p->v.AsyncFunctionDef.body = body;
2016      p->v.AsyncFunctionDef.decorator_list = decorator_list;
2017      p->v.AsyncFunctionDef.returns = returns;
2018      p->v.AsyncFunctionDef.type_comment = type_comment;
2019      p->lineno = lineno;
2020      p->col_offset = col_offset;
2021      p->end_lineno = end_lineno;
2022      p->end_col_offset = end_col_offset;
2023      return p;
2024  }
2025  
2026  stmt_ty
_PyAST_ClassDef(identifier name,asdl_expr_seq * bases,asdl_keyword_seq * keywords,asdl_stmt_seq * body,asdl_expr_seq * decorator_list,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2027  _PyAST_ClassDef(identifier name, asdl_expr_seq * bases, asdl_keyword_seq *
2028                  keywords, asdl_stmt_seq * body, asdl_expr_seq * decorator_list,
2029                  int lineno, int col_offset, int end_lineno, int end_col_offset,
2030                  PyArena *arena)
2031  {
2032      stmt_ty p;
2033      if (!name) {
2034          PyErr_SetString(PyExc_ValueError,
2035                          "field 'name' is required for ClassDef");
2036          return NULL;
2037      }
2038      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2039      if (!p)
2040          return NULL;
2041      p->kind = ClassDef_kind;
2042      p->v.ClassDef.name = name;
2043      p->v.ClassDef.bases = bases;
2044      p->v.ClassDef.keywords = keywords;
2045      p->v.ClassDef.body = body;
2046      p->v.ClassDef.decorator_list = decorator_list;
2047      p->lineno = lineno;
2048      p->col_offset = col_offset;
2049      p->end_lineno = end_lineno;
2050      p->end_col_offset = end_col_offset;
2051      return p;
2052  }
2053  
2054  stmt_ty
_PyAST_Return(expr_ty value,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2055  _PyAST_Return(expr_ty value, int lineno, int col_offset, int end_lineno, int
2056                end_col_offset, PyArena *arena)
2057  {
2058      stmt_ty p;
2059      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2060      if (!p)
2061          return NULL;
2062      p->kind = Return_kind;
2063      p->v.Return.value = value;
2064      p->lineno = lineno;
2065      p->col_offset = col_offset;
2066      p->end_lineno = end_lineno;
2067      p->end_col_offset = end_col_offset;
2068      return p;
2069  }
2070  
2071  stmt_ty
_PyAST_Delete(asdl_expr_seq * targets,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2072  _PyAST_Delete(asdl_expr_seq * targets, int lineno, int col_offset, int
2073                end_lineno, int end_col_offset, PyArena *arena)
2074  {
2075      stmt_ty p;
2076      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2077      if (!p)
2078          return NULL;
2079      p->kind = Delete_kind;
2080      p->v.Delete.targets = targets;
2081      p->lineno = lineno;
2082      p->col_offset = col_offset;
2083      p->end_lineno = end_lineno;
2084      p->end_col_offset = end_col_offset;
2085      return p;
2086  }
2087  
2088  stmt_ty
_PyAST_Assign(asdl_expr_seq * targets,expr_ty value,string type_comment,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2089  _PyAST_Assign(asdl_expr_seq * targets, expr_ty value, string type_comment, int
2090                lineno, int col_offset, int end_lineno, int end_col_offset,
2091                PyArena *arena)
2092  {
2093      stmt_ty p;
2094      if (!value) {
2095          PyErr_SetString(PyExc_ValueError,
2096                          "field 'value' is required for Assign");
2097          return NULL;
2098      }
2099      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2100      if (!p)
2101          return NULL;
2102      p->kind = Assign_kind;
2103      p->v.Assign.targets = targets;
2104      p->v.Assign.value = value;
2105      p->v.Assign.type_comment = type_comment;
2106      p->lineno = lineno;
2107      p->col_offset = col_offset;
2108      p->end_lineno = end_lineno;
2109      p->end_col_offset = end_col_offset;
2110      return p;
2111  }
2112  
2113  stmt_ty
_PyAST_AugAssign(expr_ty target,operator_ty op,expr_ty value,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2114  _PyAST_AugAssign(expr_ty target, operator_ty op, expr_ty value, int lineno, int
2115                   col_offset, int end_lineno, int end_col_offset, PyArena *arena)
2116  {
2117      stmt_ty p;
2118      if (!target) {
2119          PyErr_SetString(PyExc_ValueError,
2120                          "field 'target' is required for AugAssign");
2121          return NULL;
2122      }
2123      if (!op) {
2124          PyErr_SetString(PyExc_ValueError,
2125                          "field 'op' is required for AugAssign");
2126          return NULL;
2127      }
2128      if (!value) {
2129          PyErr_SetString(PyExc_ValueError,
2130                          "field 'value' is required for AugAssign");
2131          return NULL;
2132      }
2133      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2134      if (!p)
2135          return NULL;
2136      p->kind = AugAssign_kind;
2137      p->v.AugAssign.target = target;
2138      p->v.AugAssign.op = op;
2139      p->v.AugAssign.value = value;
2140      p->lineno = lineno;
2141      p->col_offset = col_offset;
2142      p->end_lineno = end_lineno;
2143      p->end_col_offset = end_col_offset;
2144      return p;
2145  }
2146  
2147  stmt_ty
_PyAST_AnnAssign(expr_ty target,expr_ty annotation,expr_ty value,int simple,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2148  _PyAST_AnnAssign(expr_ty target, expr_ty annotation, expr_ty value, int simple,
2149                   int lineno, int col_offset, int end_lineno, int
2150                   end_col_offset, PyArena *arena)
2151  {
2152      stmt_ty p;
2153      if (!target) {
2154          PyErr_SetString(PyExc_ValueError,
2155                          "field 'target' is required for AnnAssign");
2156          return NULL;
2157      }
2158      if (!annotation) {
2159          PyErr_SetString(PyExc_ValueError,
2160                          "field 'annotation' is required for AnnAssign");
2161          return NULL;
2162      }
2163      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2164      if (!p)
2165          return NULL;
2166      p->kind = AnnAssign_kind;
2167      p->v.AnnAssign.target = target;
2168      p->v.AnnAssign.annotation = annotation;
2169      p->v.AnnAssign.value = value;
2170      p->v.AnnAssign.simple = simple;
2171      p->lineno = lineno;
2172      p->col_offset = col_offset;
2173      p->end_lineno = end_lineno;
2174      p->end_col_offset = end_col_offset;
2175      return p;
2176  }
2177  
2178  stmt_ty
_PyAST_For(expr_ty target,expr_ty iter,asdl_stmt_seq * body,asdl_stmt_seq * orelse,string type_comment,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2179  _PyAST_For(expr_ty target, expr_ty iter, asdl_stmt_seq * body, asdl_stmt_seq *
2180             orelse, string type_comment, int lineno, int col_offset, int
2181             end_lineno, int end_col_offset, PyArena *arena)
2182  {
2183      stmt_ty p;
2184      if (!target) {
2185          PyErr_SetString(PyExc_ValueError,
2186                          "field 'target' is required for For");
2187          return NULL;
2188      }
2189      if (!iter) {
2190          PyErr_SetString(PyExc_ValueError,
2191                          "field 'iter' is required for For");
2192          return NULL;
2193      }
2194      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2195      if (!p)
2196          return NULL;
2197      p->kind = For_kind;
2198      p->v.For.target = target;
2199      p->v.For.iter = iter;
2200      p->v.For.body = body;
2201      p->v.For.orelse = orelse;
2202      p->v.For.type_comment = type_comment;
2203      p->lineno = lineno;
2204      p->col_offset = col_offset;
2205      p->end_lineno = end_lineno;
2206      p->end_col_offset = end_col_offset;
2207      return p;
2208  }
2209  
2210  stmt_ty
_PyAST_AsyncFor(expr_ty target,expr_ty iter,asdl_stmt_seq * body,asdl_stmt_seq * orelse,string type_comment,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2211  _PyAST_AsyncFor(expr_ty target, expr_ty iter, asdl_stmt_seq * body,
2212                  asdl_stmt_seq * orelse, string type_comment, int lineno, int
2213                  col_offset, int end_lineno, int end_col_offset, PyArena *arena)
2214  {
2215      stmt_ty p;
2216      if (!target) {
2217          PyErr_SetString(PyExc_ValueError,
2218                          "field 'target' is required for AsyncFor");
2219          return NULL;
2220      }
2221      if (!iter) {
2222          PyErr_SetString(PyExc_ValueError,
2223                          "field 'iter' is required for AsyncFor");
2224          return NULL;
2225      }
2226      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2227      if (!p)
2228          return NULL;
2229      p->kind = AsyncFor_kind;
2230      p->v.AsyncFor.target = target;
2231      p->v.AsyncFor.iter = iter;
2232      p->v.AsyncFor.body = body;
2233      p->v.AsyncFor.orelse = orelse;
2234      p->v.AsyncFor.type_comment = type_comment;
2235      p->lineno = lineno;
2236      p->col_offset = col_offset;
2237      p->end_lineno = end_lineno;
2238      p->end_col_offset = end_col_offset;
2239      return p;
2240  }
2241  
2242  stmt_ty
_PyAST_While(expr_ty test,asdl_stmt_seq * body,asdl_stmt_seq * orelse,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2243  _PyAST_While(expr_ty test, asdl_stmt_seq * body, asdl_stmt_seq * orelse, int
2244               lineno, int col_offset, int end_lineno, int end_col_offset,
2245               PyArena *arena)
2246  {
2247      stmt_ty p;
2248      if (!test) {
2249          PyErr_SetString(PyExc_ValueError,
2250                          "field 'test' is required for While");
2251          return NULL;
2252      }
2253      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2254      if (!p)
2255          return NULL;
2256      p->kind = While_kind;
2257      p->v.While.test = test;
2258      p->v.While.body = body;
2259      p->v.While.orelse = orelse;
2260      p->lineno = lineno;
2261      p->col_offset = col_offset;
2262      p->end_lineno = end_lineno;
2263      p->end_col_offset = end_col_offset;
2264      return p;
2265  }
2266  
2267  stmt_ty
_PyAST_If(expr_ty test,asdl_stmt_seq * body,asdl_stmt_seq * orelse,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2268  _PyAST_If(expr_ty test, asdl_stmt_seq * body, asdl_stmt_seq * orelse, int
2269            lineno, int col_offset, int end_lineno, int end_col_offset, PyArena
2270            *arena)
2271  {
2272      stmt_ty p;
2273      if (!test) {
2274          PyErr_SetString(PyExc_ValueError,
2275                          "field 'test' is required for If");
2276          return NULL;
2277      }
2278      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2279      if (!p)
2280          return NULL;
2281      p->kind = If_kind;
2282      p->v.If.test = test;
2283      p->v.If.body = body;
2284      p->v.If.orelse = orelse;
2285      p->lineno = lineno;
2286      p->col_offset = col_offset;
2287      p->end_lineno = end_lineno;
2288      p->end_col_offset = end_col_offset;
2289      return p;
2290  }
2291  
2292  stmt_ty
_PyAST_With(asdl_withitem_seq * items,asdl_stmt_seq * body,string type_comment,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2293  _PyAST_With(asdl_withitem_seq * items, asdl_stmt_seq * body, string
2294              type_comment, int lineno, int col_offset, int end_lineno, int
2295              end_col_offset, PyArena *arena)
2296  {
2297      stmt_ty p;
2298      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2299      if (!p)
2300          return NULL;
2301      p->kind = With_kind;
2302      p->v.With.items = items;
2303      p->v.With.body = body;
2304      p->v.With.type_comment = type_comment;
2305      p->lineno = lineno;
2306      p->col_offset = col_offset;
2307      p->end_lineno = end_lineno;
2308      p->end_col_offset = end_col_offset;
2309      return p;
2310  }
2311  
2312  stmt_ty
_PyAST_AsyncWith(asdl_withitem_seq * items,asdl_stmt_seq * body,string type_comment,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2313  _PyAST_AsyncWith(asdl_withitem_seq * items, asdl_stmt_seq * body, string
2314                   type_comment, int lineno, int col_offset, int end_lineno, int
2315                   end_col_offset, PyArena *arena)
2316  {
2317      stmt_ty p;
2318      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2319      if (!p)
2320          return NULL;
2321      p->kind = AsyncWith_kind;
2322      p->v.AsyncWith.items = items;
2323      p->v.AsyncWith.body = body;
2324      p->v.AsyncWith.type_comment = type_comment;
2325      p->lineno = lineno;
2326      p->col_offset = col_offset;
2327      p->end_lineno = end_lineno;
2328      p->end_col_offset = end_col_offset;
2329      return p;
2330  }
2331  
2332  stmt_ty
_PyAST_Match(expr_ty subject,asdl_match_case_seq * cases,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2333  _PyAST_Match(expr_ty subject, asdl_match_case_seq * cases, int lineno, int
2334               col_offset, int end_lineno, int end_col_offset, PyArena *arena)
2335  {
2336      stmt_ty p;
2337      if (!subject) {
2338          PyErr_SetString(PyExc_ValueError,
2339                          "field 'subject' is required for Match");
2340          return NULL;
2341      }
2342      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2343      if (!p)
2344          return NULL;
2345      p->kind = Match_kind;
2346      p->v.Match.subject = subject;
2347      p->v.Match.cases = cases;
2348      p->lineno = lineno;
2349      p->col_offset = col_offset;
2350      p->end_lineno = end_lineno;
2351      p->end_col_offset = end_col_offset;
2352      return p;
2353  }
2354  
2355  stmt_ty
_PyAST_Raise(expr_ty exc,expr_ty cause,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2356  _PyAST_Raise(expr_ty exc, expr_ty cause, int lineno, int col_offset, int
2357               end_lineno, int end_col_offset, PyArena *arena)
2358  {
2359      stmt_ty p;
2360      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2361      if (!p)
2362          return NULL;
2363      p->kind = Raise_kind;
2364      p->v.Raise.exc = exc;
2365      p->v.Raise.cause = cause;
2366      p->lineno = lineno;
2367      p->col_offset = col_offset;
2368      p->end_lineno = end_lineno;
2369      p->end_col_offset = end_col_offset;
2370      return p;
2371  }
2372  
2373  stmt_ty
_PyAST_Try(asdl_stmt_seq * body,asdl_excepthandler_seq * handlers,asdl_stmt_seq * orelse,asdl_stmt_seq * finalbody,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2374  _PyAST_Try(asdl_stmt_seq * body, asdl_excepthandler_seq * handlers,
2375             asdl_stmt_seq * orelse, asdl_stmt_seq * finalbody, int lineno, int
2376             col_offset, int end_lineno, int end_col_offset, PyArena *arena)
2377  {
2378      stmt_ty p;
2379      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2380      if (!p)
2381          return NULL;
2382      p->kind = Try_kind;
2383      p->v.Try.body = body;
2384      p->v.Try.handlers = handlers;
2385      p->v.Try.orelse = orelse;
2386      p->v.Try.finalbody = finalbody;
2387      p->lineno = lineno;
2388      p->col_offset = col_offset;
2389      p->end_lineno = end_lineno;
2390      p->end_col_offset = end_col_offset;
2391      return p;
2392  }
2393  
2394  stmt_ty
_PyAST_TryStar(asdl_stmt_seq * body,asdl_excepthandler_seq * handlers,asdl_stmt_seq * orelse,asdl_stmt_seq * finalbody,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2395  _PyAST_TryStar(asdl_stmt_seq * body, asdl_excepthandler_seq * handlers,
2396                 asdl_stmt_seq * orelse, asdl_stmt_seq * finalbody, int lineno,
2397                 int col_offset, int end_lineno, int end_col_offset, PyArena
2398                 *arena)
2399  {
2400      stmt_ty p;
2401      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2402      if (!p)
2403          return NULL;
2404      p->kind = TryStar_kind;
2405      p->v.TryStar.body = body;
2406      p->v.TryStar.handlers = handlers;
2407      p->v.TryStar.orelse = orelse;
2408      p->v.TryStar.finalbody = finalbody;
2409      p->lineno = lineno;
2410      p->col_offset = col_offset;
2411      p->end_lineno = end_lineno;
2412      p->end_col_offset = end_col_offset;
2413      return p;
2414  }
2415  
2416  stmt_ty
_PyAST_Assert(expr_ty test,expr_ty msg,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2417  _PyAST_Assert(expr_ty test, expr_ty msg, int lineno, int col_offset, int
2418                end_lineno, int end_col_offset, PyArena *arena)
2419  {
2420      stmt_ty p;
2421      if (!test) {
2422          PyErr_SetString(PyExc_ValueError,
2423                          "field 'test' is required for Assert");
2424          return NULL;
2425      }
2426      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2427      if (!p)
2428          return NULL;
2429      p->kind = Assert_kind;
2430      p->v.Assert.test = test;
2431      p->v.Assert.msg = msg;
2432      p->lineno = lineno;
2433      p->col_offset = col_offset;
2434      p->end_lineno = end_lineno;
2435      p->end_col_offset = end_col_offset;
2436      return p;
2437  }
2438  
2439  stmt_ty
_PyAST_Import(asdl_alias_seq * names,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2440  _PyAST_Import(asdl_alias_seq * names, int lineno, int col_offset, int
2441                end_lineno, int end_col_offset, PyArena *arena)
2442  {
2443      stmt_ty p;
2444      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2445      if (!p)
2446          return NULL;
2447      p->kind = Import_kind;
2448      p->v.Import.names = names;
2449      p->lineno = lineno;
2450      p->col_offset = col_offset;
2451      p->end_lineno = end_lineno;
2452      p->end_col_offset = end_col_offset;
2453      return p;
2454  }
2455  
2456  stmt_ty
_PyAST_ImportFrom(identifier module,asdl_alias_seq * names,int level,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2457  _PyAST_ImportFrom(identifier module, asdl_alias_seq * names, int level, int
2458                    lineno, int col_offset, int end_lineno, int end_col_offset,
2459                    PyArena *arena)
2460  {
2461      stmt_ty p;
2462      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2463      if (!p)
2464          return NULL;
2465      p->kind = ImportFrom_kind;
2466      p->v.ImportFrom.module = module;
2467      p->v.ImportFrom.names = names;
2468      p->v.ImportFrom.level = level;
2469      p->lineno = lineno;
2470      p->col_offset = col_offset;
2471      p->end_lineno = end_lineno;
2472      p->end_col_offset = end_col_offset;
2473      return p;
2474  }
2475  
2476  stmt_ty
_PyAST_Global(asdl_identifier_seq * names,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2477  _PyAST_Global(asdl_identifier_seq * names, int lineno, int col_offset, int
2478                end_lineno, int end_col_offset, PyArena *arena)
2479  {
2480      stmt_ty p;
2481      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2482      if (!p)
2483          return NULL;
2484      p->kind = Global_kind;
2485      p->v.Global.names = names;
2486      p->lineno = lineno;
2487      p->col_offset = col_offset;
2488      p->end_lineno = end_lineno;
2489      p->end_col_offset = end_col_offset;
2490      return p;
2491  }
2492  
2493  stmt_ty
_PyAST_Nonlocal(asdl_identifier_seq * names,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2494  _PyAST_Nonlocal(asdl_identifier_seq * names, int lineno, int col_offset, int
2495                  end_lineno, int end_col_offset, PyArena *arena)
2496  {
2497      stmt_ty p;
2498      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2499      if (!p)
2500          return NULL;
2501      p->kind = Nonlocal_kind;
2502      p->v.Nonlocal.names = names;
2503      p->lineno = lineno;
2504      p->col_offset = col_offset;
2505      p->end_lineno = end_lineno;
2506      p->end_col_offset = end_col_offset;
2507      return p;
2508  }
2509  
2510  stmt_ty
_PyAST_Expr(expr_ty value,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2511  _PyAST_Expr(expr_ty value, int lineno, int col_offset, int end_lineno, int
2512              end_col_offset, PyArena *arena)
2513  {
2514      stmt_ty p;
2515      if (!value) {
2516          PyErr_SetString(PyExc_ValueError,
2517                          "field 'value' is required for Expr");
2518          return NULL;
2519      }
2520      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2521      if (!p)
2522          return NULL;
2523      p->kind = Expr_kind;
2524      p->v.Expr.value = value;
2525      p->lineno = lineno;
2526      p->col_offset = col_offset;
2527      p->end_lineno = end_lineno;
2528      p->end_col_offset = end_col_offset;
2529      return p;
2530  }
2531  
2532  stmt_ty
_PyAST_Pass(int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2533  _PyAST_Pass(int lineno, int col_offset, int end_lineno, int end_col_offset,
2534              PyArena *arena)
2535  {
2536      stmt_ty p;
2537      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2538      if (!p)
2539          return NULL;
2540      p->kind = Pass_kind;
2541      p->lineno = lineno;
2542      p->col_offset = col_offset;
2543      p->end_lineno = end_lineno;
2544      p->end_col_offset = end_col_offset;
2545      return p;
2546  }
2547  
2548  stmt_ty
_PyAST_Break(int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2549  _PyAST_Break(int lineno, int col_offset, int end_lineno, int end_col_offset,
2550               PyArena *arena)
2551  {
2552      stmt_ty p;
2553      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2554      if (!p)
2555          return NULL;
2556      p->kind = Break_kind;
2557      p->lineno = lineno;
2558      p->col_offset = col_offset;
2559      p->end_lineno = end_lineno;
2560      p->end_col_offset = end_col_offset;
2561      return p;
2562  }
2563  
2564  stmt_ty
_PyAST_Continue(int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2565  _PyAST_Continue(int lineno, int col_offset, int end_lineno, int end_col_offset,
2566                  PyArena *arena)
2567  {
2568      stmt_ty p;
2569      p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
2570      if (!p)
2571          return NULL;
2572      p->kind = Continue_kind;
2573      p->lineno = lineno;
2574      p->col_offset = col_offset;
2575      p->end_lineno = end_lineno;
2576      p->end_col_offset = end_col_offset;
2577      return p;
2578  }
2579  
2580  expr_ty
_PyAST_BoolOp(boolop_ty op,asdl_expr_seq * values,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2581  _PyAST_BoolOp(boolop_ty op, asdl_expr_seq * values, int lineno, int col_offset,
2582                int end_lineno, int end_col_offset, PyArena *arena)
2583  {
2584      expr_ty p;
2585      if (!op) {
2586          PyErr_SetString(PyExc_ValueError,
2587                          "field 'op' is required for BoolOp");
2588          return NULL;
2589      }
2590      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2591      if (!p)
2592          return NULL;
2593      p->kind = BoolOp_kind;
2594      p->v.BoolOp.op = op;
2595      p->v.BoolOp.values = values;
2596      p->lineno = lineno;
2597      p->col_offset = col_offset;
2598      p->end_lineno = end_lineno;
2599      p->end_col_offset = end_col_offset;
2600      return p;
2601  }
2602  
2603  expr_ty
_PyAST_NamedExpr(expr_ty target,expr_ty value,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2604  _PyAST_NamedExpr(expr_ty target, expr_ty value, int lineno, int col_offset, int
2605                   end_lineno, int end_col_offset, PyArena *arena)
2606  {
2607      expr_ty p;
2608      if (!target) {
2609          PyErr_SetString(PyExc_ValueError,
2610                          "field 'target' is required for NamedExpr");
2611          return NULL;
2612      }
2613      if (!value) {
2614          PyErr_SetString(PyExc_ValueError,
2615                          "field 'value' is required for NamedExpr");
2616          return NULL;
2617      }
2618      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2619      if (!p)
2620          return NULL;
2621      p->kind = NamedExpr_kind;
2622      p->v.NamedExpr.target = target;
2623      p->v.NamedExpr.value = value;
2624      p->lineno = lineno;
2625      p->col_offset = col_offset;
2626      p->end_lineno = end_lineno;
2627      p->end_col_offset = end_col_offset;
2628      return p;
2629  }
2630  
2631  expr_ty
_PyAST_BinOp(expr_ty left,operator_ty op,expr_ty right,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2632  _PyAST_BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno, int
2633               col_offset, int end_lineno, int end_col_offset, PyArena *arena)
2634  {
2635      expr_ty p;
2636      if (!left) {
2637          PyErr_SetString(PyExc_ValueError,
2638                          "field 'left' is required for BinOp");
2639          return NULL;
2640      }
2641      if (!op) {
2642          PyErr_SetString(PyExc_ValueError,
2643                          "field 'op' is required for BinOp");
2644          return NULL;
2645      }
2646      if (!right) {
2647          PyErr_SetString(PyExc_ValueError,
2648                          "field 'right' is required for BinOp");
2649          return NULL;
2650      }
2651      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2652      if (!p)
2653          return NULL;
2654      p->kind = BinOp_kind;
2655      p->v.BinOp.left = left;
2656      p->v.BinOp.op = op;
2657      p->v.BinOp.right = right;
2658      p->lineno = lineno;
2659      p->col_offset = col_offset;
2660      p->end_lineno = end_lineno;
2661      p->end_col_offset = end_col_offset;
2662      return p;
2663  }
2664  
2665  expr_ty
_PyAST_UnaryOp(unaryop_ty op,expr_ty operand,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2666  _PyAST_UnaryOp(unaryop_ty op, expr_ty operand, int lineno, int col_offset, int
2667                 end_lineno, int end_col_offset, PyArena *arena)
2668  {
2669      expr_ty p;
2670      if (!op) {
2671          PyErr_SetString(PyExc_ValueError,
2672                          "field 'op' is required for UnaryOp");
2673          return NULL;
2674      }
2675      if (!operand) {
2676          PyErr_SetString(PyExc_ValueError,
2677                          "field 'operand' is required for UnaryOp");
2678          return NULL;
2679      }
2680      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2681      if (!p)
2682          return NULL;
2683      p->kind = UnaryOp_kind;
2684      p->v.UnaryOp.op = op;
2685      p->v.UnaryOp.operand = operand;
2686      p->lineno = lineno;
2687      p->col_offset = col_offset;
2688      p->end_lineno = end_lineno;
2689      p->end_col_offset = end_col_offset;
2690      return p;
2691  }
2692  
2693  expr_ty
_PyAST_Lambda(arguments_ty args,expr_ty body,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2694  _PyAST_Lambda(arguments_ty args, expr_ty body, int lineno, int col_offset, int
2695                end_lineno, int end_col_offset, PyArena *arena)
2696  {
2697      expr_ty p;
2698      if (!args) {
2699          PyErr_SetString(PyExc_ValueError,
2700                          "field 'args' is required for Lambda");
2701          return NULL;
2702      }
2703      if (!body) {
2704          PyErr_SetString(PyExc_ValueError,
2705                          "field 'body' is required for Lambda");
2706          return NULL;
2707      }
2708      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2709      if (!p)
2710          return NULL;
2711      p->kind = Lambda_kind;
2712      p->v.Lambda.args = args;
2713      p->v.Lambda.body = body;
2714      p->lineno = lineno;
2715      p->col_offset = col_offset;
2716      p->end_lineno = end_lineno;
2717      p->end_col_offset = end_col_offset;
2718      return p;
2719  }
2720  
2721  expr_ty
_PyAST_IfExp(expr_ty test,expr_ty body,expr_ty orelse,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2722  _PyAST_IfExp(expr_ty test, expr_ty body, expr_ty orelse, int lineno, int
2723               col_offset, int end_lineno, int end_col_offset, PyArena *arena)
2724  {
2725      expr_ty p;
2726      if (!test) {
2727          PyErr_SetString(PyExc_ValueError,
2728                          "field 'test' is required for IfExp");
2729          return NULL;
2730      }
2731      if (!body) {
2732          PyErr_SetString(PyExc_ValueError,
2733                          "field 'body' is required for IfExp");
2734          return NULL;
2735      }
2736      if (!orelse) {
2737          PyErr_SetString(PyExc_ValueError,
2738                          "field 'orelse' is required for IfExp");
2739          return NULL;
2740      }
2741      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2742      if (!p)
2743          return NULL;
2744      p->kind = IfExp_kind;
2745      p->v.IfExp.test = test;
2746      p->v.IfExp.body = body;
2747      p->v.IfExp.orelse = orelse;
2748      p->lineno = lineno;
2749      p->col_offset = col_offset;
2750      p->end_lineno = end_lineno;
2751      p->end_col_offset = end_col_offset;
2752      return p;
2753  }
2754  
2755  expr_ty
_PyAST_Dict(asdl_expr_seq * keys,asdl_expr_seq * values,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2756  _PyAST_Dict(asdl_expr_seq * keys, asdl_expr_seq * values, int lineno, int
2757              col_offset, int end_lineno, int end_col_offset, PyArena *arena)
2758  {
2759      expr_ty p;
2760      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2761      if (!p)
2762          return NULL;
2763      p->kind = Dict_kind;
2764      p->v.Dict.keys = keys;
2765      p->v.Dict.values = values;
2766      p->lineno = lineno;
2767      p->col_offset = col_offset;
2768      p->end_lineno = end_lineno;
2769      p->end_col_offset = end_col_offset;
2770      return p;
2771  }
2772  
2773  expr_ty
_PyAST_Set(asdl_expr_seq * elts,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2774  _PyAST_Set(asdl_expr_seq * elts, int lineno, int col_offset, int end_lineno,
2775             int end_col_offset, PyArena *arena)
2776  {
2777      expr_ty p;
2778      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2779      if (!p)
2780          return NULL;
2781      p->kind = Set_kind;
2782      p->v.Set.elts = elts;
2783      p->lineno = lineno;
2784      p->col_offset = col_offset;
2785      p->end_lineno = end_lineno;
2786      p->end_col_offset = end_col_offset;
2787      return p;
2788  }
2789  
2790  expr_ty
_PyAST_ListComp(expr_ty elt,asdl_comprehension_seq * generators,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2791  _PyAST_ListComp(expr_ty elt, asdl_comprehension_seq * generators, int lineno,
2792                  int col_offset, int end_lineno, int end_col_offset, PyArena
2793                  *arena)
2794  {
2795      expr_ty p;
2796      if (!elt) {
2797          PyErr_SetString(PyExc_ValueError,
2798                          "field 'elt' is required for ListComp");
2799          return NULL;
2800      }
2801      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2802      if (!p)
2803          return NULL;
2804      p->kind = ListComp_kind;
2805      p->v.ListComp.elt = elt;
2806      p->v.ListComp.generators = generators;
2807      p->lineno = lineno;
2808      p->col_offset = col_offset;
2809      p->end_lineno = end_lineno;
2810      p->end_col_offset = end_col_offset;
2811      return p;
2812  }
2813  
2814  expr_ty
_PyAST_SetComp(expr_ty elt,asdl_comprehension_seq * generators,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2815  _PyAST_SetComp(expr_ty elt, asdl_comprehension_seq * generators, int lineno,
2816                 int col_offset, int end_lineno, int end_col_offset, PyArena
2817                 *arena)
2818  {
2819      expr_ty p;
2820      if (!elt) {
2821          PyErr_SetString(PyExc_ValueError,
2822                          "field 'elt' is required for SetComp");
2823          return NULL;
2824      }
2825      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2826      if (!p)
2827          return NULL;
2828      p->kind = SetComp_kind;
2829      p->v.SetComp.elt = elt;
2830      p->v.SetComp.generators = generators;
2831      p->lineno = lineno;
2832      p->col_offset = col_offset;
2833      p->end_lineno = end_lineno;
2834      p->end_col_offset = end_col_offset;
2835      return p;
2836  }
2837  
2838  expr_ty
_PyAST_DictComp(expr_ty key,expr_ty value,asdl_comprehension_seq * generators,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2839  _PyAST_DictComp(expr_ty key, expr_ty value, asdl_comprehension_seq *
2840                  generators, int lineno, int col_offset, int end_lineno, int
2841                  end_col_offset, PyArena *arena)
2842  {
2843      expr_ty p;
2844      if (!key) {
2845          PyErr_SetString(PyExc_ValueError,
2846                          "field 'key' is required for DictComp");
2847          return NULL;
2848      }
2849      if (!value) {
2850          PyErr_SetString(PyExc_ValueError,
2851                          "field 'value' is required for DictComp");
2852          return NULL;
2853      }
2854      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2855      if (!p)
2856          return NULL;
2857      p->kind = DictComp_kind;
2858      p->v.DictComp.key = key;
2859      p->v.DictComp.value = value;
2860      p->v.DictComp.generators = generators;
2861      p->lineno = lineno;
2862      p->col_offset = col_offset;
2863      p->end_lineno = end_lineno;
2864      p->end_col_offset = end_col_offset;
2865      return p;
2866  }
2867  
2868  expr_ty
_PyAST_GeneratorExp(expr_ty elt,asdl_comprehension_seq * generators,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2869  _PyAST_GeneratorExp(expr_ty elt, asdl_comprehension_seq * generators, int
2870                      lineno, int col_offset, int end_lineno, int end_col_offset,
2871                      PyArena *arena)
2872  {
2873      expr_ty p;
2874      if (!elt) {
2875          PyErr_SetString(PyExc_ValueError,
2876                          "field 'elt' is required for GeneratorExp");
2877          return NULL;
2878      }
2879      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2880      if (!p)
2881          return NULL;
2882      p->kind = GeneratorExp_kind;
2883      p->v.GeneratorExp.elt = elt;
2884      p->v.GeneratorExp.generators = generators;
2885      p->lineno = lineno;
2886      p->col_offset = col_offset;
2887      p->end_lineno = end_lineno;
2888      p->end_col_offset = end_col_offset;
2889      return p;
2890  }
2891  
2892  expr_ty
_PyAST_Await(expr_ty value,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2893  _PyAST_Await(expr_ty value, int lineno, int col_offset, int end_lineno, int
2894               end_col_offset, PyArena *arena)
2895  {
2896      expr_ty p;
2897      if (!value) {
2898          PyErr_SetString(PyExc_ValueError,
2899                          "field 'value' is required for Await");
2900          return NULL;
2901      }
2902      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2903      if (!p)
2904          return NULL;
2905      p->kind = Await_kind;
2906      p->v.Await.value = value;
2907      p->lineno = lineno;
2908      p->col_offset = col_offset;
2909      p->end_lineno = end_lineno;
2910      p->end_col_offset = end_col_offset;
2911      return p;
2912  }
2913  
2914  expr_ty
_PyAST_Yield(expr_ty value,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2915  _PyAST_Yield(expr_ty value, int lineno, int col_offset, int end_lineno, int
2916               end_col_offset, PyArena *arena)
2917  {
2918      expr_ty p;
2919      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2920      if (!p)
2921          return NULL;
2922      p->kind = Yield_kind;
2923      p->v.Yield.value = value;
2924      p->lineno = lineno;
2925      p->col_offset = col_offset;
2926      p->end_lineno = end_lineno;
2927      p->end_col_offset = end_col_offset;
2928      return p;
2929  }
2930  
2931  expr_ty
_PyAST_YieldFrom(expr_ty value,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2932  _PyAST_YieldFrom(expr_ty value, int lineno, int col_offset, int end_lineno, int
2933                   end_col_offset, PyArena *arena)
2934  {
2935      expr_ty p;
2936      if (!value) {
2937          PyErr_SetString(PyExc_ValueError,
2938                          "field 'value' is required for YieldFrom");
2939          return NULL;
2940      }
2941      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2942      if (!p)
2943          return NULL;
2944      p->kind = YieldFrom_kind;
2945      p->v.YieldFrom.value = value;
2946      p->lineno = lineno;
2947      p->col_offset = col_offset;
2948      p->end_lineno = end_lineno;
2949      p->end_col_offset = end_col_offset;
2950      return p;
2951  }
2952  
2953  expr_ty
_PyAST_Compare(expr_ty left,asdl_int_seq * ops,asdl_expr_seq * comparators,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2954  _PyAST_Compare(expr_ty left, asdl_int_seq * ops, asdl_expr_seq * comparators,
2955                 int lineno, int col_offset, int end_lineno, int end_col_offset,
2956                 PyArena *arena)
2957  {
2958      expr_ty p;
2959      if (!left) {
2960          PyErr_SetString(PyExc_ValueError,
2961                          "field 'left' is required for Compare");
2962          return NULL;
2963      }
2964      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2965      if (!p)
2966          return NULL;
2967      p->kind = Compare_kind;
2968      p->v.Compare.left = left;
2969      p->v.Compare.ops = ops;
2970      p->v.Compare.comparators = comparators;
2971      p->lineno = lineno;
2972      p->col_offset = col_offset;
2973      p->end_lineno = end_lineno;
2974      p->end_col_offset = end_col_offset;
2975      return p;
2976  }
2977  
2978  expr_ty
_PyAST_Call(expr_ty func,asdl_expr_seq * args,asdl_keyword_seq * keywords,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)2979  _PyAST_Call(expr_ty func, asdl_expr_seq * args, asdl_keyword_seq * keywords,
2980              int lineno, int col_offset, int end_lineno, int end_col_offset,
2981              PyArena *arena)
2982  {
2983      expr_ty p;
2984      if (!func) {
2985          PyErr_SetString(PyExc_ValueError,
2986                          "field 'func' is required for Call");
2987          return NULL;
2988      }
2989      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
2990      if (!p)
2991          return NULL;
2992      p->kind = Call_kind;
2993      p->v.Call.func = func;
2994      p->v.Call.args = args;
2995      p->v.Call.keywords = keywords;
2996      p->lineno = lineno;
2997      p->col_offset = col_offset;
2998      p->end_lineno = end_lineno;
2999      p->end_col_offset = end_col_offset;
3000      return p;
3001  }
3002  
3003  expr_ty
_PyAST_FormattedValue(expr_ty value,int conversion,expr_ty format_spec,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)3004  _PyAST_FormattedValue(expr_ty value, int conversion, expr_ty format_spec, int
3005                        lineno, int col_offset, int end_lineno, int
3006                        end_col_offset, PyArena *arena)
3007  {
3008      expr_ty p;
3009      if (!value) {
3010          PyErr_SetString(PyExc_ValueError,
3011                          "field 'value' is required for FormattedValue");
3012          return NULL;
3013      }
3014      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
3015      if (!p)
3016          return NULL;
3017      p->kind = FormattedValue_kind;
3018      p->v.FormattedValue.value = value;
3019      p->v.FormattedValue.conversion = conversion;
3020      p->v.FormattedValue.format_spec = format_spec;
3021      p->lineno = lineno;
3022      p->col_offset = col_offset;
3023      p->end_lineno = end_lineno;
3024      p->end_col_offset = end_col_offset;
3025      return p;
3026  }
3027  
3028  expr_ty
_PyAST_JoinedStr(asdl_expr_seq * values,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)3029  _PyAST_JoinedStr(asdl_expr_seq * values, int lineno, int col_offset, int
3030                   end_lineno, int end_col_offset, PyArena *arena)
3031  {
3032      expr_ty p;
3033      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
3034      if (!p)
3035          return NULL;
3036      p->kind = JoinedStr_kind;
3037      p->v.JoinedStr.values = values;
3038      p->lineno = lineno;
3039      p->col_offset = col_offset;
3040      p->end_lineno = end_lineno;
3041      p->end_col_offset = end_col_offset;
3042      return p;
3043  }
3044  
3045  expr_ty
_PyAST_Constant(constant value,string kind,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)3046  _PyAST_Constant(constant value, string kind, int lineno, int col_offset, int
3047                  end_lineno, int end_col_offset, PyArena *arena)
3048  {
3049      expr_ty p;
3050      if (!value) {
3051          PyErr_SetString(PyExc_ValueError,
3052                          "field 'value' is required for Constant");
3053          return NULL;
3054      }
3055      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
3056      if (!p)
3057          return NULL;
3058      p->kind = Constant_kind;
3059      p->v.Constant.value = value;
3060      p->v.Constant.kind = kind;
3061      p->lineno = lineno;
3062      p->col_offset = col_offset;
3063      p->end_lineno = end_lineno;
3064      p->end_col_offset = end_col_offset;
3065      return p;
3066  }
3067  
3068  expr_ty
_PyAST_Attribute(expr_ty value,identifier attr,expr_context_ty ctx,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)3069  _PyAST_Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int
3070                   lineno, int col_offset, int end_lineno, int end_col_offset,
3071                   PyArena *arena)
3072  {
3073      expr_ty p;
3074      if (!value) {
3075          PyErr_SetString(PyExc_ValueError,
3076                          "field 'value' is required for Attribute");
3077          return NULL;
3078      }
3079      if (!attr) {
3080          PyErr_SetString(PyExc_ValueError,
3081                          "field 'attr' is required for Attribute");
3082          return NULL;
3083      }
3084      if (!ctx) {
3085          PyErr_SetString(PyExc_ValueError,
3086                          "field 'ctx' is required for Attribute");
3087          return NULL;
3088      }
3089      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
3090      if (!p)
3091          return NULL;
3092      p->kind = Attribute_kind;
3093      p->v.Attribute.value = value;
3094      p->v.Attribute.attr = attr;
3095      p->v.Attribute.ctx = ctx;
3096      p->lineno = lineno;
3097      p->col_offset = col_offset;
3098      p->end_lineno = end_lineno;
3099      p->end_col_offset = end_col_offset;
3100      return p;
3101  }
3102  
3103  expr_ty
_PyAST_Subscript(expr_ty value,expr_ty slice,expr_context_ty ctx,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)3104  _PyAST_Subscript(expr_ty value, expr_ty slice, expr_context_ty ctx, int lineno,
3105                   int col_offset, int end_lineno, int end_col_offset, PyArena
3106                   *arena)
3107  {
3108      expr_ty p;
3109      if (!value) {
3110          PyErr_SetString(PyExc_ValueError,
3111                          "field 'value' is required for Subscript");
3112          return NULL;
3113      }
3114      if (!slice) {
3115          PyErr_SetString(PyExc_ValueError,
3116                          "field 'slice' is required for Subscript");
3117          return NULL;
3118      }
3119      if (!ctx) {
3120          PyErr_SetString(PyExc_ValueError,
3121                          "field 'ctx' is required for Subscript");
3122          return NULL;
3123      }
3124      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
3125      if (!p)
3126          return NULL;
3127      p->kind = Subscript_kind;
3128      p->v.Subscript.value = value;
3129      p->v.Subscript.slice = slice;
3130      p->v.Subscript.ctx = ctx;
3131      p->lineno = lineno;
3132      p->col_offset = col_offset;
3133      p->end_lineno = end_lineno;
3134      p->end_col_offset = end_col_offset;
3135      return p;
3136  }
3137  
3138  expr_ty
_PyAST_Starred(expr_ty value,expr_context_ty ctx,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)3139  _PyAST_Starred(expr_ty value, expr_context_ty ctx, int lineno, int col_offset,
3140                 int end_lineno, int end_col_offset, PyArena *arena)
3141  {
3142      expr_ty p;
3143      if (!value) {
3144          PyErr_SetString(PyExc_ValueError,
3145                          "field 'value' is required for Starred");
3146          return NULL;
3147      }
3148      if (!ctx) {
3149          PyErr_SetString(PyExc_ValueError,
3150                          "field 'ctx' is required for Starred");
3151          return NULL;
3152      }
3153      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
3154      if (!p)
3155          return NULL;
3156      p->kind = Starred_kind;
3157      p->v.Starred.value = value;
3158      p->v.Starred.ctx = ctx;
3159      p->lineno = lineno;
3160      p->col_offset = col_offset;
3161      p->end_lineno = end_lineno;
3162      p->end_col_offset = end_col_offset;
3163      return p;
3164  }
3165  
3166  expr_ty
_PyAST_Name(identifier id,expr_context_ty ctx,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)3167  _PyAST_Name(identifier id, expr_context_ty ctx, int lineno, int col_offset, int
3168              end_lineno, int end_col_offset, PyArena *arena)
3169  {
3170      expr_ty p;
3171      if (!id) {
3172          PyErr_SetString(PyExc_ValueError,
3173                          "field 'id' is required for Name");
3174          return NULL;
3175      }
3176      if (!ctx) {
3177          PyErr_SetString(PyExc_ValueError,
3178                          "field 'ctx' is required for Name");
3179          return NULL;
3180      }
3181      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
3182      if (!p)
3183          return NULL;
3184      p->kind = Name_kind;
3185      p->v.Name.id = id;
3186      p->v.Name.ctx = ctx;
3187      p->lineno = lineno;
3188      p->col_offset = col_offset;
3189      p->end_lineno = end_lineno;
3190      p->end_col_offset = end_col_offset;
3191      return p;
3192  }
3193  
3194  expr_ty
_PyAST_List(asdl_expr_seq * elts,expr_context_ty ctx,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)3195  _PyAST_List(asdl_expr_seq * elts, expr_context_ty ctx, int lineno, int
3196              col_offset, int end_lineno, int end_col_offset, PyArena *arena)
3197  {
3198      expr_ty p;
3199      if (!ctx) {
3200          PyErr_SetString(PyExc_ValueError,
3201                          "field 'ctx' is required for List");
3202          return NULL;
3203      }
3204      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
3205      if (!p)
3206          return NULL;
3207      p->kind = List_kind;
3208      p->v.List.elts = elts;
3209      p->v.List.ctx = ctx;
3210      p->lineno = lineno;
3211      p->col_offset = col_offset;
3212      p->end_lineno = end_lineno;
3213      p->end_col_offset = end_col_offset;
3214      return p;
3215  }
3216  
3217  expr_ty
_PyAST_Tuple(asdl_expr_seq * elts,expr_context_ty ctx,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)3218  _PyAST_Tuple(asdl_expr_seq * elts, expr_context_ty ctx, int lineno, int
3219               col_offset, int end_lineno, int end_col_offset, PyArena *arena)
3220  {
3221      expr_ty p;
3222      if (!ctx) {
3223          PyErr_SetString(PyExc_ValueError,
3224                          "field 'ctx' is required for Tuple");
3225          return NULL;
3226      }
3227      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
3228      if (!p)
3229          return NULL;
3230      p->kind = Tuple_kind;
3231      p->v.Tuple.elts = elts;
3232      p->v.Tuple.ctx = ctx;
3233      p->lineno = lineno;
3234      p->col_offset = col_offset;
3235      p->end_lineno = end_lineno;
3236      p->end_col_offset = end_col_offset;
3237      return p;
3238  }
3239  
3240  expr_ty
_PyAST_Slice(expr_ty lower,expr_ty upper,expr_ty step,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)3241  _PyAST_Slice(expr_ty lower, expr_ty upper, expr_ty step, int lineno, int
3242               col_offset, int end_lineno, int end_col_offset, PyArena *arena)
3243  {
3244      expr_ty p;
3245      p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p));
3246      if (!p)
3247          return NULL;
3248      p->kind = Slice_kind;
3249      p->v.Slice.lower = lower;
3250      p->v.Slice.upper = upper;
3251      p->v.Slice.step = step;
3252      p->lineno = lineno;
3253      p->col_offset = col_offset;
3254      p->end_lineno = end_lineno;
3255      p->end_col_offset = end_col_offset;
3256      return p;
3257  }
3258  
3259  comprehension_ty
_PyAST_comprehension(expr_ty target,expr_ty iter,asdl_expr_seq * ifs,int is_async,PyArena * arena)3260  _PyAST_comprehension(expr_ty target, expr_ty iter, asdl_expr_seq * ifs, int
3261                       is_async, PyArena *arena)
3262  {
3263      comprehension_ty p;
3264      if (!target) {
3265          PyErr_SetString(PyExc_ValueError,
3266                          "field 'target' is required for comprehension");
3267          return NULL;
3268      }
3269      if (!iter) {
3270          PyErr_SetString(PyExc_ValueError,
3271                          "field 'iter' is required for comprehension");
3272          return NULL;
3273      }
3274      p = (comprehension_ty)_PyArena_Malloc(arena, sizeof(*p));
3275      if (!p)
3276          return NULL;
3277      p->target = target;
3278      p->iter = iter;
3279      p->ifs = ifs;
3280      p->is_async = is_async;
3281      return p;
3282  }
3283  
3284  excepthandler_ty
_PyAST_ExceptHandler(expr_ty type,identifier name,asdl_stmt_seq * body,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)3285  _PyAST_ExceptHandler(expr_ty type, identifier name, asdl_stmt_seq * body, int
3286                       lineno, int col_offset, int end_lineno, int
3287                       end_col_offset, PyArena *arena)
3288  {
3289      excepthandler_ty p;
3290      p = (excepthandler_ty)_PyArena_Malloc(arena, sizeof(*p));
3291      if (!p)
3292          return NULL;
3293      p->kind = ExceptHandler_kind;
3294      p->v.ExceptHandler.type = type;
3295      p->v.ExceptHandler.name = name;
3296      p->v.ExceptHandler.body = body;
3297      p->lineno = lineno;
3298      p->col_offset = col_offset;
3299      p->end_lineno = end_lineno;
3300      p->end_col_offset = end_col_offset;
3301      return p;
3302  }
3303  
3304  arguments_ty
_PyAST_arguments(asdl_arg_seq * posonlyargs,asdl_arg_seq * args,arg_ty vararg,asdl_arg_seq * kwonlyargs,asdl_expr_seq * kw_defaults,arg_ty kwarg,asdl_expr_seq * defaults,PyArena * arena)3305  _PyAST_arguments(asdl_arg_seq * posonlyargs, asdl_arg_seq * args, arg_ty
3306                   vararg, asdl_arg_seq * kwonlyargs, asdl_expr_seq *
3307                   kw_defaults, arg_ty kwarg, asdl_expr_seq * defaults, PyArena
3308                   *arena)
3309  {
3310      arguments_ty p;
3311      p = (arguments_ty)_PyArena_Malloc(arena, sizeof(*p));
3312      if (!p)
3313          return NULL;
3314      p->posonlyargs = posonlyargs;
3315      p->args = args;
3316      p->vararg = vararg;
3317      p->kwonlyargs = kwonlyargs;
3318      p->kw_defaults = kw_defaults;
3319      p->kwarg = kwarg;
3320      p->defaults = defaults;
3321      return p;
3322  }
3323  
3324  arg_ty
_PyAST_arg(identifier arg,expr_ty annotation,string type_comment,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)3325  _PyAST_arg(identifier arg, expr_ty annotation, string type_comment, int lineno,
3326             int col_offset, int end_lineno, int end_col_offset, PyArena *arena)
3327  {
3328      arg_ty p;
3329      if (!arg) {
3330          PyErr_SetString(PyExc_ValueError,
3331                          "field 'arg' is required for arg");
3332          return NULL;
3333      }
3334      p = (arg_ty)_PyArena_Malloc(arena, sizeof(*p));
3335      if (!p)
3336          return NULL;
3337      p->arg = arg;
3338      p->annotation = annotation;
3339      p->type_comment = type_comment;
3340      p->lineno = lineno;
3341      p->col_offset = col_offset;
3342      p->end_lineno = end_lineno;
3343      p->end_col_offset = end_col_offset;
3344      return p;
3345  }
3346  
3347  keyword_ty
_PyAST_keyword(identifier arg,expr_ty value,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)3348  _PyAST_keyword(identifier arg, expr_ty value, int lineno, int col_offset, int
3349                 end_lineno, int end_col_offset, PyArena *arena)
3350  {
3351      keyword_ty p;
3352      if (!value) {
3353          PyErr_SetString(PyExc_ValueError,
3354                          "field 'value' is required for keyword");
3355          return NULL;
3356      }
3357      p = (keyword_ty)_PyArena_Malloc(arena, sizeof(*p));
3358      if (!p)
3359          return NULL;
3360      p->arg = arg;
3361      p->value = value;
3362      p->lineno = lineno;
3363      p->col_offset = col_offset;
3364      p->end_lineno = end_lineno;
3365      p->end_col_offset = end_col_offset;
3366      return p;
3367  }
3368  
3369  alias_ty
_PyAST_alias(identifier name,identifier asname,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)3370  _PyAST_alias(identifier name, identifier asname, int lineno, int col_offset,
3371               int end_lineno, int end_col_offset, PyArena *arena)
3372  {
3373      alias_ty p;
3374      if (!name) {
3375          PyErr_SetString(PyExc_ValueError,
3376                          "field 'name' is required for alias");
3377          return NULL;
3378      }
3379      p = (alias_ty)_PyArena_Malloc(arena, sizeof(*p));
3380      if (!p)
3381          return NULL;
3382      p->name = name;
3383      p->asname = asname;
3384      p->lineno = lineno;
3385      p->col_offset = col_offset;
3386      p->end_lineno = end_lineno;
3387      p->end_col_offset = end_col_offset;
3388      return p;
3389  }
3390  
3391  withitem_ty
_PyAST_withitem(expr_ty context_expr,expr_ty optional_vars,PyArena * arena)3392  _PyAST_withitem(expr_ty context_expr, expr_ty optional_vars, PyArena *arena)
3393  {
3394      withitem_ty p;
3395      if (!context_expr) {
3396          PyErr_SetString(PyExc_ValueError,
3397                          "field 'context_expr' is required for withitem");
3398          return NULL;
3399      }
3400      p = (withitem_ty)_PyArena_Malloc(arena, sizeof(*p));
3401      if (!p)
3402          return NULL;
3403      p->context_expr = context_expr;
3404      p->optional_vars = optional_vars;
3405      return p;
3406  }
3407  
3408  match_case_ty
_PyAST_match_case(pattern_ty pattern,expr_ty guard,asdl_stmt_seq * body,PyArena * arena)3409  _PyAST_match_case(pattern_ty pattern, expr_ty guard, asdl_stmt_seq * body,
3410                    PyArena *arena)
3411  {
3412      match_case_ty p;
3413      if (!pattern) {
3414          PyErr_SetString(PyExc_ValueError,
3415                          "field 'pattern' is required for match_case");
3416          return NULL;
3417      }
3418      p = (match_case_ty)_PyArena_Malloc(arena, sizeof(*p));
3419      if (!p)
3420          return NULL;
3421      p->pattern = pattern;
3422      p->guard = guard;
3423      p->body = body;
3424      return p;
3425  }
3426  
3427  pattern_ty
_PyAST_MatchValue(expr_ty value,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)3428  _PyAST_MatchValue(expr_ty value, int lineno, int col_offset, int end_lineno,
3429                    int end_col_offset, PyArena *arena)
3430  {
3431      pattern_ty p;
3432      if (!value) {
3433          PyErr_SetString(PyExc_ValueError,
3434                          "field 'value' is required for MatchValue");
3435          return NULL;
3436      }
3437      p = (pattern_ty)_PyArena_Malloc(arena, sizeof(*p));
3438      if (!p)
3439          return NULL;
3440      p->kind = MatchValue_kind;
3441      p->v.MatchValue.value = value;
3442      p->lineno = lineno;
3443      p->col_offset = col_offset;
3444      p->end_lineno = end_lineno;
3445      p->end_col_offset = end_col_offset;
3446      return p;
3447  }
3448  
3449  pattern_ty
_PyAST_MatchSingleton(constant value,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)3450  _PyAST_MatchSingleton(constant value, int lineno, int col_offset, int
3451                        end_lineno, int end_col_offset, PyArena *arena)
3452  {
3453      pattern_ty p;
3454      if (!value) {
3455          PyErr_SetString(PyExc_ValueError,
3456                          "field 'value' is required for MatchSingleton");
3457          return NULL;
3458      }
3459      p = (pattern_ty)_PyArena_Malloc(arena, sizeof(*p));
3460      if (!p)
3461          return NULL;
3462      p->kind = MatchSingleton_kind;
3463      p->v.MatchSingleton.value = value;
3464      p->lineno = lineno;
3465      p->col_offset = col_offset;
3466      p->end_lineno = end_lineno;
3467      p->end_col_offset = end_col_offset;
3468      return p;
3469  }
3470  
3471  pattern_ty
_PyAST_MatchSequence(asdl_pattern_seq * patterns,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)3472  _PyAST_MatchSequence(asdl_pattern_seq * patterns, int lineno, int col_offset,
3473                       int end_lineno, int end_col_offset, PyArena *arena)
3474  {
3475      pattern_ty p;
3476      p = (pattern_ty)_PyArena_Malloc(arena, sizeof(*p));
3477      if (!p)
3478          return NULL;
3479      p->kind = MatchSequence_kind;
3480      p->v.MatchSequence.patterns = patterns;
3481      p->lineno = lineno;
3482      p->col_offset = col_offset;
3483      p->end_lineno = end_lineno;
3484      p->end_col_offset = end_col_offset;
3485      return p;
3486  }
3487  
3488  pattern_ty
_PyAST_MatchMapping(asdl_expr_seq * keys,asdl_pattern_seq * patterns,identifier rest,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)3489  _PyAST_MatchMapping(asdl_expr_seq * keys, asdl_pattern_seq * patterns,
3490                      identifier rest, int lineno, int col_offset, int
3491                      end_lineno, int end_col_offset, PyArena *arena)
3492  {
3493      pattern_ty p;
3494      p = (pattern_ty)_PyArena_Malloc(arena, sizeof(*p));
3495      if (!p)
3496          return NULL;
3497      p->kind = MatchMapping_kind;
3498      p->v.MatchMapping.keys = keys;
3499      p->v.MatchMapping.patterns = patterns;
3500      p->v.MatchMapping.rest = rest;
3501      p->lineno = lineno;
3502      p->col_offset = col_offset;
3503      p->end_lineno = end_lineno;
3504      p->end_col_offset = end_col_offset;
3505      return p;
3506  }
3507  
3508  pattern_ty
_PyAST_MatchClass(expr_ty cls,asdl_pattern_seq * patterns,asdl_identifier_seq * kwd_attrs,asdl_pattern_seq * kwd_patterns,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)3509  _PyAST_MatchClass(expr_ty cls, asdl_pattern_seq * patterns, asdl_identifier_seq
3510                    * kwd_attrs, asdl_pattern_seq * kwd_patterns, int lineno, int
3511                    col_offset, int end_lineno, int end_col_offset, PyArena
3512                    *arena)
3513  {
3514      pattern_ty p;
3515      if (!cls) {
3516          PyErr_SetString(PyExc_ValueError,
3517                          "field 'cls' is required for MatchClass");
3518          return NULL;
3519      }
3520      p = (pattern_ty)_PyArena_Malloc(arena, sizeof(*p));
3521      if (!p)
3522          return NULL;
3523      p->kind = MatchClass_kind;
3524      p->v.MatchClass.cls = cls;
3525      p->v.MatchClass.patterns = patterns;
3526      p->v.MatchClass.kwd_attrs = kwd_attrs;
3527      p->v.MatchClass.kwd_patterns = kwd_patterns;
3528      p->lineno = lineno;
3529      p->col_offset = col_offset;
3530      p->end_lineno = end_lineno;
3531      p->end_col_offset = end_col_offset;
3532      return p;
3533  }
3534  
3535  pattern_ty
_PyAST_MatchStar(identifier name,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)3536  _PyAST_MatchStar(identifier name, int lineno, int col_offset, int end_lineno,
3537                   int end_col_offset, PyArena *arena)
3538  {
3539      pattern_ty p;
3540      p = (pattern_ty)_PyArena_Malloc(arena, sizeof(*p));
3541      if (!p)
3542          return NULL;
3543      p->kind = MatchStar_kind;
3544      p->v.MatchStar.name = name;
3545      p->lineno = lineno;
3546      p->col_offset = col_offset;
3547      p->end_lineno = end_lineno;
3548      p->end_col_offset = end_col_offset;
3549      return p;
3550  }
3551  
3552  pattern_ty
_PyAST_MatchAs(pattern_ty pattern,identifier name,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)3553  _PyAST_MatchAs(pattern_ty pattern, identifier name, int lineno, int col_offset,
3554                 int end_lineno, int end_col_offset, PyArena *arena)
3555  {
3556      pattern_ty p;
3557      p = (pattern_ty)_PyArena_Malloc(arena, sizeof(*p));
3558      if (!p)
3559          return NULL;
3560      p->kind = MatchAs_kind;
3561      p->v.MatchAs.pattern = pattern;
3562      p->v.MatchAs.name = name;
3563      p->lineno = lineno;
3564      p->col_offset = col_offset;
3565      p->end_lineno = end_lineno;
3566      p->end_col_offset = end_col_offset;
3567      return p;
3568  }
3569  
3570  pattern_ty
_PyAST_MatchOr(asdl_pattern_seq * patterns,int lineno,int col_offset,int end_lineno,int end_col_offset,PyArena * arena)3571  _PyAST_MatchOr(asdl_pattern_seq * patterns, int lineno, int col_offset, int
3572                 end_lineno, int end_col_offset, PyArena *arena)
3573  {
3574      pattern_ty p;
3575      p = (pattern_ty)_PyArena_Malloc(arena, sizeof(*p));
3576      if (!p)
3577          return NULL;
3578      p->kind = MatchOr_kind;
3579      p->v.MatchOr.patterns = patterns;
3580      p->lineno = lineno;
3581      p->col_offset = col_offset;
3582      p->end_lineno = end_lineno;
3583      p->end_col_offset = end_col_offset;
3584      return p;
3585  }
3586  
3587  type_ignore_ty
_PyAST_TypeIgnore(int lineno,string tag,PyArena * arena)3588  _PyAST_TypeIgnore(int lineno, string tag, PyArena *arena)
3589  {
3590      type_ignore_ty p;
3591      if (!tag) {
3592          PyErr_SetString(PyExc_ValueError,
3593                          "field 'tag' is required for TypeIgnore");
3594          return NULL;
3595      }
3596      p = (type_ignore_ty)_PyArena_Malloc(arena, sizeof(*p));
3597      if (!p)
3598          return NULL;
3599      p->kind = TypeIgnore_kind;
3600      p->v.TypeIgnore.lineno = lineno;
3601      p->v.TypeIgnore.tag = tag;
3602      return p;
3603  }
3604  
3605  
3606  PyObject*
ast2obj_mod(struct ast_state * state,void * _o)3607  ast2obj_mod(struct ast_state *state, void* _o)
3608  {
3609      mod_ty o = (mod_ty)_o;
3610      PyObject *result = NULL, *value = NULL;
3611      PyTypeObject *tp;
3612      if (!o) {
3613          Py_RETURN_NONE;
3614      }
3615      if (++state->recursion_depth > state->recursion_limit) {
3616          PyErr_SetString(PyExc_RecursionError,
3617              "maximum recursion depth exceeded during ast construction");
3618          return 0;
3619      }
3620      switch (o->kind) {
3621      case Module_kind:
3622          tp = (PyTypeObject *)state->Module_type;
3623          result = PyType_GenericNew(tp, NULL, NULL);
3624          if (!result) goto failed;
3625          value = ast2obj_list(state, (asdl_seq*)o->v.Module.body, ast2obj_stmt);
3626          if (!value) goto failed;
3627          if (PyObject_SetAttr(result, state->body, value) == -1)
3628              goto failed;
3629          Py_DECREF(value);
3630          value = ast2obj_list(state, (asdl_seq*)o->v.Module.type_ignores,
3631                               ast2obj_type_ignore);
3632          if (!value) goto failed;
3633          if (PyObject_SetAttr(result, state->type_ignores, value) == -1)
3634              goto failed;
3635          Py_DECREF(value);
3636          break;
3637      case Interactive_kind:
3638          tp = (PyTypeObject *)state->Interactive_type;
3639          result = PyType_GenericNew(tp, NULL, NULL);
3640          if (!result) goto failed;
3641          value = ast2obj_list(state, (asdl_seq*)o->v.Interactive.body,
3642                               ast2obj_stmt);
3643          if (!value) goto failed;
3644          if (PyObject_SetAttr(result, state->body, value) == -1)
3645              goto failed;
3646          Py_DECREF(value);
3647          break;
3648      case Expression_kind:
3649          tp = (PyTypeObject *)state->Expression_type;
3650          result = PyType_GenericNew(tp, NULL, NULL);
3651          if (!result) goto failed;
3652          value = ast2obj_expr(state, o->v.Expression.body);
3653          if (!value) goto failed;
3654          if (PyObject_SetAttr(result, state->body, value) == -1)
3655              goto failed;
3656          Py_DECREF(value);
3657          break;
3658      case FunctionType_kind:
3659          tp = (PyTypeObject *)state->FunctionType_type;
3660          result = PyType_GenericNew(tp, NULL, NULL);
3661          if (!result) goto failed;
3662          value = ast2obj_list(state, (asdl_seq*)o->v.FunctionType.argtypes,
3663                               ast2obj_expr);
3664          if (!value) goto failed;
3665          if (PyObject_SetAttr(result, state->argtypes, value) == -1)
3666              goto failed;
3667          Py_DECREF(value);
3668          value = ast2obj_expr(state, o->v.FunctionType.returns);
3669          if (!value) goto failed;
3670          if (PyObject_SetAttr(result, state->returns, value) == -1)
3671              goto failed;
3672          Py_DECREF(value);
3673          break;
3674      }
3675      state->recursion_depth--;
3676      return result;
3677  failed:
3678      Py_XDECREF(value);
3679      Py_XDECREF(result);
3680      return NULL;
3681  }
3682  
3683  PyObject*
ast2obj_stmt(struct ast_state * state,void * _o)3684  ast2obj_stmt(struct ast_state *state, void* _o)
3685  {
3686      stmt_ty o = (stmt_ty)_o;
3687      PyObject *result = NULL, *value = NULL;
3688      PyTypeObject *tp;
3689      if (!o) {
3690          Py_RETURN_NONE;
3691      }
3692      if (++state->recursion_depth > state->recursion_limit) {
3693          PyErr_SetString(PyExc_RecursionError,
3694              "maximum recursion depth exceeded during ast construction");
3695          return 0;
3696      }
3697      switch (o->kind) {
3698      case FunctionDef_kind:
3699          tp = (PyTypeObject *)state->FunctionDef_type;
3700          result = PyType_GenericNew(tp, NULL, NULL);
3701          if (!result) goto failed;
3702          value = ast2obj_identifier(state, o->v.FunctionDef.name);
3703          if (!value) goto failed;
3704          if (PyObject_SetAttr(result, state->name, value) == -1)
3705              goto failed;
3706          Py_DECREF(value);
3707          value = ast2obj_arguments(state, o->v.FunctionDef.args);
3708          if (!value) goto failed;
3709          if (PyObject_SetAttr(result, state->args, value) == -1)
3710              goto failed;
3711          Py_DECREF(value);
3712          value = ast2obj_list(state, (asdl_seq*)o->v.FunctionDef.body,
3713                               ast2obj_stmt);
3714          if (!value) goto failed;
3715          if (PyObject_SetAttr(result, state->body, value) == -1)
3716              goto failed;
3717          Py_DECREF(value);
3718          value = ast2obj_list(state, (asdl_seq*)o->v.FunctionDef.decorator_list,
3719                               ast2obj_expr);
3720          if (!value) goto failed;
3721          if (PyObject_SetAttr(result, state->decorator_list, value) == -1)
3722              goto failed;
3723          Py_DECREF(value);
3724          value = ast2obj_expr(state, o->v.FunctionDef.returns);
3725          if (!value) goto failed;
3726          if (PyObject_SetAttr(result, state->returns, value) == -1)
3727              goto failed;
3728          Py_DECREF(value);
3729          value = ast2obj_string(state, o->v.FunctionDef.type_comment);
3730          if (!value) goto failed;
3731          if (PyObject_SetAttr(result, state->type_comment, value) == -1)
3732              goto failed;
3733          Py_DECREF(value);
3734          break;
3735      case AsyncFunctionDef_kind:
3736          tp = (PyTypeObject *)state->AsyncFunctionDef_type;
3737          result = PyType_GenericNew(tp, NULL, NULL);
3738          if (!result) goto failed;
3739          value = ast2obj_identifier(state, o->v.AsyncFunctionDef.name);
3740          if (!value) goto failed;
3741          if (PyObject_SetAttr(result, state->name, value) == -1)
3742              goto failed;
3743          Py_DECREF(value);
3744          value = ast2obj_arguments(state, o->v.AsyncFunctionDef.args);
3745          if (!value) goto failed;
3746          if (PyObject_SetAttr(result, state->args, value) == -1)
3747              goto failed;
3748          Py_DECREF(value);
3749          value = ast2obj_list(state, (asdl_seq*)o->v.AsyncFunctionDef.body,
3750                               ast2obj_stmt);
3751          if (!value) goto failed;
3752          if (PyObject_SetAttr(result, state->body, value) == -1)
3753              goto failed;
3754          Py_DECREF(value);
3755          value = ast2obj_list(state,
3756                               (asdl_seq*)o->v.AsyncFunctionDef.decorator_list,
3757                               ast2obj_expr);
3758          if (!value) goto failed;
3759          if (PyObject_SetAttr(result, state->decorator_list, value) == -1)
3760              goto failed;
3761          Py_DECREF(value);
3762          value = ast2obj_expr(state, o->v.AsyncFunctionDef.returns);
3763          if (!value) goto failed;
3764          if (PyObject_SetAttr(result, state->returns, value) == -1)
3765              goto failed;
3766          Py_DECREF(value);
3767          value = ast2obj_string(state, o->v.AsyncFunctionDef.type_comment);
3768          if (!value) goto failed;
3769          if (PyObject_SetAttr(result, state->type_comment, value) == -1)
3770              goto failed;
3771          Py_DECREF(value);
3772          break;
3773      case ClassDef_kind:
3774          tp = (PyTypeObject *)state->ClassDef_type;
3775          result = PyType_GenericNew(tp, NULL, NULL);
3776          if (!result) goto failed;
3777          value = ast2obj_identifier(state, o->v.ClassDef.name);
3778          if (!value) goto failed;
3779          if (PyObject_SetAttr(result, state->name, value) == -1)
3780              goto failed;
3781          Py_DECREF(value);
3782          value = ast2obj_list(state, (asdl_seq*)o->v.ClassDef.bases,
3783                               ast2obj_expr);
3784          if (!value) goto failed;
3785          if (PyObject_SetAttr(result, state->bases, value) == -1)
3786              goto failed;
3787          Py_DECREF(value);
3788          value = ast2obj_list(state, (asdl_seq*)o->v.ClassDef.keywords,
3789                               ast2obj_keyword);
3790          if (!value) goto failed;
3791          if (PyObject_SetAttr(result, state->keywords, value) == -1)
3792              goto failed;
3793          Py_DECREF(value);
3794          value = ast2obj_list(state, (asdl_seq*)o->v.ClassDef.body,
3795                               ast2obj_stmt);
3796          if (!value) goto failed;
3797          if (PyObject_SetAttr(result, state->body, value) == -1)
3798              goto failed;
3799          Py_DECREF(value);
3800          value = ast2obj_list(state, (asdl_seq*)o->v.ClassDef.decorator_list,
3801                               ast2obj_expr);
3802          if (!value) goto failed;
3803          if (PyObject_SetAttr(result, state->decorator_list, value) == -1)
3804              goto failed;
3805          Py_DECREF(value);
3806          break;
3807      case Return_kind:
3808          tp = (PyTypeObject *)state->Return_type;
3809          result = PyType_GenericNew(tp, NULL, NULL);
3810          if (!result) goto failed;
3811          value = ast2obj_expr(state, o->v.Return.value);
3812          if (!value) goto failed;
3813          if (PyObject_SetAttr(result, state->value, value) == -1)
3814              goto failed;
3815          Py_DECREF(value);
3816          break;
3817      case Delete_kind:
3818          tp = (PyTypeObject *)state->Delete_type;
3819          result = PyType_GenericNew(tp, NULL, NULL);
3820          if (!result) goto failed;
3821          value = ast2obj_list(state, (asdl_seq*)o->v.Delete.targets,
3822                               ast2obj_expr);
3823          if (!value) goto failed;
3824          if (PyObject_SetAttr(result, state->targets, value) == -1)
3825              goto failed;
3826          Py_DECREF(value);
3827          break;
3828      case Assign_kind:
3829          tp = (PyTypeObject *)state->Assign_type;
3830          result = PyType_GenericNew(tp, NULL, NULL);
3831          if (!result) goto failed;
3832          value = ast2obj_list(state, (asdl_seq*)o->v.Assign.targets,
3833                               ast2obj_expr);
3834          if (!value) goto failed;
3835          if (PyObject_SetAttr(result, state->targets, value) == -1)
3836              goto failed;
3837          Py_DECREF(value);
3838          value = ast2obj_expr(state, o->v.Assign.value);
3839          if (!value) goto failed;
3840          if (PyObject_SetAttr(result, state->value, value) == -1)
3841              goto failed;
3842          Py_DECREF(value);
3843          value = ast2obj_string(state, o->v.Assign.type_comment);
3844          if (!value) goto failed;
3845          if (PyObject_SetAttr(result, state->type_comment, value) == -1)
3846              goto failed;
3847          Py_DECREF(value);
3848          break;
3849      case AugAssign_kind:
3850          tp = (PyTypeObject *)state->AugAssign_type;
3851          result = PyType_GenericNew(tp, NULL, NULL);
3852          if (!result) goto failed;
3853          value = ast2obj_expr(state, o->v.AugAssign.target);
3854          if (!value) goto failed;
3855          if (PyObject_SetAttr(result, state->target, value) == -1)
3856              goto failed;
3857          Py_DECREF(value);
3858          value = ast2obj_operator(state, o->v.AugAssign.op);
3859          if (!value) goto failed;
3860          if (PyObject_SetAttr(result, state->op, value) == -1)
3861              goto failed;
3862          Py_DECREF(value);
3863          value = ast2obj_expr(state, o->v.AugAssign.value);
3864          if (!value) goto failed;
3865          if (PyObject_SetAttr(result, state->value, value) == -1)
3866              goto failed;
3867          Py_DECREF(value);
3868          break;
3869      case AnnAssign_kind:
3870          tp = (PyTypeObject *)state->AnnAssign_type;
3871          result = PyType_GenericNew(tp, NULL, NULL);
3872          if (!result) goto failed;
3873          value = ast2obj_expr(state, o->v.AnnAssign.target);
3874          if (!value) goto failed;
3875          if (PyObject_SetAttr(result, state->target, value) == -1)
3876              goto failed;
3877          Py_DECREF(value);
3878          value = ast2obj_expr(state, o->v.AnnAssign.annotation);
3879          if (!value) goto failed;
3880          if (PyObject_SetAttr(result, state->annotation, value) == -1)
3881              goto failed;
3882          Py_DECREF(value);
3883          value = ast2obj_expr(state, o->v.AnnAssign.value);
3884          if (!value) goto failed;
3885          if (PyObject_SetAttr(result, state->value, value) == -1)
3886              goto failed;
3887          Py_DECREF(value);
3888          value = ast2obj_int(state, o->v.AnnAssign.simple);
3889          if (!value) goto failed;
3890          if (PyObject_SetAttr(result, state->simple, value) == -1)
3891              goto failed;
3892          Py_DECREF(value);
3893          break;
3894      case For_kind:
3895          tp = (PyTypeObject *)state->For_type;
3896          result = PyType_GenericNew(tp, NULL, NULL);
3897          if (!result) goto failed;
3898          value = ast2obj_expr(state, o->v.For.target);
3899          if (!value) goto failed;
3900          if (PyObject_SetAttr(result, state->target, value) == -1)
3901              goto failed;
3902          Py_DECREF(value);
3903          value = ast2obj_expr(state, o->v.For.iter);
3904          if (!value) goto failed;
3905          if (PyObject_SetAttr(result, state->iter, value) == -1)
3906              goto failed;
3907          Py_DECREF(value);
3908          value = ast2obj_list(state, (asdl_seq*)o->v.For.body, ast2obj_stmt);
3909          if (!value) goto failed;
3910          if (PyObject_SetAttr(result, state->body, value) == -1)
3911              goto failed;
3912          Py_DECREF(value);
3913          value = ast2obj_list(state, (asdl_seq*)o->v.For.orelse, ast2obj_stmt);
3914          if (!value) goto failed;
3915          if (PyObject_SetAttr(result, state->orelse, value) == -1)
3916              goto failed;
3917          Py_DECREF(value);
3918          value = ast2obj_string(state, o->v.For.type_comment);
3919          if (!value) goto failed;
3920          if (PyObject_SetAttr(result, state->type_comment, value) == -1)
3921              goto failed;
3922          Py_DECREF(value);
3923          break;
3924      case AsyncFor_kind:
3925          tp = (PyTypeObject *)state->AsyncFor_type;
3926          result = PyType_GenericNew(tp, NULL, NULL);
3927          if (!result) goto failed;
3928          value = ast2obj_expr(state, o->v.AsyncFor.target);
3929          if (!value) goto failed;
3930          if (PyObject_SetAttr(result, state->target, value) == -1)
3931              goto failed;
3932          Py_DECREF(value);
3933          value = ast2obj_expr(state, o->v.AsyncFor.iter);
3934          if (!value) goto failed;
3935          if (PyObject_SetAttr(result, state->iter, value) == -1)
3936              goto failed;
3937          Py_DECREF(value);
3938          value = ast2obj_list(state, (asdl_seq*)o->v.AsyncFor.body,
3939                               ast2obj_stmt);
3940          if (!value) goto failed;
3941          if (PyObject_SetAttr(result, state->body, value) == -1)
3942              goto failed;
3943          Py_DECREF(value);
3944          value = ast2obj_list(state, (asdl_seq*)o->v.AsyncFor.orelse,
3945                               ast2obj_stmt);
3946          if (!value) goto failed;
3947          if (PyObject_SetAttr(result, state->orelse, value) == -1)
3948              goto failed;
3949          Py_DECREF(value);
3950          value = ast2obj_string(state, o->v.AsyncFor.type_comment);
3951          if (!value) goto failed;
3952          if (PyObject_SetAttr(result, state->type_comment, value) == -1)
3953              goto failed;
3954          Py_DECREF(value);
3955          break;
3956      case While_kind:
3957          tp = (PyTypeObject *)state->While_type;
3958          result = PyType_GenericNew(tp, NULL, NULL);
3959          if (!result) goto failed;
3960          value = ast2obj_expr(state, o->v.While.test);
3961          if (!value) goto failed;
3962          if (PyObject_SetAttr(result, state->test, value) == -1)
3963              goto failed;
3964          Py_DECREF(value);
3965          value = ast2obj_list(state, (asdl_seq*)o->v.While.body, ast2obj_stmt);
3966          if (!value) goto failed;
3967          if (PyObject_SetAttr(result, state->body, value) == -1)
3968              goto failed;
3969          Py_DECREF(value);
3970          value = ast2obj_list(state, (asdl_seq*)o->v.While.orelse, ast2obj_stmt);
3971          if (!value) goto failed;
3972          if (PyObject_SetAttr(result, state->orelse, value) == -1)
3973              goto failed;
3974          Py_DECREF(value);
3975          break;
3976      case If_kind:
3977          tp = (PyTypeObject *)state->If_type;
3978          result = PyType_GenericNew(tp, NULL, NULL);
3979          if (!result) goto failed;
3980          value = ast2obj_expr(state, o->v.If.test);
3981          if (!value) goto failed;
3982          if (PyObject_SetAttr(result, state->test, value) == -1)
3983              goto failed;
3984          Py_DECREF(value);
3985          value = ast2obj_list(state, (asdl_seq*)o->v.If.body, ast2obj_stmt);
3986          if (!value) goto failed;
3987          if (PyObject_SetAttr(result, state->body, value) == -1)
3988              goto failed;
3989          Py_DECREF(value);
3990          value = ast2obj_list(state, (asdl_seq*)o->v.If.orelse, ast2obj_stmt);
3991          if (!value) goto failed;
3992          if (PyObject_SetAttr(result, state->orelse, value) == -1)
3993              goto failed;
3994          Py_DECREF(value);
3995          break;
3996      case With_kind:
3997          tp = (PyTypeObject *)state->With_type;
3998          result = PyType_GenericNew(tp, NULL, NULL);
3999          if (!result) goto failed;
4000          value = ast2obj_list(state, (asdl_seq*)o->v.With.items,
4001                               ast2obj_withitem);
4002          if (!value) goto failed;
4003          if (PyObject_SetAttr(result, state->items, value) == -1)
4004              goto failed;
4005          Py_DECREF(value);
4006          value = ast2obj_list(state, (asdl_seq*)o->v.With.body, ast2obj_stmt);
4007          if (!value) goto failed;
4008          if (PyObject_SetAttr(result, state->body, value) == -1)
4009              goto failed;
4010          Py_DECREF(value);
4011          value = ast2obj_string(state, o->v.With.type_comment);
4012          if (!value) goto failed;
4013          if (PyObject_SetAttr(result, state->type_comment, value) == -1)
4014              goto failed;
4015          Py_DECREF(value);
4016          break;
4017      case AsyncWith_kind:
4018          tp = (PyTypeObject *)state->AsyncWith_type;
4019          result = PyType_GenericNew(tp, NULL, NULL);
4020          if (!result) goto failed;
4021          value = ast2obj_list(state, (asdl_seq*)o->v.AsyncWith.items,
4022                               ast2obj_withitem);
4023          if (!value) goto failed;
4024          if (PyObject_SetAttr(result, state->items, value) == -1)
4025              goto failed;
4026          Py_DECREF(value);
4027          value = ast2obj_list(state, (asdl_seq*)o->v.AsyncWith.body,
4028                               ast2obj_stmt);
4029          if (!value) goto failed;
4030          if (PyObject_SetAttr(result, state->body, value) == -1)
4031              goto failed;
4032          Py_DECREF(value);
4033          value = ast2obj_string(state, o->v.AsyncWith.type_comment);
4034          if (!value) goto failed;
4035          if (PyObject_SetAttr(result, state->type_comment, value) == -1)
4036              goto failed;
4037          Py_DECREF(value);
4038          break;
4039      case Match_kind:
4040          tp = (PyTypeObject *)state->Match_type;
4041          result = PyType_GenericNew(tp, NULL, NULL);
4042          if (!result) goto failed;
4043          value = ast2obj_expr(state, o->v.Match.subject);
4044          if (!value) goto failed;
4045          if (PyObject_SetAttr(result, state->subject, value) == -1)
4046              goto failed;
4047          Py_DECREF(value);
4048          value = ast2obj_list(state, (asdl_seq*)o->v.Match.cases,
4049                               ast2obj_match_case);
4050          if (!value) goto failed;
4051          if (PyObject_SetAttr(result, state->cases, value) == -1)
4052              goto failed;
4053          Py_DECREF(value);
4054          break;
4055      case Raise_kind:
4056          tp = (PyTypeObject *)state->Raise_type;
4057          result = PyType_GenericNew(tp, NULL, NULL);
4058          if (!result) goto failed;
4059          value = ast2obj_expr(state, o->v.Raise.exc);
4060          if (!value) goto failed;
4061          if (PyObject_SetAttr(result, state->exc, value) == -1)
4062              goto failed;
4063          Py_DECREF(value);
4064          value = ast2obj_expr(state, o->v.Raise.cause);
4065          if (!value) goto failed;
4066          if (PyObject_SetAttr(result, state->cause, value) == -1)
4067              goto failed;
4068          Py_DECREF(value);
4069          break;
4070      case Try_kind:
4071          tp = (PyTypeObject *)state->Try_type;
4072          result = PyType_GenericNew(tp, NULL, NULL);
4073          if (!result) goto failed;
4074          value = ast2obj_list(state, (asdl_seq*)o->v.Try.body, ast2obj_stmt);
4075          if (!value) goto failed;
4076          if (PyObject_SetAttr(result, state->body, value) == -1)
4077              goto failed;
4078          Py_DECREF(value);
4079          value = ast2obj_list(state, (asdl_seq*)o->v.Try.handlers,
4080                               ast2obj_excepthandler);
4081          if (!value) goto failed;
4082          if (PyObject_SetAttr(result, state->handlers, value) == -1)
4083              goto failed;
4084          Py_DECREF(value);
4085          value = ast2obj_list(state, (asdl_seq*)o->v.Try.orelse, ast2obj_stmt);
4086          if (!value) goto failed;
4087          if (PyObject_SetAttr(result, state->orelse, value) == -1)
4088              goto failed;
4089          Py_DECREF(value);
4090          value = ast2obj_list(state, (asdl_seq*)o->v.Try.finalbody,
4091                               ast2obj_stmt);
4092          if (!value) goto failed;
4093          if (PyObject_SetAttr(result, state->finalbody, value) == -1)
4094              goto failed;
4095          Py_DECREF(value);
4096          break;
4097      case TryStar_kind:
4098          tp = (PyTypeObject *)state->TryStar_type;
4099          result = PyType_GenericNew(tp, NULL, NULL);
4100          if (!result) goto failed;
4101          value = ast2obj_list(state, (asdl_seq*)o->v.TryStar.body, ast2obj_stmt);
4102          if (!value) goto failed;
4103          if (PyObject_SetAttr(result, state->body, value) == -1)
4104              goto failed;
4105          Py_DECREF(value);
4106          value = ast2obj_list(state, (asdl_seq*)o->v.TryStar.handlers,
4107                               ast2obj_excepthandler);
4108          if (!value) goto failed;
4109          if (PyObject_SetAttr(result, state->handlers, value) == -1)
4110              goto failed;
4111          Py_DECREF(value);
4112          value = ast2obj_list(state, (asdl_seq*)o->v.TryStar.orelse,
4113                               ast2obj_stmt);
4114          if (!value) goto failed;
4115          if (PyObject_SetAttr(result, state->orelse, value) == -1)
4116              goto failed;
4117          Py_DECREF(value);
4118          value = ast2obj_list(state, (asdl_seq*)o->v.TryStar.finalbody,
4119                               ast2obj_stmt);
4120          if (!value) goto failed;
4121          if (PyObject_SetAttr(result, state->finalbody, value) == -1)
4122              goto failed;
4123          Py_DECREF(value);
4124          break;
4125      case Assert_kind:
4126          tp = (PyTypeObject *)state->Assert_type;
4127          result = PyType_GenericNew(tp, NULL, NULL);
4128          if (!result) goto failed;
4129          value = ast2obj_expr(state, o->v.Assert.test);
4130          if (!value) goto failed;
4131          if (PyObject_SetAttr(result, state->test, value) == -1)
4132              goto failed;
4133          Py_DECREF(value);
4134          value = ast2obj_expr(state, o->v.Assert.msg);
4135          if (!value) goto failed;
4136          if (PyObject_SetAttr(result, state->msg, value) == -1)
4137              goto failed;
4138          Py_DECREF(value);
4139          break;
4140      case Import_kind:
4141          tp = (PyTypeObject *)state->Import_type;
4142          result = PyType_GenericNew(tp, NULL, NULL);
4143          if (!result) goto failed;
4144          value = ast2obj_list(state, (asdl_seq*)o->v.Import.names,
4145                               ast2obj_alias);
4146          if (!value) goto failed;
4147          if (PyObject_SetAttr(result, state->names, value) == -1)
4148              goto failed;
4149          Py_DECREF(value);
4150          break;
4151      case ImportFrom_kind:
4152          tp = (PyTypeObject *)state->ImportFrom_type;
4153          result = PyType_GenericNew(tp, NULL, NULL);
4154          if (!result) goto failed;
4155          value = ast2obj_identifier(state, o->v.ImportFrom.module);
4156          if (!value) goto failed;
4157          if (PyObject_SetAttr(result, state->module, value) == -1)
4158              goto failed;
4159          Py_DECREF(value);
4160          value = ast2obj_list(state, (asdl_seq*)o->v.ImportFrom.names,
4161                               ast2obj_alias);
4162          if (!value) goto failed;
4163          if (PyObject_SetAttr(result, state->names, value) == -1)
4164              goto failed;
4165          Py_DECREF(value);
4166          value = ast2obj_int(state, o->v.ImportFrom.level);
4167          if (!value) goto failed;
4168          if (PyObject_SetAttr(result, state->level, value) == -1)
4169              goto failed;
4170          Py_DECREF(value);
4171          break;
4172      case Global_kind:
4173          tp = (PyTypeObject *)state->Global_type;
4174          result = PyType_GenericNew(tp, NULL, NULL);
4175          if (!result) goto failed;
4176          value = ast2obj_list(state, (asdl_seq*)o->v.Global.names,
4177                               ast2obj_identifier);
4178          if (!value) goto failed;
4179          if (PyObject_SetAttr(result, state->names, value) == -1)
4180              goto failed;
4181          Py_DECREF(value);
4182          break;
4183      case Nonlocal_kind:
4184          tp = (PyTypeObject *)state->Nonlocal_type;
4185          result = PyType_GenericNew(tp, NULL, NULL);
4186          if (!result) goto failed;
4187          value = ast2obj_list(state, (asdl_seq*)o->v.Nonlocal.names,
4188                               ast2obj_identifier);
4189          if (!value) goto failed;
4190          if (PyObject_SetAttr(result, state->names, value) == -1)
4191              goto failed;
4192          Py_DECREF(value);
4193          break;
4194      case Expr_kind:
4195          tp = (PyTypeObject *)state->Expr_type;
4196          result = PyType_GenericNew(tp, NULL, NULL);
4197          if (!result) goto failed;
4198          value = ast2obj_expr(state, o->v.Expr.value);
4199          if (!value) goto failed;
4200          if (PyObject_SetAttr(result, state->value, value) == -1)
4201              goto failed;
4202          Py_DECREF(value);
4203          break;
4204      case Pass_kind:
4205          tp = (PyTypeObject *)state->Pass_type;
4206          result = PyType_GenericNew(tp, NULL, NULL);
4207          if (!result) goto failed;
4208          break;
4209      case Break_kind:
4210          tp = (PyTypeObject *)state->Break_type;
4211          result = PyType_GenericNew(tp, NULL, NULL);
4212          if (!result) goto failed;
4213          break;
4214      case Continue_kind:
4215          tp = (PyTypeObject *)state->Continue_type;
4216          result = PyType_GenericNew(tp, NULL, NULL);
4217          if (!result) goto failed;
4218          break;
4219      }
4220      value = ast2obj_int(state, o->lineno);
4221      if (!value) goto failed;
4222      if (PyObject_SetAttr(result, state->lineno, value) < 0)
4223          goto failed;
4224      Py_DECREF(value);
4225      value = ast2obj_int(state, o->col_offset);
4226      if (!value) goto failed;
4227      if (PyObject_SetAttr(result, state->col_offset, value) < 0)
4228          goto failed;
4229      Py_DECREF(value);
4230      value = ast2obj_int(state, o->end_lineno);
4231      if (!value) goto failed;
4232      if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
4233          goto failed;
4234      Py_DECREF(value);
4235      value = ast2obj_int(state, o->end_col_offset);
4236      if (!value) goto failed;
4237      if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
4238          goto failed;
4239      Py_DECREF(value);
4240      state->recursion_depth--;
4241      return result;
4242  failed:
4243      Py_XDECREF(value);
4244      Py_XDECREF(result);
4245      return NULL;
4246  }
4247  
4248  PyObject*
ast2obj_expr(struct ast_state * state,void * _o)4249  ast2obj_expr(struct ast_state *state, void* _o)
4250  {
4251      expr_ty o = (expr_ty)_o;
4252      PyObject *result = NULL, *value = NULL;
4253      PyTypeObject *tp;
4254      if (!o) {
4255          Py_RETURN_NONE;
4256      }
4257      if (++state->recursion_depth > state->recursion_limit) {
4258          PyErr_SetString(PyExc_RecursionError,
4259              "maximum recursion depth exceeded during ast construction");
4260          return 0;
4261      }
4262      switch (o->kind) {
4263      case BoolOp_kind:
4264          tp = (PyTypeObject *)state->BoolOp_type;
4265          result = PyType_GenericNew(tp, NULL, NULL);
4266          if (!result) goto failed;
4267          value = ast2obj_boolop(state, o->v.BoolOp.op);
4268          if (!value) goto failed;
4269          if (PyObject_SetAttr(result, state->op, value) == -1)
4270              goto failed;
4271          Py_DECREF(value);
4272          value = ast2obj_list(state, (asdl_seq*)o->v.BoolOp.values,
4273                               ast2obj_expr);
4274          if (!value) goto failed;
4275          if (PyObject_SetAttr(result, state->values, value) == -1)
4276              goto failed;
4277          Py_DECREF(value);
4278          break;
4279      case NamedExpr_kind:
4280          tp = (PyTypeObject *)state->NamedExpr_type;
4281          result = PyType_GenericNew(tp, NULL, NULL);
4282          if (!result) goto failed;
4283          value = ast2obj_expr(state, o->v.NamedExpr.target);
4284          if (!value) goto failed;
4285          if (PyObject_SetAttr(result, state->target, value) == -1)
4286              goto failed;
4287          Py_DECREF(value);
4288          value = ast2obj_expr(state, o->v.NamedExpr.value);
4289          if (!value) goto failed;
4290          if (PyObject_SetAttr(result, state->value, value) == -1)
4291              goto failed;
4292          Py_DECREF(value);
4293          break;
4294      case BinOp_kind:
4295          tp = (PyTypeObject *)state->BinOp_type;
4296          result = PyType_GenericNew(tp, NULL, NULL);
4297          if (!result) goto failed;
4298          value = ast2obj_expr(state, o->v.BinOp.left);
4299          if (!value) goto failed;
4300          if (PyObject_SetAttr(result, state->left, value) == -1)
4301              goto failed;
4302          Py_DECREF(value);
4303          value = ast2obj_operator(state, o->v.BinOp.op);
4304          if (!value) goto failed;
4305          if (PyObject_SetAttr(result, state->op, value) == -1)
4306              goto failed;
4307          Py_DECREF(value);
4308          value = ast2obj_expr(state, o->v.BinOp.right);
4309          if (!value) goto failed;
4310          if (PyObject_SetAttr(result, state->right, value) == -1)
4311              goto failed;
4312          Py_DECREF(value);
4313          break;
4314      case UnaryOp_kind:
4315          tp = (PyTypeObject *)state->UnaryOp_type;
4316          result = PyType_GenericNew(tp, NULL, NULL);
4317          if (!result) goto failed;
4318          value = ast2obj_unaryop(state, o->v.UnaryOp.op);
4319          if (!value) goto failed;
4320          if (PyObject_SetAttr(result, state->op, value) == -1)
4321              goto failed;
4322          Py_DECREF(value);
4323          value = ast2obj_expr(state, o->v.UnaryOp.operand);
4324          if (!value) goto failed;
4325          if (PyObject_SetAttr(result, state->operand, value) == -1)
4326              goto failed;
4327          Py_DECREF(value);
4328          break;
4329      case Lambda_kind:
4330          tp = (PyTypeObject *)state->Lambda_type;
4331          result = PyType_GenericNew(tp, NULL, NULL);
4332          if (!result) goto failed;
4333          value = ast2obj_arguments(state, o->v.Lambda.args);
4334          if (!value) goto failed;
4335          if (PyObject_SetAttr(result, state->args, value) == -1)
4336              goto failed;
4337          Py_DECREF(value);
4338          value = ast2obj_expr(state, o->v.Lambda.body);
4339          if (!value) goto failed;
4340          if (PyObject_SetAttr(result, state->body, value) == -1)
4341              goto failed;
4342          Py_DECREF(value);
4343          break;
4344      case IfExp_kind:
4345          tp = (PyTypeObject *)state->IfExp_type;
4346          result = PyType_GenericNew(tp, NULL, NULL);
4347          if (!result) goto failed;
4348          value = ast2obj_expr(state, o->v.IfExp.test);
4349          if (!value) goto failed;
4350          if (PyObject_SetAttr(result, state->test, value) == -1)
4351              goto failed;
4352          Py_DECREF(value);
4353          value = ast2obj_expr(state, o->v.IfExp.body);
4354          if (!value) goto failed;
4355          if (PyObject_SetAttr(result, state->body, value) == -1)
4356              goto failed;
4357          Py_DECREF(value);
4358          value = ast2obj_expr(state, o->v.IfExp.orelse);
4359          if (!value) goto failed;
4360          if (PyObject_SetAttr(result, state->orelse, value) == -1)
4361              goto failed;
4362          Py_DECREF(value);
4363          break;
4364      case Dict_kind:
4365          tp = (PyTypeObject *)state->Dict_type;
4366          result = PyType_GenericNew(tp, NULL, NULL);
4367          if (!result) goto failed;
4368          value = ast2obj_list(state, (asdl_seq*)o->v.Dict.keys, ast2obj_expr);
4369          if (!value) goto failed;
4370          if (PyObject_SetAttr(result, state->keys, value) == -1)
4371              goto failed;
4372          Py_DECREF(value);
4373          value = ast2obj_list(state, (asdl_seq*)o->v.Dict.values, ast2obj_expr);
4374          if (!value) goto failed;
4375          if (PyObject_SetAttr(result, state->values, value) == -1)
4376              goto failed;
4377          Py_DECREF(value);
4378          break;
4379      case Set_kind:
4380          tp = (PyTypeObject *)state->Set_type;
4381          result = PyType_GenericNew(tp, NULL, NULL);
4382          if (!result) goto failed;
4383          value = ast2obj_list(state, (asdl_seq*)o->v.Set.elts, ast2obj_expr);
4384          if (!value) goto failed;
4385          if (PyObject_SetAttr(result, state->elts, value) == -1)
4386              goto failed;
4387          Py_DECREF(value);
4388          break;
4389      case ListComp_kind:
4390          tp = (PyTypeObject *)state->ListComp_type;
4391          result = PyType_GenericNew(tp, NULL, NULL);
4392          if (!result) goto failed;
4393          value = ast2obj_expr(state, o->v.ListComp.elt);
4394          if (!value) goto failed;
4395          if (PyObject_SetAttr(result, state->elt, value) == -1)
4396              goto failed;
4397          Py_DECREF(value);
4398          value = ast2obj_list(state, (asdl_seq*)o->v.ListComp.generators,
4399                               ast2obj_comprehension);
4400          if (!value) goto failed;
4401          if (PyObject_SetAttr(result, state->generators, value) == -1)
4402              goto failed;
4403          Py_DECREF(value);
4404          break;
4405      case SetComp_kind:
4406          tp = (PyTypeObject *)state->SetComp_type;
4407          result = PyType_GenericNew(tp, NULL, NULL);
4408          if (!result) goto failed;
4409          value = ast2obj_expr(state, o->v.SetComp.elt);
4410          if (!value) goto failed;
4411          if (PyObject_SetAttr(result, state->elt, value) == -1)
4412              goto failed;
4413          Py_DECREF(value);
4414          value = ast2obj_list(state, (asdl_seq*)o->v.SetComp.generators,
4415                               ast2obj_comprehension);
4416          if (!value) goto failed;
4417          if (PyObject_SetAttr(result, state->generators, value) == -1)
4418              goto failed;
4419          Py_DECREF(value);
4420          break;
4421      case DictComp_kind:
4422          tp = (PyTypeObject *)state->DictComp_type;
4423          result = PyType_GenericNew(tp, NULL, NULL);
4424          if (!result) goto failed;
4425          value = ast2obj_expr(state, o->v.DictComp.key);
4426          if (!value) goto failed;
4427          if (PyObject_SetAttr(result, state->key, value) == -1)
4428              goto failed;
4429          Py_DECREF(value);
4430          value = ast2obj_expr(state, o->v.DictComp.value);
4431          if (!value) goto failed;
4432          if (PyObject_SetAttr(result, state->value, value) == -1)
4433              goto failed;
4434          Py_DECREF(value);
4435          value = ast2obj_list(state, (asdl_seq*)o->v.DictComp.generators,
4436                               ast2obj_comprehension);
4437          if (!value) goto failed;
4438          if (PyObject_SetAttr(result, state->generators, value) == -1)
4439              goto failed;
4440          Py_DECREF(value);
4441          break;
4442      case GeneratorExp_kind:
4443          tp = (PyTypeObject *)state->GeneratorExp_type;
4444          result = PyType_GenericNew(tp, NULL, NULL);
4445          if (!result) goto failed;
4446          value = ast2obj_expr(state, o->v.GeneratorExp.elt);
4447          if (!value) goto failed;
4448          if (PyObject_SetAttr(result, state->elt, value) == -1)
4449              goto failed;
4450          Py_DECREF(value);
4451          value = ast2obj_list(state, (asdl_seq*)o->v.GeneratorExp.generators,
4452                               ast2obj_comprehension);
4453          if (!value) goto failed;
4454          if (PyObject_SetAttr(result, state->generators, value) == -1)
4455              goto failed;
4456          Py_DECREF(value);
4457          break;
4458      case Await_kind:
4459          tp = (PyTypeObject *)state->Await_type;
4460          result = PyType_GenericNew(tp, NULL, NULL);
4461          if (!result) goto failed;
4462          value = ast2obj_expr(state, o->v.Await.value);
4463          if (!value) goto failed;
4464          if (PyObject_SetAttr(result, state->value, value) == -1)
4465              goto failed;
4466          Py_DECREF(value);
4467          break;
4468      case Yield_kind:
4469          tp = (PyTypeObject *)state->Yield_type;
4470          result = PyType_GenericNew(tp, NULL, NULL);
4471          if (!result) goto failed;
4472          value = ast2obj_expr(state, o->v.Yield.value);
4473          if (!value) goto failed;
4474          if (PyObject_SetAttr(result, state->value, value) == -1)
4475              goto failed;
4476          Py_DECREF(value);
4477          break;
4478      case YieldFrom_kind:
4479          tp = (PyTypeObject *)state->YieldFrom_type;
4480          result = PyType_GenericNew(tp, NULL, NULL);
4481          if (!result) goto failed;
4482          value = ast2obj_expr(state, o->v.YieldFrom.value);
4483          if (!value) goto failed;
4484          if (PyObject_SetAttr(result, state->value, value) == -1)
4485              goto failed;
4486          Py_DECREF(value);
4487          break;
4488      case Compare_kind:
4489          tp = (PyTypeObject *)state->Compare_type;
4490          result = PyType_GenericNew(tp, NULL, NULL);
4491          if (!result) goto failed;
4492          value = ast2obj_expr(state, o->v.Compare.left);
4493          if (!value) goto failed;
4494          if (PyObject_SetAttr(result, state->left, value) == -1)
4495              goto failed;
4496          Py_DECREF(value);
4497          {
4498              Py_ssize_t i, n = asdl_seq_LEN(o->v.Compare.ops);
4499              value = PyList_New(n);
4500              if (!value) goto failed;
4501              for(i = 0; i < n; i++)
4502                  PyList_SET_ITEM(value, i, ast2obj_cmpop(state, (cmpop_ty)asdl_seq_GET(o->v.Compare.ops, i)));
4503          }
4504          if (!value) goto failed;
4505          if (PyObject_SetAttr(result, state->ops, value) == -1)
4506              goto failed;
4507          Py_DECREF(value);
4508          value = ast2obj_list(state, (asdl_seq*)o->v.Compare.comparators,
4509                               ast2obj_expr);
4510          if (!value) goto failed;
4511          if (PyObject_SetAttr(result, state->comparators, value) == -1)
4512              goto failed;
4513          Py_DECREF(value);
4514          break;
4515      case Call_kind:
4516          tp = (PyTypeObject *)state->Call_type;
4517          result = PyType_GenericNew(tp, NULL, NULL);
4518          if (!result) goto failed;
4519          value = ast2obj_expr(state, o->v.Call.func);
4520          if (!value) goto failed;
4521          if (PyObject_SetAttr(result, state->func, value) == -1)
4522              goto failed;
4523          Py_DECREF(value);
4524          value = ast2obj_list(state, (asdl_seq*)o->v.Call.args, ast2obj_expr);
4525          if (!value) goto failed;
4526          if (PyObject_SetAttr(result, state->args, value) == -1)
4527              goto failed;
4528          Py_DECREF(value);
4529          value = ast2obj_list(state, (asdl_seq*)o->v.Call.keywords,
4530                               ast2obj_keyword);
4531          if (!value) goto failed;
4532          if (PyObject_SetAttr(result, state->keywords, value) == -1)
4533              goto failed;
4534          Py_DECREF(value);
4535          break;
4536      case FormattedValue_kind:
4537          tp = (PyTypeObject *)state->FormattedValue_type;
4538          result = PyType_GenericNew(tp, NULL, NULL);
4539          if (!result) goto failed;
4540          value = ast2obj_expr(state, o->v.FormattedValue.value);
4541          if (!value) goto failed;
4542          if (PyObject_SetAttr(result, state->value, value) == -1)
4543              goto failed;
4544          Py_DECREF(value);
4545          value = ast2obj_int(state, o->v.FormattedValue.conversion);
4546          if (!value) goto failed;
4547          if (PyObject_SetAttr(result, state->conversion, value) == -1)
4548              goto failed;
4549          Py_DECREF(value);
4550          value = ast2obj_expr(state, o->v.FormattedValue.format_spec);
4551          if (!value) goto failed;
4552          if (PyObject_SetAttr(result, state->format_spec, value) == -1)
4553              goto failed;
4554          Py_DECREF(value);
4555          break;
4556      case JoinedStr_kind:
4557          tp = (PyTypeObject *)state->JoinedStr_type;
4558          result = PyType_GenericNew(tp, NULL, NULL);
4559          if (!result) goto failed;
4560          value = ast2obj_list(state, (asdl_seq*)o->v.JoinedStr.values,
4561                               ast2obj_expr);
4562          if (!value) goto failed;
4563          if (PyObject_SetAttr(result, state->values, value) == -1)
4564              goto failed;
4565          Py_DECREF(value);
4566          break;
4567      case Constant_kind:
4568          tp = (PyTypeObject *)state->Constant_type;
4569          result = PyType_GenericNew(tp, NULL, NULL);
4570          if (!result) goto failed;
4571          value = ast2obj_constant(state, o->v.Constant.value);
4572          if (!value) goto failed;
4573          if (PyObject_SetAttr(result, state->value, value) == -1)
4574              goto failed;
4575          Py_DECREF(value);
4576          value = ast2obj_string(state, o->v.Constant.kind);
4577          if (!value) goto failed;
4578          if (PyObject_SetAttr(result, state->kind, value) == -1)
4579              goto failed;
4580          Py_DECREF(value);
4581          break;
4582      case Attribute_kind:
4583          tp = (PyTypeObject *)state->Attribute_type;
4584          result = PyType_GenericNew(tp, NULL, NULL);
4585          if (!result) goto failed;
4586          value = ast2obj_expr(state, o->v.Attribute.value);
4587          if (!value) goto failed;
4588          if (PyObject_SetAttr(result, state->value, value) == -1)
4589              goto failed;
4590          Py_DECREF(value);
4591          value = ast2obj_identifier(state, o->v.Attribute.attr);
4592          if (!value) goto failed;
4593          if (PyObject_SetAttr(result, state->attr, value) == -1)
4594              goto failed;
4595          Py_DECREF(value);
4596          value = ast2obj_expr_context(state, o->v.Attribute.ctx);
4597          if (!value) goto failed;
4598          if (PyObject_SetAttr(result, state->ctx, value) == -1)
4599              goto failed;
4600          Py_DECREF(value);
4601          break;
4602      case Subscript_kind:
4603          tp = (PyTypeObject *)state->Subscript_type;
4604          result = PyType_GenericNew(tp, NULL, NULL);
4605          if (!result) goto failed;
4606          value = ast2obj_expr(state, o->v.Subscript.value);
4607          if (!value) goto failed;
4608          if (PyObject_SetAttr(result, state->value, value) == -1)
4609              goto failed;
4610          Py_DECREF(value);
4611          value = ast2obj_expr(state, o->v.Subscript.slice);
4612          if (!value) goto failed;
4613          if (PyObject_SetAttr(result, state->slice, value) == -1)
4614              goto failed;
4615          Py_DECREF(value);
4616          value = ast2obj_expr_context(state, o->v.Subscript.ctx);
4617          if (!value) goto failed;
4618          if (PyObject_SetAttr(result, state->ctx, value) == -1)
4619              goto failed;
4620          Py_DECREF(value);
4621          break;
4622      case Starred_kind:
4623          tp = (PyTypeObject *)state->Starred_type;
4624          result = PyType_GenericNew(tp, NULL, NULL);
4625          if (!result) goto failed;
4626          value = ast2obj_expr(state, o->v.Starred.value);
4627          if (!value) goto failed;
4628          if (PyObject_SetAttr(result, state->value, value) == -1)
4629              goto failed;
4630          Py_DECREF(value);
4631          value = ast2obj_expr_context(state, o->v.Starred.ctx);
4632          if (!value) goto failed;
4633          if (PyObject_SetAttr(result, state->ctx, value) == -1)
4634              goto failed;
4635          Py_DECREF(value);
4636          break;
4637      case Name_kind:
4638          tp = (PyTypeObject *)state->Name_type;
4639          result = PyType_GenericNew(tp, NULL, NULL);
4640          if (!result) goto failed;
4641          value = ast2obj_identifier(state, o->v.Name.id);
4642          if (!value) goto failed;
4643          if (PyObject_SetAttr(result, state->id, value) == -1)
4644              goto failed;
4645          Py_DECREF(value);
4646          value = ast2obj_expr_context(state, o->v.Name.ctx);
4647          if (!value) goto failed;
4648          if (PyObject_SetAttr(result, state->ctx, value) == -1)
4649              goto failed;
4650          Py_DECREF(value);
4651          break;
4652      case List_kind:
4653          tp = (PyTypeObject *)state->List_type;
4654          result = PyType_GenericNew(tp, NULL, NULL);
4655          if (!result) goto failed;
4656          value = ast2obj_list(state, (asdl_seq*)o->v.List.elts, ast2obj_expr);
4657          if (!value) goto failed;
4658          if (PyObject_SetAttr(result, state->elts, value) == -1)
4659              goto failed;
4660          Py_DECREF(value);
4661          value = ast2obj_expr_context(state, o->v.List.ctx);
4662          if (!value) goto failed;
4663          if (PyObject_SetAttr(result, state->ctx, value) == -1)
4664              goto failed;
4665          Py_DECREF(value);
4666          break;
4667      case Tuple_kind:
4668          tp = (PyTypeObject *)state->Tuple_type;
4669          result = PyType_GenericNew(tp, NULL, NULL);
4670          if (!result) goto failed;
4671          value = ast2obj_list(state, (asdl_seq*)o->v.Tuple.elts, ast2obj_expr);
4672          if (!value) goto failed;
4673          if (PyObject_SetAttr(result, state->elts, value) == -1)
4674              goto failed;
4675          Py_DECREF(value);
4676          value = ast2obj_expr_context(state, o->v.Tuple.ctx);
4677          if (!value) goto failed;
4678          if (PyObject_SetAttr(result, state->ctx, value) == -1)
4679              goto failed;
4680          Py_DECREF(value);
4681          break;
4682      case Slice_kind:
4683          tp = (PyTypeObject *)state->Slice_type;
4684          result = PyType_GenericNew(tp, NULL, NULL);
4685          if (!result) goto failed;
4686          value = ast2obj_expr(state, o->v.Slice.lower);
4687          if (!value) goto failed;
4688          if (PyObject_SetAttr(result, state->lower, value) == -1)
4689              goto failed;
4690          Py_DECREF(value);
4691          value = ast2obj_expr(state, o->v.Slice.upper);
4692          if (!value) goto failed;
4693          if (PyObject_SetAttr(result, state->upper, value) == -1)
4694              goto failed;
4695          Py_DECREF(value);
4696          value = ast2obj_expr(state, o->v.Slice.step);
4697          if (!value) goto failed;
4698          if (PyObject_SetAttr(result, state->step, value) == -1)
4699              goto failed;
4700          Py_DECREF(value);
4701          break;
4702      }
4703      value = ast2obj_int(state, o->lineno);
4704      if (!value) goto failed;
4705      if (PyObject_SetAttr(result, state->lineno, value) < 0)
4706          goto failed;
4707      Py_DECREF(value);
4708      value = ast2obj_int(state, o->col_offset);
4709      if (!value) goto failed;
4710      if (PyObject_SetAttr(result, state->col_offset, value) < 0)
4711          goto failed;
4712      Py_DECREF(value);
4713      value = ast2obj_int(state, o->end_lineno);
4714      if (!value) goto failed;
4715      if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
4716          goto failed;
4717      Py_DECREF(value);
4718      value = ast2obj_int(state, o->end_col_offset);
4719      if (!value) goto failed;
4720      if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
4721          goto failed;
4722      Py_DECREF(value);
4723      state->recursion_depth--;
4724      return result;
4725  failed:
4726      Py_XDECREF(value);
4727      Py_XDECREF(result);
4728      return NULL;
4729  }
4730  
ast2obj_expr_context(struct ast_state * state,expr_context_ty o)4731  PyObject* ast2obj_expr_context(struct ast_state *state, expr_context_ty o)
4732  {
4733      switch(o) {
4734          case Load:
4735              Py_INCREF(state->Load_singleton);
4736              return state->Load_singleton;
4737          case Store:
4738              Py_INCREF(state->Store_singleton);
4739              return state->Store_singleton;
4740          case Del:
4741              Py_INCREF(state->Del_singleton);
4742              return state->Del_singleton;
4743      }
4744      Py_UNREACHABLE();
4745  }
ast2obj_boolop(struct ast_state * state,boolop_ty o)4746  PyObject* ast2obj_boolop(struct ast_state *state, boolop_ty o)
4747  {
4748      switch(o) {
4749          case And:
4750              Py_INCREF(state->And_singleton);
4751              return state->And_singleton;
4752          case Or:
4753              Py_INCREF(state->Or_singleton);
4754              return state->Or_singleton;
4755      }
4756      Py_UNREACHABLE();
4757  }
ast2obj_operator(struct ast_state * state,operator_ty o)4758  PyObject* ast2obj_operator(struct ast_state *state, operator_ty o)
4759  {
4760      switch(o) {
4761          case Add:
4762              Py_INCREF(state->Add_singleton);
4763              return state->Add_singleton;
4764          case Sub:
4765              Py_INCREF(state->Sub_singleton);
4766              return state->Sub_singleton;
4767          case Mult:
4768              Py_INCREF(state->Mult_singleton);
4769              return state->Mult_singleton;
4770          case MatMult:
4771              Py_INCREF(state->MatMult_singleton);
4772              return state->MatMult_singleton;
4773          case Div:
4774              Py_INCREF(state->Div_singleton);
4775              return state->Div_singleton;
4776          case Mod:
4777              Py_INCREF(state->Mod_singleton);
4778              return state->Mod_singleton;
4779          case Pow:
4780              Py_INCREF(state->Pow_singleton);
4781              return state->Pow_singleton;
4782          case LShift:
4783              Py_INCREF(state->LShift_singleton);
4784              return state->LShift_singleton;
4785          case RShift:
4786              Py_INCREF(state->RShift_singleton);
4787              return state->RShift_singleton;
4788          case BitOr:
4789              Py_INCREF(state->BitOr_singleton);
4790              return state->BitOr_singleton;
4791          case BitXor:
4792              Py_INCREF(state->BitXor_singleton);
4793              return state->BitXor_singleton;
4794          case BitAnd:
4795              Py_INCREF(state->BitAnd_singleton);
4796              return state->BitAnd_singleton;
4797          case FloorDiv:
4798              Py_INCREF(state->FloorDiv_singleton);
4799              return state->FloorDiv_singleton;
4800      }
4801      Py_UNREACHABLE();
4802  }
ast2obj_unaryop(struct ast_state * state,unaryop_ty o)4803  PyObject* ast2obj_unaryop(struct ast_state *state, unaryop_ty o)
4804  {
4805      switch(o) {
4806          case Invert:
4807              Py_INCREF(state->Invert_singleton);
4808              return state->Invert_singleton;
4809          case Not:
4810              Py_INCREF(state->Not_singleton);
4811              return state->Not_singleton;
4812          case UAdd:
4813              Py_INCREF(state->UAdd_singleton);
4814              return state->UAdd_singleton;
4815          case USub:
4816              Py_INCREF(state->USub_singleton);
4817              return state->USub_singleton;
4818      }
4819      Py_UNREACHABLE();
4820  }
ast2obj_cmpop(struct ast_state * state,cmpop_ty o)4821  PyObject* ast2obj_cmpop(struct ast_state *state, cmpop_ty o)
4822  {
4823      switch(o) {
4824          case Eq:
4825              Py_INCREF(state->Eq_singleton);
4826              return state->Eq_singleton;
4827          case NotEq:
4828              Py_INCREF(state->NotEq_singleton);
4829              return state->NotEq_singleton;
4830          case Lt:
4831              Py_INCREF(state->Lt_singleton);
4832              return state->Lt_singleton;
4833          case LtE:
4834              Py_INCREF(state->LtE_singleton);
4835              return state->LtE_singleton;
4836          case Gt:
4837              Py_INCREF(state->Gt_singleton);
4838              return state->Gt_singleton;
4839          case GtE:
4840              Py_INCREF(state->GtE_singleton);
4841              return state->GtE_singleton;
4842          case Is:
4843              Py_INCREF(state->Is_singleton);
4844              return state->Is_singleton;
4845          case IsNot:
4846              Py_INCREF(state->IsNot_singleton);
4847              return state->IsNot_singleton;
4848          case In:
4849              Py_INCREF(state->In_singleton);
4850              return state->In_singleton;
4851          case NotIn:
4852              Py_INCREF(state->NotIn_singleton);
4853              return state->NotIn_singleton;
4854      }
4855      Py_UNREACHABLE();
4856  }
4857  PyObject*
ast2obj_comprehension(struct ast_state * state,void * _o)4858  ast2obj_comprehension(struct ast_state *state, void* _o)
4859  {
4860      comprehension_ty o = (comprehension_ty)_o;
4861      PyObject *result = NULL, *value = NULL;
4862      PyTypeObject *tp;
4863      if (!o) {
4864          Py_RETURN_NONE;
4865      }
4866      if (++state->recursion_depth > state->recursion_limit) {
4867          PyErr_SetString(PyExc_RecursionError,
4868              "maximum recursion depth exceeded during ast construction");
4869          return 0;
4870      }
4871      tp = (PyTypeObject *)state->comprehension_type;
4872      result = PyType_GenericNew(tp, NULL, NULL);
4873      if (!result) return NULL;
4874      value = ast2obj_expr(state, o->target);
4875      if (!value) goto failed;
4876      if (PyObject_SetAttr(result, state->target, value) == -1)
4877          goto failed;
4878      Py_DECREF(value);
4879      value = ast2obj_expr(state, o->iter);
4880      if (!value) goto failed;
4881      if (PyObject_SetAttr(result, state->iter, value) == -1)
4882          goto failed;
4883      Py_DECREF(value);
4884      value = ast2obj_list(state, (asdl_seq*)o->ifs, ast2obj_expr);
4885      if (!value) goto failed;
4886      if (PyObject_SetAttr(result, state->ifs, value) == -1)
4887          goto failed;
4888      Py_DECREF(value);
4889      value = ast2obj_int(state, o->is_async);
4890      if (!value) goto failed;
4891      if (PyObject_SetAttr(result, state->is_async, value) == -1)
4892          goto failed;
4893      Py_DECREF(value);
4894      state->recursion_depth--;
4895      return result;
4896  failed:
4897      Py_XDECREF(value);
4898      Py_XDECREF(result);
4899      return NULL;
4900  }
4901  
4902  PyObject*
ast2obj_excepthandler(struct ast_state * state,void * _o)4903  ast2obj_excepthandler(struct ast_state *state, void* _o)
4904  {
4905      excepthandler_ty o = (excepthandler_ty)_o;
4906      PyObject *result = NULL, *value = NULL;
4907      PyTypeObject *tp;
4908      if (!o) {
4909          Py_RETURN_NONE;
4910      }
4911      if (++state->recursion_depth > state->recursion_limit) {
4912          PyErr_SetString(PyExc_RecursionError,
4913              "maximum recursion depth exceeded during ast construction");
4914          return 0;
4915      }
4916      switch (o->kind) {
4917      case ExceptHandler_kind:
4918          tp = (PyTypeObject *)state->ExceptHandler_type;
4919          result = PyType_GenericNew(tp, NULL, NULL);
4920          if (!result) goto failed;
4921          value = ast2obj_expr(state, o->v.ExceptHandler.type);
4922          if (!value) goto failed;
4923          if (PyObject_SetAttr(result, state->type, value) == -1)
4924              goto failed;
4925          Py_DECREF(value);
4926          value = ast2obj_identifier(state, o->v.ExceptHandler.name);
4927          if (!value) goto failed;
4928          if (PyObject_SetAttr(result, state->name, value) == -1)
4929              goto failed;
4930          Py_DECREF(value);
4931          value = ast2obj_list(state, (asdl_seq*)o->v.ExceptHandler.body,
4932                               ast2obj_stmt);
4933          if (!value) goto failed;
4934          if (PyObject_SetAttr(result, state->body, value) == -1)
4935              goto failed;
4936          Py_DECREF(value);
4937          break;
4938      }
4939      value = ast2obj_int(state, o->lineno);
4940      if (!value) goto failed;
4941      if (PyObject_SetAttr(result, state->lineno, value) < 0)
4942          goto failed;
4943      Py_DECREF(value);
4944      value = ast2obj_int(state, o->col_offset);
4945      if (!value) goto failed;
4946      if (PyObject_SetAttr(result, state->col_offset, value) < 0)
4947          goto failed;
4948      Py_DECREF(value);
4949      value = ast2obj_int(state, o->end_lineno);
4950      if (!value) goto failed;
4951      if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
4952          goto failed;
4953      Py_DECREF(value);
4954      value = ast2obj_int(state, o->end_col_offset);
4955      if (!value) goto failed;
4956      if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
4957          goto failed;
4958      Py_DECREF(value);
4959      state->recursion_depth--;
4960      return result;
4961  failed:
4962      Py_XDECREF(value);
4963      Py_XDECREF(result);
4964      return NULL;
4965  }
4966  
4967  PyObject*
ast2obj_arguments(struct ast_state * state,void * _o)4968  ast2obj_arguments(struct ast_state *state, void* _o)
4969  {
4970      arguments_ty o = (arguments_ty)_o;
4971      PyObject *result = NULL, *value = NULL;
4972      PyTypeObject *tp;
4973      if (!o) {
4974          Py_RETURN_NONE;
4975      }
4976      if (++state->recursion_depth > state->recursion_limit) {
4977          PyErr_SetString(PyExc_RecursionError,
4978              "maximum recursion depth exceeded during ast construction");
4979          return 0;
4980      }
4981      tp = (PyTypeObject *)state->arguments_type;
4982      result = PyType_GenericNew(tp, NULL, NULL);
4983      if (!result) return NULL;
4984      value = ast2obj_list(state, (asdl_seq*)o->posonlyargs, ast2obj_arg);
4985      if (!value) goto failed;
4986      if (PyObject_SetAttr(result, state->posonlyargs, value) == -1)
4987          goto failed;
4988      Py_DECREF(value);
4989      value = ast2obj_list(state, (asdl_seq*)o->args, ast2obj_arg);
4990      if (!value) goto failed;
4991      if (PyObject_SetAttr(result, state->args, value) == -1)
4992          goto failed;
4993      Py_DECREF(value);
4994      value = ast2obj_arg(state, o->vararg);
4995      if (!value) goto failed;
4996      if (PyObject_SetAttr(result, state->vararg, value) == -1)
4997          goto failed;
4998      Py_DECREF(value);
4999      value = ast2obj_list(state, (asdl_seq*)o->kwonlyargs, ast2obj_arg);
5000      if (!value) goto failed;
5001      if (PyObject_SetAttr(result, state->kwonlyargs, value) == -1)
5002          goto failed;
5003      Py_DECREF(value);
5004      value = ast2obj_list(state, (asdl_seq*)o->kw_defaults, ast2obj_expr);
5005      if (!value) goto failed;
5006      if (PyObject_SetAttr(result, state->kw_defaults, value) == -1)
5007          goto failed;
5008      Py_DECREF(value);
5009      value = ast2obj_arg(state, o->kwarg);
5010      if (!value) goto failed;
5011      if (PyObject_SetAttr(result, state->kwarg, value) == -1)
5012          goto failed;
5013      Py_DECREF(value);
5014      value = ast2obj_list(state, (asdl_seq*)o->defaults, ast2obj_expr);
5015      if (!value) goto failed;
5016      if (PyObject_SetAttr(result, state->defaults, value) == -1)
5017          goto failed;
5018      Py_DECREF(value);
5019      state->recursion_depth--;
5020      return result;
5021  failed:
5022      Py_XDECREF(value);
5023      Py_XDECREF(result);
5024      return NULL;
5025  }
5026  
5027  PyObject*
ast2obj_arg(struct ast_state * state,void * _o)5028  ast2obj_arg(struct ast_state *state, void* _o)
5029  {
5030      arg_ty o = (arg_ty)_o;
5031      PyObject *result = NULL, *value = NULL;
5032      PyTypeObject *tp;
5033      if (!o) {
5034          Py_RETURN_NONE;
5035      }
5036      if (++state->recursion_depth > state->recursion_limit) {
5037          PyErr_SetString(PyExc_RecursionError,
5038              "maximum recursion depth exceeded during ast construction");
5039          return 0;
5040      }
5041      tp = (PyTypeObject *)state->arg_type;
5042      result = PyType_GenericNew(tp, NULL, NULL);
5043      if (!result) return NULL;
5044      value = ast2obj_identifier(state, o->arg);
5045      if (!value) goto failed;
5046      if (PyObject_SetAttr(result, state->arg, value) == -1)
5047          goto failed;
5048      Py_DECREF(value);
5049      value = ast2obj_expr(state, o->annotation);
5050      if (!value) goto failed;
5051      if (PyObject_SetAttr(result, state->annotation, value) == -1)
5052          goto failed;
5053      Py_DECREF(value);
5054      value = ast2obj_string(state, o->type_comment);
5055      if (!value) goto failed;
5056      if (PyObject_SetAttr(result, state->type_comment, value) == -1)
5057          goto failed;
5058      Py_DECREF(value);
5059      value = ast2obj_int(state, o->lineno);
5060      if (!value) goto failed;
5061      if (PyObject_SetAttr(result, state->lineno, value) < 0)
5062          goto failed;
5063      Py_DECREF(value);
5064      value = ast2obj_int(state, o->col_offset);
5065      if (!value) goto failed;
5066      if (PyObject_SetAttr(result, state->col_offset, value) < 0)
5067          goto failed;
5068      Py_DECREF(value);
5069      value = ast2obj_int(state, o->end_lineno);
5070      if (!value) goto failed;
5071      if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
5072          goto failed;
5073      Py_DECREF(value);
5074      value = ast2obj_int(state, o->end_col_offset);
5075      if (!value) goto failed;
5076      if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
5077          goto failed;
5078      Py_DECREF(value);
5079      state->recursion_depth--;
5080      return result;
5081  failed:
5082      Py_XDECREF(value);
5083      Py_XDECREF(result);
5084      return NULL;
5085  }
5086  
5087  PyObject*
ast2obj_keyword(struct ast_state * state,void * _o)5088  ast2obj_keyword(struct ast_state *state, void* _o)
5089  {
5090      keyword_ty o = (keyword_ty)_o;
5091      PyObject *result = NULL, *value = NULL;
5092      PyTypeObject *tp;
5093      if (!o) {
5094          Py_RETURN_NONE;
5095      }
5096      if (++state->recursion_depth > state->recursion_limit) {
5097          PyErr_SetString(PyExc_RecursionError,
5098              "maximum recursion depth exceeded during ast construction");
5099          return 0;
5100      }
5101      tp = (PyTypeObject *)state->keyword_type;
5102      result = PyType_GenericNew(tp, NULL, NULL);
5103      if (!result) return NULL;
5104      value = ast2obj_identifier(state, o->arg);
5105      if (!value) goto failed;
5106      if (PyObject_SetAttr(result, state->arg, value) == -1)
5107          goto failed;
5108      Py_DECREF(value);
5109      value = ast2obj_expr(state, o->value);
5110      if (!value) goto failed;
5111      if (PyObject_SetAttr(result, state->value, value) == -1)
5112          goto failed;
5113      Py_DECREF(value);
5114      value = ast2obj_int(state, o->lineno);
5115      if (!value) goto failed;
5116      if (PyObject_SetAttr(result, state->lineno, value) < 0)
5117          goto failed;
5118      Py_DECREF(value);
5119      value = ast2obj_int(state, o->col_offset);
5120      if (!value) goto failed;
5121      if (PyObject_SetAttr(result, state->col_offset, value) < 0)
5122          goto failed;
5123      Py_DECREF(value);
5124      value = ast2obj_int(state, o->end_lineno);
5125      if (!value) goto failed;
5126      if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
5127          goto failed;
5128      Py_DECREF(value);
5129      value = ast2obj_int(state, o->end_col_offset);
5130      if (!value) goto failed;
5131      if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
5132          goto failed;
5133      Py_DECREF(value);
5134      state->recursion_depth--;
5135      return result;
5136  failed:
5137      Py_XDECREF(value);
5138      Py_XDECREF(result);
5139      return NULL;
5140  }
5141  
5142  PyObject*
ast2obj_alias(struct ast_state * state,void * _o)5143  ast2obj_alias(struct ast_state *state, void* _o)
5144  {
5145      alias_ty o = (alias_ty)_o;
5146      PyObject *result = NULL, *value = NULL;
5147      PyTypeObject *tp;
5148      if (!o) {
5149          Py_RETURN_NONE;
5150      }
5151      if (++state->recursion_depth > state->recursion_limit) {
5152          PyErr_SetString(PyExc_RecursionError,
5153              "maximum recursion depth exceeded during ast construction");
5154          return 0;
5155      }
5156      tp = (PyTypeObject *)state->alias_type;
5157      result = PyType_GenericNew(tp, NULL, NULL);
5158      if (!result) return NULL;
5159      value = ast2obj_identifier(state, o->name);
5160      if (!value) goto failed;
5161      if (PyObject_SetAttr(result, state->name, value) == -1)
5162          goto failed;
5163      Py_DECREF(value);
5164      value = ast2obj_identifier(state, o->asname);
5165      if (!value) goto failed;
5166      if (PyObject_SetAttr(result, state->asname, value) == -1)
5167          goto failed;
5168      Py_DECREF(value);
5169      value = ast2obj_int(state, o->lineno);
5170      if (!value) goto failed;
5171      if (PyObject_SetAttr(result, state->lineno, value) < 0)
5172          goto failed;
5173      Py_DECREF(value);
5174      value = ast2obj_int(state, o->col_offset);
5175      if (!value) goto failed;
5176      if (PyObject_SetAttr(result, state->col_offset, value) < 0)
5177          goto failed;
5178      Py_DECREF(value);
5179      value = ast2obj_int(state, o->end_lineno);
5180      if (!value) goto failed;
5181      if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
5182          goto failed;
5183      Py_DECREF(value);
5184      value = ast2obj_int(state, o->end_col_offset);
5185      if (!value) goto failed;
5186      if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
5187          goto failed;
5188      Py_DECREF(value);
5189      state->recursion_depth--;
5190      return result;
5191  failed:
5192      Py_XDECREF(value);
5193      Py_XDECREF(result);
5194      return NULL;
5195  }
5196  
5197  PyObject*
ast2obj_withitem(struct ast_state * state,void * _o)5198  ast2obj_withitem(struct ast_state *state, void* _o)
5199  {
5200      withitem_ty o = (withitem_ty)_o;
5201      PyObject *result = NULL, *value = NULL;
5202      PyTypeObject *tp;
5203      if (!o) {
5204          Py_RETURN_NONE;
5205      }
5206      if (++state->recursion_depth > state->recursion_limit) {
5207          PyErr_SetString(PyExc_RecursionError,
5208              "maximum recursion depth exceeded during ast construction");
5209          return 0;
5210      }
5211      tp = (PyTypeObject *)state->withitem_type;
5212      result = PyType_GenericNew(tp, NULL, NULL);
5213      if (!result) return NULL;
5214      value = ast2obj_expr(state, o->context_expr);
5215      if (!value) goto failed;
5216      if (PyObject_SetAttr(result, state->context_expr, value) == -1)
5217          goto failed;
5218      Py_DECREF(value);
5219      value = ast2obj_expr(state, o->optional_vars);
5220      if (!value) goto failed;
5221      if (PyObject_SetAttr(result, state->optional_vars, value) == -1)
5222          goto failed;
5223      Py_DECREF(value);
5224      state->recursion_depth--;
5225      return result;
5226  failed:
5227      Py_XDECREF(value);
5228      Py_XDECREF(result);
5229      return NULL;
5230  }
5231  
5232  PyObject*
ast2obj_match_case(struct ast_state * state,void * _o)5233  ast2obj_match_case(struct ast_state *state, void* _o)
5234  {
5235      match_case_ty o = (match_case_ty)_o;
5236      PyObject *result = NULL, *value = NULL;
5237      PyTypeObject *tp;
5238      if (!o) {
5239          Py_RETURN_NONE;
5240      }
5241      if (++state->recursion_depth > state->recursion_limit) {
5242          PyErr_SetString(PyExc_RecursionError,
5243              "maximum recursion depth exceeded during ast construction");
5244          return 0;
5245      }
5246      tp = (PyTypeObject *)state->match_case_type;
5247      result = PyType_GenericNew(tp, NULL, NULL);
5248      if (!result) return NULL;
5249      value = ast2obj_pattern(state, o->pattern);
5250      if (!value) goto failed;
5251      if (PyObject_SetAttr(result, state->pattern, value) == -1)
5252          goto failed;
5253      Py_DECREF(value);
5254      value = ast2obj_expr(state, o->guard);
5255      if (!value) goto failed;
5256      if (PyObject_SetAttr(result, state->guard, value) == -1)
5257          goto failed;
5258      Py_DECREF(value);
5259      value = ast2obj_list(state, (asdl_seq*)o->body, ast2obj_stmt);
5260      if (!value) goto failed;
5261      if (PyObject_SetAttr(result, state->body, value) == -1)
5262          goto failed;
5263      Py_DECREF(value);
5264      state->recursion_depth--;
5265      return result;
5266  failed:
5267      Py_XDECREF(value);
5268      Py_XDECREF(result);
5269      return NULL;
5270  }
5271  
5272  PyObject*
ast2obj_pattern(struct ast_state * state,void * _o)5273  ast2obj_pattern(struct ast_state *state, void* _o)
5274  {
5275      pattern_ty o = (pattern_ty)_o;
5276      PyObject *result = NULL, *value = NULL;
5277      PyTypeObject *tp;
5278      if (!o) {
5279          Py_RETURN_NONE;
5280      }
5281      if (++state->recursion_depth > state->recursion_limit) {
5282          PyErr_SetString(PyExc_RecursionError,
5283              "maximum recursion depth exceeded during ast construction");
5284          return 0;
5285      }
5286      switch (o->kind) {
5287      case MatchValue_kind:
5288          tp = (PyTypeObject *)state->MatchValue_type;
5289          result = PyType_GenericNew(tp, NULL, NULL);
5290          if (!result) goto failed;
5291          value = ast2obj_expr(state, o->v.MatchValue.value);
5292          if (!value) goto failed;
5293          if (PyObject_SetAttr(result, state->value, value) == -1)
5294              goto failed;
5295          Py_DECREF(value);
5296          break;
5297      case MatchSingleton_kind:
5298          tp = (PyTypeObject *)state->MatchSingleton_type;
5299          result = PyType_GenericNew(tp, NULL, NULL);
5300          if (!result) goto failed;
5301          value = ast2obj_constant(state, o->v.MatchSingleton.value);
5302          if (!value) goto failed;
5303          if (PyObject_SetAttr(result, state->value, value) == -1)
5304              goto failed;
5305          Py_DECREF(value);
5306          break;
5307      case MatchSequence_kind:
5308          tp = (PyTypeObject *)state->MatchSequence_type;
5309          result = PyType_GenericNew(tp, NULL, NULL);
5310          if (!result) goto failed;
5311          value = ast2obj_list(state, (asdl_seq*)o->v.MatchSequence.patterns,
5312                               ast2obj_pattern);
5313          if (!value) goto failed;
5314          if (PyObject_SetAttr(result, state->patterns, value) == -1)
5315              goto failed;
5316          Py_DECREF(value);
5317          break;
5318      case MatchMapping_kind:
5319          tp = (PyTypeObject *)state->MatchMapping_type;
5320          result = PyType_GenericNew(tp, NULL, NULL);
5321          if (!result) goto failed;
5322          value = ast2obj_list(state, (asdl_seq*)o->v.MatchMapping.keys,
5323                               ast2obj_expr);
5324          if (!value) goto failed;
5325          if (PyObject_SetAttr(result, state->keys, value) == -1)
5326              goto failed;
5327          Py_DECREF(value);
5328          value = ast2obj_list(state, (asdl_seq*)o->v.MatchMapping.patterns,
5329                               ast2obj_pattern);
5330          if (!value) goto failed;
5331          if (PyObject_SetAttr(result, state->patterns, value) == -1)
5332              goto failed;
5333          Py_DECREF(value);
5334          value = ast2obj_identifier(state, o->v.MatchMapping.rest);
5335          if (!value) goto failed;
5336          if (PyObject_SetAttr(result, state->rest, value) == -1)
5337              goto failed;
5338          Py_DECREF(value);
5339          break;
5340      case MatchClass_kind:
5341          tp = (PyTypeObject *)state->MatchClass_type;
5342          result = PyType_GenericNew(tp, NULL, NULL);
5343          if (!result) goto failed;
5344          value = ast2obj_expr(state, o->v.MatchClass.cls);
5345          if (!value) goto failed;
5346          if (PyObject_SetAttr(result, state->cls, value) == -1)
5347              goto failed;
5348          Py_DECREF(value);
5349          value = ast2obj_list(state, (asdl_seq*)o->v.MatchClass.patterns,
5350                               ast2obj_pattern);
5351          if (!value) goto failed;
5352          if (PyObject_SetAttr(result, state->patterns, value) == -1)
5353              goto failed;
5354          Py_DECREF(value);
5355          value = ast2obj_list(state, (asdl_seq*)o->v.MatchClass.kwd_attrs,
5356                               ast2obj_identifier);
5357          if (!value) goto failed;
5358          if (PyObject_SetAttr(result, state->kwd_attrs, value) == -1)
5359              goto failed;
5360          Py_DECREF(value);
5361          value = ast2obj_list(state, (asdl_seq*)o->v.MatchClass.kwd_patterns,
5362                               ast2obj_pattern);
5363          if (!value) goto failed;
5364          if (PyObject_SetAttr(result, state->kwd_patterns, value) == -1)
5365              goto failed;
5366          Py_DECREF(value);
5367          break;
5368      case MatchStar_kind:
5369          tp = (PyTypeObject *)state->MatchStar_type;
5370          result = PyType_GenericNew(tp, NULL, NULL);
5371          if (!result) goto failed;
5372          value = ast2obj_identifier(state, o->v.MatchStar.name);
5373          if (!value) goto failed;
5374          if (PyObject_SetAttr(result, state->name, value) == -1)
5375              goto failed;
5376          Py_DECREF(value);
5377          break;
5378      case MatchAs_kind:
5379          tp = (PyTypeObject *)state->MatchAs_type;
5380          result = PyType_GenericNew(tp, NULL, NULL);
5381          if (!result) goto failed;
5382          value = ast2obj_pattern(state, o->v.MatchAs.pattern);
5383          if (!value) goto failed;
5384          if (PyObject_SetAttr(result, state->pattern, value) == -1)
5385              goto failed;
5386          Py_DECREF(value);
5387          value = ast2obj_identifier(state, o->v.MatchAs.name);
5388          if (!value) goto failed;
5389          if (PyObject_SetAttr(result, state->name, value) == -1)
5390              goto failed;
5391          Py_DECREF(value);
5392          break;
5393      case MatchOr_kind:
5394          tp = (PyTypeObject *)state->MatchOr_type;
5395          result = PyType_GenericNew(tp, NULL, NULL);
5396          if (!result) goto failed;
5397          value = ast2obj_list(state, (asdl_seq*)o->v.MatchOr.patterns,
5398                               ast2obj_pattern);
5399          if (!value) goto failed;
5400          if (PyObject_SetAttr(result, state->patterns, value) == -1)
5401              goto failed;
5402          Py_DECREF(value);
5403          break;
5404      }
5405      value = ast2obj_int(state, o->lineno);
5406      if (!value) goto failed;
5407      if (PyObject_SetAttr(result, state->lineno, value) < 0)
5408          goto failed;
5409      Py_DECREF(value);
5410      value = ast2obj_int(state, o->col_offset);
5411      if (!value) goto failed;
5412      if (PyObject_SetAttr(result, state->col_offset, value) < 0)
5413          goto failed;
5414      Py_DECREF(value);
5415      value = ast2obj_int(state, o->end_lineno);
5416      if (!value) goto failed;
5417      if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
5418          goto failed;
5419      Py_DECREF(value);
5420      value = ast2obj_int(state, o->end_col_offset);
5421      if (!value) goto failed;
5422      if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
5423          goto failed;
5424      Py_DECREF(value);
5425      state->recursion_depth--;
5426      return result;
5427  failed:
5428      Py_XDECREF(value);
5429      Py_XDECREF(result);
5430      return NULL;
5431  }
5432  
5433  PyObject*
ast2obj_type_ignore(struct ast_state * state,void * _o)5434  ast2obj_type_ignore(struct ast_state *state, void* _o)
5435  {
5436      type_ignore_ty o = (type_ignore_ty)_o;
5437      PyObject *result = NULL, *value = NULL;
5438      PyTypeObject *tp;
5439      if (!o) {
5440          Py_RETURN_NONE;
5441      }
5442      if (++state->recursion_depth > state->recursion_limit) {
5443          PyErr_SetString(PyExc_RecursionError,
5444              "maximum recursion depth exceeded during ast construction");
5445          return 0;
5446      }
5447      switch (o->kind) {
5448      case TypeIgnore_kind:
5449          tp = (PyTypeObject *)state->TypeIgnore_type;
5450          result = PyType_GenericNew(tp, NULL, NULL);
5451          if (!result) goto failed;
5452          value = ast2obj_int(state, o->v.TypeIgnore.lineno);
5453          if (!value) goto failed;
5454          if (PyObject_SetAttr(result, state->lineno, value) == -1)
5455              goto failed;
5456          Py_DECREF(value);
5457          value = ast2obj_string(state, o->v.TypeIgnore.tag);
5458          if (!value) goto failed;
5459          if (PyObject_SetAttr(result, state->tag, value) == -1)
5460              goto failed;
5461          Py_DECREF(value);
5462          break;
5463      }
5464      state->recursion_depth--;
5465      return result;
5466  failed:
5467      Py_XDECREF(value);
5468      Py_XDECREF(result);
5469      return NULL;
5470  }
5471  
5472  
5473  int
obj2ast_mod(struct ast_state * state,PyObject * obj,mod_ty * out,PyArena * arena)5474  obj2ast_mod(struct ast_state *state, PyObject* obj, mod_ty* out, PyArena* arena)
5475  {
5476      int isinstance;
5477  
5478      PyObject *tmp = NULL;
5479      PyObject *tp;
5480  
5481      if (obj == Py_None) {
5482          *out = NULL;
5483          return 0;
5484      }
5485      tp = state->Module_type;
5486      isinstance = PyObject_IsInstance(obj, tp);
5487      if (isinstance == -1) {
5488          return 1;
5489      }
5490      if (isinstance) {
5491          asdl_stmt_seq* body;
5492          asdl_type_ignore_seq* type_ignores;
5493  
5494          if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
5495              return 1;
5496          }
5497          if (tmp == NULL) {
5498              PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Module");
5499              return 1;
5500          }
5501          else {
5502              int res;
5503              Py_ssize_t len;
5504              Py_ssize_t i;
5505              if (!PyList_Check(tmp)) {
5506                  PyErr_Format(PyExc_TypeError, "Module field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
5507                  goto failed;
5508              }
5509              len = PyList_GET_SIZE(tmp);
5510              body = _Py_asdl_stmt_seq_new(len, arena);
5511              if (body == NULL) goto failed;
5512              for (i = 0; i < len; i++) {
5513                  stmt_ty val;
5514                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
5515                  Py_INCREF(tmp2);
5516                  if (_Py_EnterRecursiveCall(" while traversing 'Module' node")) {
5517                      goto failed;
5518                  }
5519                  res = obj2ast_stmt(state, tmp2, &val, arena);
5520                  _Py_LeaveRecursiveCall();
5521                  Py_DECREF(tmp2);
5522                  if (res != 0) goto failed;
5523                  if (len != PyList_GET_SIZE(tmp)) {
5524                      PyErr_SetString(PyExc_RuntimeError, "Module field \"body\" changed size during iteration");
5525                      goto failed;
5526                  }
5527                  asdl_seq_SET(body, i, val);
5528              }
5529              Py_CLEAR(tmp);
5530          }
5531          if (_PyObject_LookupAttr(obj, state->type_ignores, &tmp) < 0) {
5532              return 1;
5533          }
5534          if (tmp == NULL) {
5535              PyErr_SetString(PyExc_TypeError, "required field \"type_ignores\" missing from Module");
5536              return 1;
5537          }
5538          else {
5539              int res;
5540              Py_ssize_t len;
5541              Py_ssize_t i;
5542              if (!PyList_Check(tmp)) {
5543                  PyErr_Format(PyExc_TypeError, "Module field \"type_ignores\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
5544                  goto failed;
5545              }
5546              len = PyList_GET_SIZE(tmp);
5547              type_ignores = _Py_asdl_type_ignore_seq_new(len, arena);
5548              if (type_ignores == NULL) goto failed;
5549              for (i = 0; i < len; i++) {
5550                  type_ignore_ty val;
5551                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
5552                  Py_INCREF(tmp2);
5553                  if (_Py_EnterRecursiveCall(" while traversing 'Module' node")) {
5554                      goto failed;
5555                  }
5556                  res = obj2ast_type_ignore(state, tmp2, &val, arena);
5557                  _Py_LeaveRecursiveCall();
5558                  Py_DECREF(tmp2);
5559                  if (res != 0) goto failed;
5560                  if (len != PyList_GET_SIZE(tmp)) {
5561                      PyErr_SetString(PyExc_RuntimeError, "Module field \"type_ignores\" changed size during iteration");
5562                      goto failed;
5563                  }
5564                  asdl_seq_SET(type_ignores, i, val);
5565              }
5566              Py_CLEAR(tmp);
5567          }
5568          *out = _PyAST_Module(body, type_ignores, arena);
5569          if (*out == NULL) goto failed;
5570          return 0;
5571      }
5572      tp = state->Interactive_type;
5573      isinstance = PyObject_IsInstance(obj, tp);
5574      if (isinstance == -1) {
5575          return 1;
5576      }
5577      if (isinstance) {
5578          asdl_stmt_seq* body;
5579  
5580          if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
5581              return 1;
5582          }
5583          if (tmp == NULL) {
5584              PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Interactive");
5585              return 1;
5586          }
5587          else {
5588              int res;
5589              Py_ssize_t len;
5590              Py_ssize_t i;
5591              if (!PyList_Check(tmp)) {
5592                  PyErr_Format(PyExc_TypeError, "Interactive field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
5593                  goto failed;
5594              }
5595              len = PyList_GET_SIZE(tmp);
5596              body = _Py_asdl_stmt_seq_new(len, arena);
5597              if (body == NULL) goto failed;
5598              for (i = 0; i < len; i++) {
5599                  stmt_ty val;
5600                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
5601                  Py_INCREF(tmp2);
5602                  if (_Py_EnterRecursiveCall(" while traversing 'Interactive' node")) {
5603                      goto failed;
5604                  }
5605                  res = obj2ast_stmt(state, tmp2, &val, arena);
5606                  _Py_LeaveRecursiveCall();
5607                  Py_DECREF(tmp2);
5608                  if (res != 0) goto failed;
5609                  if (len != PyList_GET_SIZE(tmp)) {
5610                      PyErr_SetString(PyExc_RuntimeError, "Interactive field \"body\" changed size during iteration");
5611                      goto failed;
5612                  }
5613                  asdl_seq_SET(body, i, val);
5614              }
5615              Py_CLEAR(tmp);
5616          }
5617          *out = _PyAST_Interactive(body, arena);
5618          if (*out == NULL) goto failed;
5619          return 0;
5620      }
5621      tp = state->Expression_type;
5622      isinstance = PyObject_IsInstance(obj, tp);
5623      if (isinstance == -1) {
5624          return 1;
5625      }
5626      if (isinstance) {
5627          expr_ty body;
5628  
5629          if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
5630              return 1;
5631          }
5632          if (tmp == NULL) {
5633              PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Expression");
5634              return 1;
5635          }
5636          else {
5637              int res;
5638              if (_Py_EnterRecursiveCall(" while traversing 'Expression' node")) {
5639                  goto failed;
5640              }
5641              res = obj2ast_expr(state, tmp, &body, arena);
5642              _Py_LeaveRecursiveCall();
5643              if (res != 0) goto failed;
5644              Py_CLEAR(tmp);
5645          }
5646          *out = _PyAST_Expression(body, arena);
5647          if (*out == NULL) goto failed;
5648          return 0;
5649      }
5650      tp = state->FunctionType_type;
5651      isinstance = PyObject_IsInstance(obj, tp);
5652      if (isinstance == -1) {
5653          return 1;
5654      }
5655      if (isinstance) {
5656          asdl_expr_seq* argtypes;
5657          expr_ty returns;
5658  
5659          if (_PyObject_LookupAttr(obj, state->argtypes, &tmp) < 0) {
5660              return 1;
5661          }
5662          if (tmp == NULL) {
5663              PyErr_SetString(PyExc_TypeError, "required field \"argtypes\" missing from FunctionType");
5664              return 1;
5665          }
5666          else {
5667              int res;
5668              Py_ssize_t len;
5669              Py_ssize_t i;
5670              if (!PyList_Check(tmp)) {
5671                  PyErr_Format(PyExc_TypeError, "FunctionType field \"argtypes\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
5672                  goto failed;
5673              }
5674              len = PyList_GET_SIZE(tmp);
5675              argtypes = _Py_asdl_expr_seq_new(len, arena);
5676              if (argtypes == NULL) goto failed;
5677              for (i = 0; i < len; i++) {
5678                  expr_ty val;
5679                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
5680                  Py_INCREF(tmp2);
5681                  if (_Py_EnterRecursiveCall(" while traversing 'FunctionType' node")) {
5682                      goto failed;
5683                  }
5684                  res = obj2ast_expr(state, tmp2, &val, arena);
5685                  _Py_LeaveRecursiveCall();
5686                  Py_DECREF(tmp2);
5687                  if (res != 0) goto failed;
5688                  if (len != PyList_GET_SIZE(tmp)) {
5689                      PyErr_SetString(PyExc_RuntimeError, "FunctionType field \"argtypes\" changed size during iteration");
5690                      goto failed;
5691                  }
5692                  asdl_seq_SET(argtypes, i, val);
5693              }
5694              Py_CLEAR(tmp);
5695          }
5696          if (_PyObject_LookupAttr(obj, state->returns, &tmp) < 0) {
5697              return 1;
5698          }
5699          if (tmp == NULL) {
5700              PyErr_SetString(PyExc_TypeError, "required field \"returns\" missing from FunctionType");
5701              return 1;
5702          }
5703          else {
5704              int res;
5705              if (_Py_EnterRecursiveCall(" while traversing 'FunctionType' node")) {
5706                  goto failed;
5707              }
5708              res = obj2ast_expr(state, tmp, &returns, arena);
5709              _Py_LeaveRecursiveCall();
5710              if (res != 0) goto failed;
5711              Py_CLEAR(tmp);
5712          }
5713          *out = _PyAST_FunctionType(argtypes, returns, arena);
5714          if (*out == NULL) goto failed;
5715          return 0;
5716      }
5717  
5718      PyErr_Format(PyExc_TypeError, "expected some sort of mod, but got %R", obj);
5719      failed:
5720      Py_XDECREF(tmp);
5721      return 1;
5722  }
5723  
5724  int
obj2ast_stmt(struct ast_state * state,PyObject * obj,stmt_ty * out,PyArena * arena)5725  obj2ast_stmt(struct ast_state *state, PyObject* obj, stmt_ty* out, PyArena*
5726               arena)
5727  {
5728      int isinstance;
5729  
5730      PyObject *tmp = NULL;
5731      PyObject *tp;
5732      int lineno;
5733      int col_offset;
5734      int end_lineno;
5735      int end_col_offset;
5736  
5737      if (obj == Py_None) {
5738          *out = NULL;
5739          return 0;
5740      }
5741      if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) {
5742          return 1;
5743      }
5744      if (tmp == NULL) {
5745          PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from stmt");
5746          return 1;
5747      }
5748      else {
5749          int res;
5750          if (_Py_EnterRecursiveCall(" while traversing 'stmt' node")) {
5751              goto failed;
5752          }
5753          res = obj2ast_int(state, tmp, &lineno, arena);
5754          _Py_LeaveRecursiveCall();
5755          if (res != 0) goto failed;
5756          Py_CLEAR(tmp);
5757      }
5758      if (_PyObject_LookupAttr(obj, state->col_offset, &tmp) < 0) {
5759          return 1;
5760      }
5761      if (tmp == NULL) {
5762          PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from stmt");
5763          return 1;
5764      }
5765      else {
5766          int res;
5767          if (_Py_EnterRecursiveCall(" while traversing 'stmt' node")) {
5768              goto failed;
5769          }
5770          res = obj2ast_int(state, tmp, &col_offset, arena);
5771          _Py_LeaveRecursiveCall();
5772          if (res != 0) goto failed;
5773          Py_CLEAR(tmp);
5774      }
5775      if (_PyObject_LookupAttr(obj, state->end_lineno, &tmp) < 0) {
5776          return 1;
5777      }
5778      if (tmp == NULL || tmp == Py_None) {
5779          Py_CLEAR(tmp);
5780          end_lineno = lineno;
5781      }
5782      else {
5783          int res;
5784          if (_Py_EnterRecursiveCall(" while traversing 'stmt' node")) {
5785              goto failed;
5786          }
5787          res = obj2ast_int(state, tmp, &end_lineno, arena);
5788          _Py_LeaveRecursiveCall();
5789          if (res != 0) goto failed;
5790          Py_CLEAR(tmp);
5791      }
5792      if (_PyObject_LookupAttr(obj, state->end_col_offset, &tmp) < 0) {
5793          return 1;
5794      }
5795      if (tmp == NULL || tmp == Py_None) {
5796          Py_CLEAR(tmp);
5797          end_col_offset = col_offset;
5798      }
5799      else {
5800          int res;
5801          if (_Py_EnterRecursiveCall(" while traversing 'stmt' node")) {
5802              goto failed;
5803          }
5804          res = obj2ast_int(state, tmp, &end_col_offset, arena);
5805          _Py_LeaveRecursiveCall();
5806          if (res != 0) goto failed;
5807          Py_CLEAR(tmp);
5808      }
5809      tp = state->FunctionDef_type;
5810      isinstance = PyObject_IsInstance(obj, tp);
5811      if (isinstance == -1) {
5812          return 1;
5813      }
5814      if (isinstance) {
5815          identifier name;
5816          arguments_ty args;
5817          asdl_stmt_seq* body;
5818          asdl_expr_seq* decorator_list;
5819          expr_ty returns;
5820          string type_comment;
5821  
5822          if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) {
5823              return 1;
5824          }
5825          if (tmp == NULL) {
5826              PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from FunctionDef");
5827              return 1;
5828          }
5829          else {
5830              int res;
5831              if (_Py_EnterRecursiveCall(" while traversing 'FunctionDef' node")) {
5832                  goto failed;
5833              }
5834              res = obj2ast_identifier(state, tmp, &name, arena);
5835              _Py_LeaveRecursiveCall();
5836              if (res != 0) goto failed;
5837              Py_CLEAR(tmp);
5838          }
5839          if (_PyObject_LookupAttr(obj, state->args, &tmp) < 0) {
5840              return 1;
5841          }
5842          if (tmp == NULL) {
5843              PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from FunctionDef");
5844              return 1;
5845          }
5846          else {
5847              int res;
5848              if (_Py_EnterRecursiveCall(" while traversing 'FunctionDef' node")) {
5849                  goto failed;
5850              }
5851              res = obj2ast_arguments(state, tmp, &args, arena);
5852              _Py_LeaveRecursiveCall();
5853              if (res != 0) goto failed;
5854              Py_CLEAR(tmp);
5855          }
5856          if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
5857              return 1;
5858          }
5859          if (tmp == NULL) {
5860              PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from FunctionDef");
5861              return 1;
5862          }
5863          else {
5864              int res;
5865              Py_ssize_t len;
5866              Py_ssize_t i;
5867              if (!PyList_Check(tmp)) {
5868                  PyErr_Format(PyExc_TypeError, "FunctionDef field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
5869                  goto failed;
5870              }
5871              len = PyList_GET_SIZE(tmp);
5872              body = _Py_asdl_stmt_seq_new(len, arena);
5873              if (body == NULL) goto failed;
5874              for (i = 0; i < len; i++) {
5875                  stmt_ty val;
5876                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
5877                  Py_INCREF(tmp2);
5878                  if (_Py_EnterRecursiveCall(" while traversing 'FunctionDef' node")) {
5879                      goto failed;
5880                  }
5881                  res = obj2ast_stmt(state, tmp2, &val, arena);
5882                  _Py_LeaveRecursiveCall();
5883                  Py_DECREF(tmp2);
5884                  if (res != 0) goto failed;
5885                  if (len != PyList_GET_SIZE(tmp)) {
5886                      PyErr_SetString(PyExc_RuntimeError, "FunctionDef field \"body\" changed size during iteration");
5887                      goto failed;
5888                  }
5889                  asdl_seq_SET(body, i, val);
5890              }
5891              Py_CLEAR(tmp);
5892          }
5893          if (_PyObject_LookupAttr(obj, state->decorator_list, &tmp) < 0) {
5894              return 1;
5895          }
5896          if (tmp == NULL) {
5897              PyErr_SetString(PyExc_TypeError, "required field \"decorator_list\" missing from FunctionDef");
5898              return 1;
5899          }
5900          else {
5901              int res;
5902              Py_ssize_t len;
5903              Py_ssize_t i;
5904              if (!PyList_Check(tmp)) {
5905                  PyErr_Format(PyExc_TypeError, "FunctionDef field \"decorator_list\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
5906                  goto failed;
5907              }
5908              len = PyList_GET_SIZE(tmp);
5909              decorator_list = _Py_asdl_expr_seq_new(len, arena);
5910              if (decorator_list == NULL) goto failed;
5911              for (i = 0; i < len; i++) {
5912                  expr_ty val;
5913                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
5914                  Py_INCREF(tmp2);
5915                  if (_Py_EnterRecursiveCall(" while traversing 'FunctionDef' node")) {
5916                      goto failed;
5917                  }
5918                  res = obj2ast_expr(state, tmp2, &val, arena);
5919                  _Py_LeaveRecursiveCall();
5920                  Py_DECREF(tmp2);
5921                  if (res != 0) goto failed;
5922                  if (len != PyList_GET_SIZE(tmp)) {
5923                      PyErr_SetString(PyExc_RuntimeError, "FunctionDef field \"decorator_list\" changed size during iteration");
5924                      goto failed;
5925                  }
5926                  asdl_seq_SET(decorator_list, i, val);
5927              }
5928              Py_CLEAR(tmp);
5929          }
5930          if (_PyObject_LookupAttr(obj, state->returns, &tmp) < 0) {
5931              return 1;
5932          }
5933          if (tmp == NULL || tmp == Py_None) {
5934              Py_CLEAR(tmp);
5935              returns = NULL;
5936          }
5937          else {
5938              int res;
5939              if (_Py_EnterRecursiveCall(" while traversing 'FunctionDef' node")) {
5940                  goto failed;
5941              }
5942              res = obj2ast_expr(state, tmp, &returns, arena);
5943              _Py_LeaveRecursiveCall();
5944              if (res != 0) goto failed;
5945              Py_CLEAR(tmp);
5946          }
5947          if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) {
5948              return 1;
5949          }
5950          if (tmp == NULL || tmp == Py_None) {
5951              Py_CLEAR(tmp);
5952              type_comment = NULL;
5953          }
5954          else {
5955              int res;
5956              if (_Py_EnterRecursiveCall(" while traversing 'FunctionDef' node")) {
5957                  goto failed;
5958              }
5959              res = obj2ast_string(state, tmp, &type_comment, arena);
5960              _Py_LeaveRecursiveCall();
5961              if (res != 0) goto failed;
5962              Py_CLEAR(tmp);
5963          }
5964          *out = _PyAST_FunctionDef(name, args, body, decorator_list, returns,
5965                                    type_comment, lineno, col_offset, end_lineno,
5966                                    end_col_offset, arena);
5967          if (*out == NULL) goto failed;
5968          return 0;
5969      }
5970      tp = state->AsyncFunctionDef_type;
5971      isinstance = PyObject_IsInstance(obj, tp);
5972      if (isinstance == -1) {
5973          return 1;
5974      }
5975      if (isinstance) {
5976          identifier name;
5977          arguments_ty args;
5978          asdl_stmt_seq* body;
5979          asdl_expr_seq* decorator_list;
5980          expr_ty returns;
5981          string type_comment;
5982  
5983          if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) {
5984              return 1;
5985          }
5986          if (tmp == NULL) {
5987              PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from AsyncFunctionDef");
5988              return 1;
5989          }
5990          else {
5991              int res;
5992              if (_Py_EnterRecursiveCall(" while traversing 'AsyncFunctionDef' node")) {
5993                  goto failed;
5994              }
5995              res = obj2ast_identifier(state, tmp, &name, arena);
5996              _Py_LeaveRecursiveCall();
5997              if (res != 0) goto failed;
5998              Py_CLEAR(tmp);
5999          }
6000          if (_PyObject_LookupAttr(obj, state->args, &tmp) < 0) {
6001              return 1;
6002          }
6003          if (tmp == NULL) {
6004              PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from AsyncFunctionDef");
6005              return 1;
6006          }
6007          else {
6008              int res;
6009              if (_Py_EnterRecursiveCall(" while traversing 'AsyncFunctionDef' node")) {
6010                  goto failed;
6011              }
6012              res = obj2ast_arguments(state, tmp, &args, arena);
6013              _Py_LeaveRecursiveCall();
6014              if (res != 0) goto failed;
6015              Py_CLEAR(tmp);
6016          }
6017          if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
6018              return 1;
6019          }
6020          if (tmp == NULL) {
6021              PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from AsyncFunctionDef");
6022              return 1;
6023          }
6024          else {
6025              int res;
6026              Py_ssize_t len;
6027              Py_ssize_t i;
6028              if (!PyList_Check(tmp)) {
6029                  PyErr_Format(PyExc_TypeError, "AsyncFunctionDef field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6030                  goto failed;
6031              }
6032              len = PyList_GET_SIZE(tmp);
6033              body = _Py_asdl_stmt_seq_new(len, arena);
6034              if (body == NULL) goto failed;
6035              for (i = 0; i < len; i++) {
6036                  stmt_ty val;
6037                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
6038                  Py_INCREF(tmp2);
6039                  if (_Py_EnterRecursiveCall(" while traversing 'AsyncFunctionDef' node")) {
6040                      goto failed;
6041                  }
6042                  res = obj2ast_stmt(state, tmp2, &val, arena);
6043                  _Py_LeaveRecursiveCall();
6044                  Py_DECREF(tmp2);
6045                  if (res != 0) goto failed;
6046                  if (len != PyList_GET_SIZE(tmp)) {
6047                      PyErr_SetString(PyExc_RuntimeError, "AsyncFunctionDef field \"body\" changed size during iteration");
6048                      goto failed;
6049                  }
6050                  asdl_seq_SET(body, i, val);
6051              }
6052              Py_CLEAR(tmp);
6053          }
6054          if (_PyObject_LookupAttr(obj, state->decorator_list, &tmp) < 0) {
6055              return 1;
6056          }
6057          if (tmp == NULL) {
6058              PyErr_SetString(PyExc_TypeError, "required field \"decorator_list\" missing from AsyncFunctionDef");
6059              return 1;
6060          }
6061          else {
6062              int res;
6063              Py_ssize_t len;
6064              Py_ssize_t i;
6065              if (!PyList_Check(tmp)) {
6066                  PyErr_Format(PyExc_TypeError, "AsyncFunctionDef field \"decorator_list\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6067                  goto failed;
6068              }
6069              len = PyList_GET_SIZE(tmp);
6070              decorator_list = _Py_asdl_expr_seq_new(len, arena);
6071              if (decorator_list == NULL) goto failed;
6072              for (i = 0; i < len; i++) {
6073                  expr_ty val;
6074                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
6075                  Py_INCREF(tmp2);
6076                  if (_Py_EnterRecursiveCall(" while traversing 'AsyncFunctionDef' node")) {
6077                      goto failed;
6078                  }
6079                  res = obj2ast_expr(state, tmp2, &val, arena);
6080                  _Py_LeaveRecursiveCall();
6081                  Py_DECREF(tmp2);
6082                  if (res != 0) goto failed;
6083                  if (len != PyList_GET_SIZE(tmp)) {
6084                      PyErr_SetString(PyExc_RuntimeError, "AsyncFunctionDef field \"decorator_list\" changed size during iteration");
6085                      goto failed;
6086                  }
6087                  asdl_seq_SET(decorator_list, i, val);
6088              }
6089              Py_CLEAR(tmp);
6090          }
6091          if (_PyObject_LookupAttr(obj, state->returns, &tmp) < 0) {
6092              return 1;
6093          }
6094          if (tmp == NULL || tmp == Py_None) {
6095              Py_CLEAR(tmp);
6096              returns = NULL;
6097          }
6098          else {
6099              int res;
6100              if (_Py_EnterRecursiveCall(" while traversing 'AsyncFunctionDef' node")) {
6101                  goto failed;
6102              }
6103              res = obj2ast_expr(state, tmp, &returns, arena);
6104              _Py_LeaveRecursiveCall();
6105              if (res != 0) goto failed;
6106              Py_CLEAR(tmp);
6107          }
6108          if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) {
6109              return 1;
6110          }
6111          if (tmp == NULL || tmp == Py_None) {
6112              Py_CLEAR(tmp);
6113              type_comment = NULL;
6114          }
6115          else {
6116              int res;
6117              if (_Py_EnterRecursiveCall(" while traversing 'AsyncFunctionDef' node")) {
6118                  goto failed;
6119              }
6120              res = obj2ast_string(state, tmp, &type_comment, arena);
6121              _Py_LeaveRecursiveCall();
6122              if (res != 0) goto failed;
6123              Py_CLEAR(tmp);
6124          }
6125          *out = _PyAST_AsyncFunctionDef(name, args, body, decorator_list,
6126                                         returns, type_comment, lineno,
6127                                         col_offset, end_lineno, end_col_offset,
6128                                         arena);
6129          if (*out == NULL) goto failed;
6130          return 0;
6131      }
6132      tp = state->ClassDef_type;
6133      isinstance = PyObject_IsInstance(obj, tp);
6134      if (isinstance == -1) {
6135          return 1;
6136      }
6137      if (isinstance) {
6138          identifier name;
6139          asdl_expr_seq* bases;
6140          asdl_keyword_seq* keywords;
6141          asdl_stmt_seq* body;
6142          asdl_expr_seq* decorator_list;
6143  
6144          if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) {
6145              return 1;
6146          }
6147          if (tmp == NULL) {
6148              PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from ClassDef");
6149              return 1;
6150          }
6151          else {
6152              int res;
6153              if (_Py_EnterRecursiveCall(" while traversing 'ClassDef' node")) {
6154                  goto failed;
6155              }
6156              res = obj2ast_identifier(state, tmp, &name, arena);
6157              _Py_LeaveRecursiveCall();
6158              if (res != 0) goto failed;
6159              Py_CLEAR(tmp);
6160          }
6161          if (_PyObject_LookupAttr(obj, state->bases, &tmp) < 0) {
6162              return 1;
6163          }
6164          if (tmp == NULL) {
6165              PyErr_SetString(PyExc_TypeError, "required field \"bases\" missing from ClassDef");
6166              return 1;
6167          }
6168          else {
6169              int res;
6170              Py_ssize_t len;
6171              Py_ssize_t i;
6172              if (!PyList_Check(tmp)) {
6173                  PyErr_Format(PyExc_TypeError, "ClassDef field \"bases\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6174                  goto failed;
6175              }
6176              len = PyList_GET_SIZE(tmp);
6177              bases = _Py_asdl_expr_seq_new(len, arena);
6178              if (bases == NULL) goto failed;
6179              for (i = 0; i < len; i++) {
6180                  expr_ty val;
6181                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
6182                  Py_INCREF(tmp2);
6183                  if (_Py_EnterRecursiveCall(" while traversing 'ClassDef' node")) {
6184                      goto failed;
6185                  }
6186                  res = obj2ast_expr(state, tmp2, &val, arena);
6187                  _Py_LeaveRecursiveCall();
6188                  Py_DECREF(tmp2);
6189                  if (res != 0) goto failed;
6190                  if (len != PyList_GET_SIZE(tmp)) {
6191                      PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"bases\" changed size during iteration");
6192                      goto failed;
6193                  }
6194                  asdl_seq_SET(bases, i, val);
6195              }
6196              Py_CLEAR(tmp);
6197          }
6198          if (_PyObject_LookupAttr(obj, state->keywords, &tmp) < 0) {
6199              return 1;
6200          }
6201          if (tmp == NULL) {
6202              PyErr_SetString(PyExc_TypeError, "required field \"keywords\" missing from ClassDef");
6203              return 1;
6204          }
6205          else {
6206              int res;
6207              Py_ssize_t len;
6208              Py_ssize_t i;
6209              if (!PyList_Check(tmp)) {
6210                  PyErr_Format(PyExc_TypeError, "ClassDef field \"keywords\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6211                  goto failed;
6212              }
6213              len = PyList_GET_SIZE(tmp);
6214              keywords = _Py_asdl_keyword_seq_new(len, arena);
6215              if (keywords == NULL) goto failed;
6216              for (i = 0; i < len; i++) {
6217                  keyword_ty val;
6218                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
6219                  Py_INCREF(tmp2);
6220                  if (_Py_EnterRecursiveCall(" while traversing 'ClassDef' node")) {
6221                      goto failed;
6222                  }
6223                  res = obj2ast_keyword(state, tmp2, &val, arena);
6224                  _Py_LeaveRecursiveCall();
6225                  Py_DECREF(tmp2);
6226                  if (res != 0) goto failed;
6227                  if (len != PyList_GET_SIZE(tmp)) {
6228                      PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"keywords\" changed size during iteration");
6229                      goto failed;
6230                  }
6231                  asdl_seq_SET(keywords, i, val);
6232              }
6233              Py_CLEAR(tmp);
6234          }
6235          if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
6236              return 1;
6237          }
6238          if (tmp == NULL) {
6239              PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from ClassDef");
6240              return 1;
6241          }
6242          else {
6243              int res;
6244              Py_ssize_t len;
6245              Py_ssize_t i;
6246              if (!PyList_Check(tmp)) {
6247                  PyErr_Format(PyExc_TypeError, "ClassDef field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6248                  goto failed;
6249              }
6250              len = PyList_GET_SIZE(tmp);
6251              body = _Py_asdl_stmt_seq_new(len, arena);
6252              if (body == NULL) goto failed;
6253              for (i = 0; i < len; i++) {
6254                  stmt_ty val;
6255                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
6256                  Py_INCREF(tmp2);
6257                  if (_Py_EnterRecursiveCall(" while traversing 'ClassDef' node")) {
6258                      goto failed;
6259                  }
6260                  res = obj2ast_stmt(state, tmp2, &val, arena);
6261                  _Py_LeaveRecursiveCall();
6262                  Py_DECREF(tmp2);
6263                  if (res != 0) goto failed;
6264                  if (len != PyList_GET_SIZE(tmp)) {
6265                      PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"body\" changed size during iteration");
6266                      goto failed;
6267                  }
6268                  asdl_seq_SET(body, i, val);
6269              }
6270              Py_CLEAR(tmp);
6271          }
6272          if (_PyObject_LookupAttr(obj, state->decorator_list, &tmp) < 0) {
6273              return 1;
6274          }
6275          if (tmp == NULL) {
6276              PyErr_SetString(PyExc_TypeError, "required field \"decorator_list\" missing from ClassDef");
6277              return 1;
6278          }
6279          else {
6280              int res;
6281              Py_ssize_t len;
6282              Py_ssize_t i;
6283              if (!PyList_Check(tmp)) {
6284                  PyErr_Format(PyExc_TypeError, "ClassDef field \"decorator_list\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6285                  goto failed;
6286              }
6287              len = PyList_GET_SIZE(tmp);
6288              decorator_list = _Py_asdl_expr_seq_new(len, arena);
6289              if (decorator_list == NULL) goto failed;
6290              for (i = 0; i < len; i++) {
6291                  expr_ty val;
6292                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
6293                  Py_INCREF(tmp2);
6294                  if (_Py_EnterRecursiveCall(" while traversing 'ClassDef' node")) {
6295                      goto failed;
6296                  }
6297                  res = obj2ast_expr(state, tmp2, &val, arena);
6298                  _Py_LeaveRecursiveCall();
6299                  Py_DECREF(tmp2);
6300                  if (res != 0) goto failed;
6301                  if (len != PyList_GET_SIZE(tmp)) {
6302                      PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"decorator_list\" changed size during iteration");
6303                      goto failed;
6304                  }
6305                  asdl_seq_SET(decorator_list, i, val);
6306              }
6307              Py_CLEAR(tmp);
6308          }
6309          *out = _PyAST_ClassDef(name, bases, keywords, body, decorator_list,
6310                                 lineno, col_offset, end_lineno, end_col_offset,
6311                                 arena);
6312          if (*out == NULL) goto failed;
6313          return 0;
6314      }
6315      tp = state->Return_type;
6316      isinstance = PyObject_IsInstance(obj, tp);
6317      if (isinstance == -1) {
6318          return 1;
6319      }
6320      if (isinstance) {
6321          expr_ty value;
6322  
6323          if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
6324              return 1;
6325          }
6326          if (tmp == NULL || tmp == Py_None) {
6327              Py_CLEAR(tmp);
6328              value = NULL;
6329          }
6330          else {
6331              int res;
6332              if (_Py_EnterRecursiveCall(" while traversing 'Return' node")) {
6333                  goto failed;
6334              }
6335              res = obj2ast_expr(state, tmp, &value, arena);
6336              _Py_LeaveRecursiveCall();
6337              if (res != 0) goto failed;
6338              Py_CLEAR(tmp);
6339          }
6340          *out = _PyAST_Return(value, lineno, col_offset, end_lineno,
6341                               end_col_offset, arena);
6342          if (*out == NULL) goto failed;
6343          return 0;
6344      }
6345      tp = state->Delete_type;
6346      isinstance = PyObject_IsInstance(obj, tp);
6347      if (isinstance == -1) {
6348          return 1;
6349      }
6350      if (isinstance) {
6351          asdl_expr_seq* targets;
6352  
6353          if (_PyObject_LookupAttr(obj, state->targets, &tmp) < 0) {
6354              return 1;
6355          }
6356          if (tmp == NULL) {
6357              PyErr_SetString(PyExc_TypeError, "required field \"targets\" missing from Delete");
6358              return 1;
6359          }
6360          else {
6361              int res;
6362              Py_ssize_t len;
6363              Py_ssize_t i;
6364              if (!PyList_Check(tmp)) {
6365                  PyErr_Format(PyExc_TypeError, "Delete field \"targets\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6366                  goto failed;
6367              }
6368              len = PyList_GET_SIZE(tmp);
6369              targets = _Py_asdl_expr_seq_new(len, arena);
6370              if (targets == NULL) goto failed;
6371              for (i = 0; i < len; i++) {
6372                  expr_ty val;
6373                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
6374                  Py_INCREF(tmp2);
6375                  if (_Py_EnterRecursiveCall(" while traversing 'Delete' node")) {
6376                      goto failed;
6377                  }
6378                  res = obj2ast_expr(state, tmp2, &val, arena);
6379                  _Py_LeaveRecursiveCall();
6380                  Py_DECREF(tmp2);
6381                  if (res != 0) goto failed;
6382                  if (len != PyList_GET_SIZE(tmp)) {
6383                      PyErr_SetString(PyExc_RuntimeError, "Delete field \"targets\" changed size during iteration");
6384                      goto failed;
6385                  }
6386                  asdl_seq_SET(targets, i, val);
6387              }
6388              Py_CLEAR(tmp);
6389          }
6390          *out = _PyAST_Delete(targets, lineno, col_offset, end_lineno,
6391                               end_col_offset, arena);
6392          if (*out == NULL) goto failed;
6393          return 0;
6394      }
6395      tp = state->Assign_type;
6396      isinstance = PyObject_IsInstance(obj, tp);
6397      if (isinstance == -1) {
6398          return 1;
6399      }
6400      if (isinstance) {
6401          asdl_expr_seq* targets;
6402          expr_ty value;
6403          string type_comment;
6404  
6405          if (_PyObject_LookupAttr(obj, state->targets, &tmp) < 0) {
6406              return 1;
6407          }
6408          if (tmp == NULL) {
6409              PyErr_SetString(PyExc_TypeError, "required field \"targets\" missing from Assign");
6410              return 1;
6411          }
6412          else {
6413              int res;
6414              Py_ssize_t len;
6415              Py_ssize_t i;
6416              if (!PyList_Check(tmp)) {
6417                  PyErr_Format(PyExc_TypeError, "Assign field \"targets\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6418                  goto failed;
6419              }
6420              len = PyList_GET_SIZE(tmp);
6421              targets = _Py_asdl_expr_seq_new(len, arena);
6422              if (targets == NULL) goto failed;
6423              for (i = 0; i < len; i++) {
6424                  expr_ty val;
6425                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
6426                  Py_INCREF(tmp2);
6427                  if (_Py_EnterRecursiveCall(" while traversing 'Assign' node")) {
6428                      goto failed;
6429                  }
6430                  res = obj2ast_expr(state, tmp2, &val, arena);
6431                  _Py_LeaveRecursiveCall();
6432                  Py_DECREF(tmp2);
6433                  if (res != 0) goto failed;
6434                  if (len != PyList_GET_SIZE(tmp)) {
6435                      PyErr_SetString(PyExc_RuntimeError, "Assign field \"targets\" changed size during iteration");
6436                      goto failed;
6437                  }
6438                  asdl_seq_SET(targets, i, val);
6439              }
6440              Py_CLEAR(tmp);
6441          }
6442          if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
6443              return 1;
6444          }
6445          if (tmp == NULL) {
6446              PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Assign");
6447              return 1;
6448          }
6449          else {
6450              int res;
6451              if (_Py_EnterRecursiveCall(" while traversing 'Assign' node")) {
6452                  goto failed;
6453              }
6454              res = obj2ast_expr(state, tmp, &value, arena);
6455              _Py_LeaveRecursiveCall();
6456              if (res != 0) goto failed;
6457              Py_CLEAR(tmp);
6458          }
6459          if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) {
6460              return 1;
6461          }
6462          if (tmp == NULL || tmp == Py_None) {
6463              Py_CLEAR(tmp);
6464              type_comment = NULL;
6465          }
6466          else {
6467              int res;
6468              if (_Py_EnterRecursiveCall(" while traversing 'Assign' node")) {
6469                  goto failed;
6470              }
6471              res = obj2ast_string(state, tmp, &type_comment, arena);
6472              _Py_LeaveRecursiveCall();
6473              if (res != 0) goto failed;
6474              Py_CLEAR(tmp);
6475          }
6476          *out = _PyAST_Assign(targets, value, type_comment, lineno, col_offset,
6477                               end_lineno, end_col_offset, arena);
6478          if (*out == NULL) goto failed;
6479          return 0;
6480      }
6481      tp = state->AugAssign_type;
6482      isinstance = PyObject_IsInstance(obj, tp);
6483      if (isinstance == -1) {
6484          return 1;
6485      }
6486      if (isinstance) {
6487          expr_ty target;
6488          operator_ty op;
6489          expr_ty value;
6490  
6491          if (_PyObject_LookupAttr(obj, state->target, &tmp) < 0) {
6492              return 1;
6493          }
6494          if (tmp == NULL) {
6495              PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from AugAssign");
6496              return 1;
6497          }
6498          else {
6499              int res;
6500              if (_Py_EnterRecursiveCall(" while traversing 'AugAssign' node")) {
6501                  goto failed;
6502              }
6503              res = obj2ast_expr(state, tmp, &target, arena);
6504              _Py_LeaveRecursiveCall();
6505              if (res != 0) goto failed;
6506              Py_CLEAR(tmp);
6507          }
6508          if (_PyObject_LookupAttr(obj, state->op, &tmp) < 0) {
6509              return 1;
6510          }
6511          if (tmp == NULL) {
6512              PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from AugAssign");
6513              return 1;
6514          }
6515          else {
6516              int res;
6517              if (_Py_EnterRecursiveCall(" while traversing 'AugAssign' node")) {
6518                  goto failed;
6519              }
6520              res = obj2ast_operator(state, tmp, &op, arena);
6521              _Py_LeaveRecursiveCall();
6522              if (res != 0) goto failed;
6523              Py_CLEAR(tmp);
6524          }
6525          if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
6526              return 1;
6527          }
6528          if (tmp == NULL) {
6529              PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from AugAssign");
6530              return 1;
6531          }
6532          else {
6533              int res;
6534              if (_Py_EnterRecursiveCall(" while traversing 'AugAssign' node")) {
6535                  goto failed;
6536              }
6537              res = obj2ast_expr(state, tmp, &value, arena);
6538              _Py_LeaveRecursiveCall();
6539              if (res != 0) goto failed;
6540              Py_CLEAR(tmp);
6541          }
6542          *out = _PyAST_AugAssign(target, op, value, lineno, col_offset,
6543                                  end_lineno, end_col_offset, arena);
6544          if (*out == NULL) goto failed;
6545          return 0;
6546      }
6547      tp = state->AnnAssign_type;
6548      isinstance = PyObject_IsInstance(obj, tp);
6549      if (isinstance == -1) {
6550          return 1;
6551      }
6552      if (isinstance) {
6553          expr_ty target;
6554          expr_ty annotation;
6555          expr_ty value;
6556          int simple;
6557  
6558          if (_PyObject_LookupAttr(obj, state->target, &tmp) < 0) {
6559              return 1;
6560          }
6561          if (tmp == NULL) {
6562              PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from AnnAssign");
6563              return 1;
6564          }
6565          else {
6566              int res;
6567              if (_Py_EnterRecursiveCall(" while traversing 'AnnAssign' node")) {
6568                  goto failed;
6569              }
6570              res = obj2ast_expr(state, tmp, &target, arena);
6571              _Py_LeaveRecursiveCall();
6572              if (res != 0) goto failed;
6573              Py_CLEAR(tmp);
6574          }
6575          if (_PyObject_LookupAttr(obj, state->annotation, &tmp) < 0) {
6576              return 1;
6577          }
6578          if (tmp == NULL) {
6579              PyErr_SetString(PyExc_TypeError, "required field \"annotation\" missing from AnnAssign");
6580              return 1;
6581          }
6582          else {
6583              int res;
6584              if (_Py_EnterRecursiveCall(" while traversing 'AnnAssign' node")) {
6585                  goto failed;
6586              }
6587              res = obj2ast_expr(state, tmp, &annotation, arena);
6588              _Py_LeaveRecursiveCall();
6589              if (res != 0) goto failed;
6590              Py_CLEAR(tmp);
6591          }
6592          if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
6593              return 1;
6594          }
6595          if (tmp == NULL || tmp == Py_None) {
6596              Py_CLEAR(tmp);
6597              value = NULL;
6598          }
6599          else {
6600              int res;
6601              if (_Py_EnterRecursiveCall(" while traversing 'AnnAssign' node")) {
6602                  goto failed;
6603              }
6604              res = obj2ast_expr(state, tmp, &value, arena);
6605              _Py_LeaveRecursiveCall();
6606              if (res != 0) goto failed;
6607              Py_CLEAR(tmp);
6608          }
6609          if (_PyObject_LookupAttr(obj, state->simple, &tmp) < 0) {
6610              return 1;
6611          }
6612          if (tmp == NULL) {
6613              PyErr_SetString(PyExc_TypeError, "required field \"simple\" missing from AnnAssign");
6614              return 1;
6615          }
6616          else {
6617              int res;
6618              if (_Py_EnterRecursiveCall(" while traversing 'AnnAssign' node")) {
6619                  goto failed;
6620              }
6621              res = obj2ast_int(state, tmp, &simple, arena);
6622              _Py_LeaveRecursiveCall();
6623              if (res != 0) goto failed;
6624              Py_CLEAR(tmp);
6625          }
6626          *out = _PyAST_AnnAssign(target, annotation, value, simple, lineno,
6627                                  col_offset, end_lineno, end_col_offset, arena);
6628          if (*out == NULL) goto failed;
6629          return 0;
6630      }
6631      tp = state->For_type;
6632      isinstance = PyObject_IsInstance(obj, tp);
6633      if (isinstance == -1) {
6634          return 1;
6635      }
6636      if (isinstance) {
6637          expr_ty target;
6638          expr_ty iter;
6639          asdl_stmt_seq* body;
6640          asdl_stmt_seq* orelse;
6641          string type_comment;
6642  
6643          if (_PyObject_LookupAttr(obj, state->target, &tmp) < 0) {
6644              return 1;
6645          }
6646          if (tmp == NULL) {
6647              PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from For");
6648              return 1;
6649          }
6650          else {
6651              int res;
6652              if (_Py_EnterRecursiveCall(" while traversing 'For' node")) {
6653                  goto failed;
6654              }
6655              res = obj2ast_expr(state, tmp, &target, arena);
6656              _Py_LeaveRecursiveCall();
6657              if (res != 0) goto failed;
6658              Py_CLEAR(tmp);
6659          }
6660          if (_PyObject_LookupAttr(obj, state->iter, &tmp) < 0) {
6661              return 1;
6662          }
6663          if (tmp == NULL) {
6664              PyErr_SetString(PyExc_TypeError, "required field \"iter\" missing from For");
6665              return 1;
6666          }
6667          else {
6668              int res;
6669              if (_Py_EnterRecursiveCall(" while traversing 'For' node")) {
6670                  goto failed;
6671              }
6672              res = obj2ast_expr(state, tmp, &iter, arena);
6673              _Py_LeaveRecursiveCall();
6674              if (res != 0) goto failed;
6675              Py_CLEAR(tmp);
6676          }
6677          if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
6678              return 1;
6679          }
6680          if (tmp == NULL) {
6681              PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from For");
6682              return 1;
6683          }
6684          else {
6685              int res;
6686              Py_ssize_t len;
6687              Py_ssize_t i;
6688              if (!PyList_Check(tmp)) {
6689                  PyErr_Format(PyExc_TypeError, "For field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6690                  goto failed;
6691              }
6692              len = PyList_GET_SIZE(tmp);
6693              body = _Py_asdl_stmt_seq_new(len, arena);
6694              if (body == NULL) goto failed;
6695              for (i = 0; i < len; i++) {
6696                  stmt_ty val;
6697                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
6698                  Py_INCREF(tmp2);
6699                  if (_Py_EnterRecursiveCall(" while traversing 'For' node")) {
6700                      goto failed;
6701                  }
6702                  res = obj2ast_stmt(state, tmp2, &val, arena);
6703                  _Py_LeaveRecursiveCall();
6704                  Py_DECREF(tmp2);
6705                  if (res != 0) goto failed;
6706                  if (len != PyList_GET_SIZE(tmp)) {
6707                      PyErr_SetString(PyExc_RuntimeError, "For field \"body\" changed size during iteration");
6708                      goto failed;
6709                  }
6710                  asdl_seq_SET(body, i, val);
6711              }
6712              Py_CLEAR(tmp);
6713          }
6714          if (_PyObject_LookupAttr(obj, state->orelse, &tmp) < 0) {
6715              return 1;
6716          }
6717          if (tmp == NULL) {
6718              PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from For");
6719              return 1;
6720          }
6721          else {
6722              int res;
6723              Py_ssize_t len;
6724              Py_ssize_t i;
6725              if (!PyList_Check(tmp)) {
6726                  PyErr_Format(PyExc_TypeError, "For field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6727                  goto failed;
6728              }
6729              len = PyList_GET_SIZE(tmp);
6730              orelse = _Py_asdl_stmt_seq_new(len, arena);
6731              if (orelse == NULL) goto failed;
6732              for (i = 0; i < len; i++) {
6733                  stmt_ty val;
6734                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
6735                  Py_INCREF(tmp2);
6736                  if (_Py_EnterRecursiveCall(" while traversing 'For' node")) {
6737                      goto failed;
6738                  }
6739                  res = obj2ast_stmt(state, tmp2, &val, arena);
6740                  _Py_LeaveRecursiveCall();
6741                  Py_DECREF(tmp2);
6742                  if (res != 0) goto failed;
6743                  if (len != PyList_GET_SIZE(tmp)) {
6744                      PyErr_SetString(PyExc_RuntimeError, "For field \"orelse\" changed size during iteration");
6745                      goto failed;
6746                  }
6747                  asdl_seq_SET(orelse, i, val);
6748              }
6749              Py_CLEAR(tmp);
6750          }
6751          if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) {
6752              return 1;
6753          }
6754          if (tmp == NULL || tmp == Py_None) {
6755              Py_CLEAR(tmp);
6756              type_comment = NULL;
6757          }
6758          else {
6759              int res;
6760              if (_Py_EnterRecursiveCall(" while traversing 'For' node")) {
6761                  goto failed;
6762              }
6763              res = obj2ast_string(state, tmp, &type_comment, arena);
6764              _Py_LeaveRecursiveCall();
6765              if (res != 0) goto failed;
6766              Py_CLEAR(tmp);
6767          }
6768          *out = _PyAST_For(target, iter, body, orelse, type_comment, lineno,
6769                            col_offset, end_lineno, end_col_offset, arena);
6770          if (*out == NULL) goto failed;
6771          return 0;
6772      }
6773      tp = state->AsyncFor_type;
6774      isinstance = PyObject_IsInstance(obj, tp);
6775      if (isinstance == -1) {
6776          return 1;
6777      }
6778      if (isinstance) {
6779          expr_ty target;
6780          expr_ty iter;
6781          asdl_stmt_seq* body;
6782          asdl_stmt_seq* orelse;
6783          string type_comment;
6784  
6785          if (_PyObject_LookupAttr(obj, state->target, &tmp) < 0) {
6786              return 1;
6787          }
6788          if (tmp == NULL) {
6789              PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from AsyncFor");
6790              return 1;
6791          }
6792          else {
6793              int res;
6794              if (_Py_EnterRecursiveCall(" while traversing 'AsyncFor' node")) {
6795                  goto failed;
6796              }
6797              res = obj2ast_expr(state, tmp, &target, arena);
6798              _Py_LeaveRecursiveCall();
6799              if (res != 0) goto failed;
6800              Py_CLEAR(tmp);
6801          }
6802          if (_PyObject_LookupAttr(obj, state->iter, &tmp) < 0) {
6803              return 1;
6804          }
6805          if (tmp == NULL) {
6806              PyErr_SetString(PyExc_TypeError, "required field \"iter\" missing from AsyncFor");
6807              return 1;
6808          }
6809          else {
6810              int res;
6811              if (_Py_EnterRecursiveCall(" while traversing 'AsyncFor' node")) {
6812                  goto failed;
6813              }
6814              res = obj2ast_expr(state, tmp, &iter, arena);
6815              _Py_LeaveRecursiveCall();
6816              if (res != 0) goto failed;
6817              Py_CLEAR(tmp);
6818          }
6819          if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
6820              return 1;
6821          }
6822          if (tmp == NULL) {
6823              PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from AsyncFor");
6824              return 1;
6825          }
6826          else {
6827              int res;
6828              Py_ssize_t len;
6829              Py_ssize_t i;
6830              if (!PyList_Check(tmp)) {
6831                  PyErr_Format(PyExc_TypeError, "AsyncFor field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6832                  goto failed;
6833              }
6834              len = PyList_GET_SIZE(tmp);
6835              body = _Py_asdl_stmt_seq_new(len, arena);
6836              if (body == NULL) goto failed;
6837              for (i = 0; i < len; i++) {
6838                  stmt_ty val;
6839                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
6840                  Py_INCREF(tmp2);
6841                  if (_Py_EnterRecursiveCall(" while traversing 'AsyncFor' node")) {
6842                      goto failed;
6843                  }
6844                  res = obj2ast_stmt(state, tmp2, &val, arena);
6845                  _Py_LeaveRecursiveCall();
6846                  Py_DECREF(tmp2);
6847                  if (res != 0) goto failed;
6848                  if (len != PyList_GET_SIZE(tmp)) {
6849                      PyErr_SetString(PyExc_RuntimeError, "AsyncFor field \"body\" changed size during iteration");
6850                      goto failed;
6851                  }
6852                  asdl_seq_SET(body, i, val);
6853              }
6854              Py_CLEAR(tmp);
6855          }
6856          if (_PyObject_LookupAttr(obj, state->orelse, &tmp) < 0) {
6857              return 1;
6858          }
6859          if (tmp == NULL) {
6860              PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from AsyncFor");
6861              return 1;
6862          }
6863          else {
6864              int res;
6865              Py_ssize_t len;
6866              Py_ssize_t i;
6867              if (!PyList_Check(tmp)) {
6868                  PyErr_Format(PyExc_TypeError, "AsyncFor field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6869                  goto failed;
6870              }
6871              len = PyList_GET_SIZE(tmp);
6872              orelse = _Py_asdl_stmt_seq_new(len, arena);
6873              if (orelse == NULL) goto failed;
6874              for (i = 0; i < len; i++) {
6875                  stmt_ty val;
6876                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
6877                  Py_INCREF(tmp2);
6878                  if (_Py_EnterRecursiveCall(" while traversing 'AsyncFor' node")) {
6879                      goto failed;
6880                  }
6881                  res = obj2ast_stmt(state, tmp2, &val, arena);
6882                  _Py_LeaveRecursiveCall();
6883                  Py_DECREF(tmp2);
6884                  if (res != 0) goto failed;
6885                  if (len != PyList_GET_SIZE(tmp)) {
6886                      PyErr_SetString(PyExc_RuntimeError, "AsyncFor field \"orelse\" changed size during iteration");
6887                      goto failed;
6888                  }
6889                  asdl_seq_SET(orelse, i, val);
6890              }
6891              Py_CLEAR(tmp);
6892          }
6893          if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) {
6894              return 1;
6895          }
6896          if (tmp == NULL || tmp == Py_None) {
6897              Py_CLEAR(tmp);
6898              type_comment = NULL;
6899          }
6900          else {
6901              int res;
6902              if (_Py_EnterRecursiveCall(" while traversing 'AsyncFor' node")) {
6903                  goto failed;
6904              }
6905              res = obj2ast_string(state, tmp, &type_comment, arena);
6906              _Py_LeaveRecursiveCall();
6907              if (res != 0) goto failed;
6908              Py_CLEAR(tmp);
6909          }
6910          *out = _PyAST_AsyncFor(target, iter, body, orelse, type_comment,
6911                                 lineno, col_offset, end_lineno, end_col_offset,
6912                                 arena);
6913          if (*out == NULL) goto failed;
6914          return 0;
6915      }
6916      tp = state->While_type;
6917      isinstance = PyObject_IsInstance(obj, tp);
6918      if (isinstance == -1) {
6919          return 1;
6920      }
6921      if (isinstance) {
6922          expr_ty test;
6923          asdl_stmt_seq* body;
6924          asdl_stmt_seq* orelse;
6925  
6926          if (_PyObject_LookupAttr(obj, state->test, &tmp) < 0) {
6927              return 1;
6928          }
6929          if (tmp == NULL) {
6930              PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from While");
6931              return 1;
6932          }
6933          else {
6934              int res;
6935              if (_Py_EnterRecursiveCall(" while traversing 'While' node")) {
6936                  goto failed;
6937              }
6938              res = obj2ast_expr(state, tmp, &test, arena);
6939              _Py_LeaveRecursiveCall();
6940              if (res != 0) goto failed;
6941              Py_CLEAR(tmp);
6942          }
6943          if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
6944              return 1;
6945          }
6946          if (tmp == NULL) {
6947              PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from While");
6948              return 1;
6949          }
6950          else {
6951              int res;
6952              Py_ssize_t len;
6953              Py_ssize_t i;
6954              if (!PyList_Check(tmp)) {
6955                  PyErr_Format(PyExc_TypeError, "While field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6956                  goto failed;
6957              }
6958              len = PyList_GET_SIZE(tmp);
6959              body = _Py_asdl_stmt_seq_new(len, arena);
6960              if (body == NULL) goto failed;
6961              for (i = 0; i < len; i++) {
6962                  stmt_ty val;
6963                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
6964                  Py_INCREF(tmp2);
6965                  if (_Py_EnterRecursiveCall(" while traversing 'While' node")) {
6966                      goto failed;
6967                  }
6968                  res = obj2ast_stmt(state, tmp2, &val, arena);
6969                  _Py_LeaveRecursiveCall();
6970                  Py_DECREF(tmp2);
6971                  if (res != 0) goto failed;
6972                  if (len != PyList_GET_SIZE(tmp)) {
6973                      PyErr_SetString(PyExc_RuntimeError, "While field \"body\" changed size during iteration");
6974                      goto failed;
6975                  }
6976                  asdl_seq_SET(body, i, val);
6977              }
6978              Py_CLEAR(tmp);
6979          }
6980          if (_PyObject_LookupAttr(obj, state->orelse, &tmp) < 0) {
6981              return 1;
6982          }
6983          if (tmp == NULL) {
6984              PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from While");
6985              return 1;
6986          }
6987          else {
6988              int res;
6989              Py_ssize_t len;
6990              Py_ssize_t i;
6991              if (!PyList_Check(tmp)) {
6992                  PyErr_Format(PyExc_TypeError, "While field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
6993                  goto failed;
6994              }
6995              len = PyList_GET_SIZE(tmp);
6996              orelse = _Py_asdl_stmt_seq_new(len, arena);
6997              if (orelse == NULL) goto failed;
6998              for (i = 0; i < len; i++) {
6999                  stmt_ty val;
7000                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7001                  Py_INCREF(tmp2);
7002                  if (_Py_EnterRecursiveCall(" while traversing 'While' node")) {
7003                      goto failed;
7004                  }
7005                  res = obj2ast_stmt(state, tmp2, &val, arena);
7006                  _Py_LeaveRecursiveCall();
7007                  Py_DECREF(tmp2);
7008                  if (res != 0) goto failed;
7009                  if (len != PyList_GET_SIZE(tmp)) {
7010                      PyErr_SetString(PyExc_RuntimeError, "While field \"orelse\" changed size during iteration");
7011                      goto failed;
7012                  }
7013                  asdl_seq_SET(orelse, i, val);
7014              }
7015              Py_CLEAR(tmp);
7016          }
7017          *out = _PyAST_While(test, body, orelse, lineno, col_offset, end_lineno,
7018                              end_col_offset, arena);
7019          if (*out == NULL) goto failed;
7020          return 0;
7021      }
7022      tp = state->If_type;
7023      isinstance = PyObject_IsInstance(obj, tp);
7024      if (isinstance == -1) {
7025          return 1;
7026      }
7027      if (isinstance) {
7028          expr_ty test;
7029          asdl_stmt_seq* body;
7030          asdl_stmt_seq* orelse;
7031  
7032          if (_PyObject_LookupAttr(obj, state->test, &tmp) < 0) {
7033              return 1;
7034          }
7035          if (tmp == NULL) {
7036              PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from If");
7037              return 1;
7038          }
7039          else {
7040              int res;
7041              if (_Py_EnterRecursiveCall(" while traversing 'If' node")) {
7042                  goto failed;
7043              }
7044              res = obj2ast_expr(state, tmp, &test, arena);
7045              _Py_LeaveRecursiveCall();
7046              if (res != 0) goto failed;
7047              Py_CLEAR(tmp);
7048          }
7049          if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
7050              return 1;
7051          }
7052          if (tmp == NULL) {
7053              PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from If");
7054              return 1;
7055          }
7056          else {
7057              int res;
7058              Py_ssize_t len;
7059              Py_ssize_t i;
7060              if (!PyList_Check(tmp)) {
7061                  PyErr_Format(PyExc_TypeError, "If field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7062                  goto failed;
7063              }
7064              len = PyList_GET_SIZE(tmp);
7065              body = _Py_asdl_stmt_seq_new(len, arena);
7066              if (body == NULL) goto failed;
7067              for (i = 0; i < len; i++) {
7068                  stmt_ty val;
7069                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7070                  Py_INCREF(tmp2);
7071                  if (_Py_EnterRecursiveCall(" while traversing 'If' node")) {
7072                      goto failed;
7073                  }
7074                  res = obj2ast_stmt(state, tmp2, &val, arena);
7075                  _Py_LeaveRecursiveCall();
7076                  Py_DECREF(tmp2);
7077                  if (res != 0) goto failed;
7078                  if (len != PyList_GET_SIZE(tmp)) {
7079                      PyErr_SetString(PyExc_RuntimeError, "If field \"body\" changed size during iteration");
7080                      goto failed;
7081                  }
7082                  asdl_seq_SET(body, i, val);
7083              }
7084              Py_CLEAR(tmp);
7085          }
7086          if (_PyObject_LookupAttr(obj, state->orelse, &tmp) < 0) {
7087              return 1;
7088          }
7089          if (tmp == NULL) {
7090              PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from If");
7091              return 1;
7092          }
7093          else {
7094              int res;
7095              Py_ssize_t len;
7096              Py_ssize_t i;
7097              if (!PyList_Check(tmp)) {
7098                  PyErr_Format(PyExc_TypeError, "If field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7099                  goto failed;
7100              }
7101              len = PyList_GET_SIZE(tmp);
7102              orelse = _Py_asdl_stmt_seq_new(len, arena);
7103              if (orelse == NULL) goto failed;
7104              for (i = 0; i < len; i++) {
7105                  stmt_ty val;
7106                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7107                  Py_INCREF(tmp2);
7108                  if (_Py_EnterRecursiveCall(" while traversing 'If' node")) {
7109                      goto failed;
7110                  }
7111                  res = obj2ast_stmt(state, tmp2, &val, arena);
7112                  _Py_LeaveRecursiveCall();
7113                  Py_DECREF(tmp2);
7114                  if (res != 0) goto failed;
7115                  if (len != PyList_GET_SIZE(tmp)) {
7116                      PyErr_SetString(PyExc_RuntimeError, "If field \"orelse\" changed size during iteration");
7117                      goto failed;
7118                  }
7119                  asdl_seq_SET(orelse, i, val);
7120              }
7121              Py_CLEAR(tmp);
7122          }
7123          *out = _PyAST_If(test, body, orelse, lineno, col_offset, end_lineno,
7124                           end_col_offset, arena);
7125          if (*out == NULL) goto failed;
7126          return 0;
7127      }
7128      tp = state->With_type;
7129      isinstance = PyObject_IsInstance(obj, tp);
7130      if (isinstance == -1) {
7131          return 1;
7132      }
7133      if (isinstance) {
7134          asdl_withitem_seq* items;
7135          asdl_stmt_seq* body;
7136          string type_comment;
7137  
7138          if (_PyObject_LookupAttr(obj, state->items, &tmp) < 0) {
7139              return 1;
7140          }
7141          if (tmp == NULL) {
7142              PyErr_SetString(PyExc_TypeError, "required field \"items\" missing from With");
7143              return 1;
7144          }
7145          else {
7146              int res;
7147              Py_ssize_t len;
7148              Py_ssize_t i;
7149              if (!PyList_Check(tmp)) {
7150                  PyErr_Format(PyExc_TypeError, "With field \"items\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7151                  goto failed;
7152              }
7153              len = PyList_GET_SIZE(tmp);
7154              items = _Py_asdl_withitem_seq_new(len, arena);
7155              if (items == NULL) goto failed;
7156              for (i = 0; i < len; i++) {
7157                  withitem_ty val;
7158                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7159                  Py_INCREF(tmp2);
7160                  if (_Py_EnterRecursiveCall(" while traversing 'With' node")) {
7161                      goto failed;
7162                  }
7163                  res = obj2ast_withitem(state, tmp2, &val, arena);
7164                  _Py_LeaveRecursiveCall();
7165                  Py_DECREF(tmp2);
7166                  if (res != 0) goto failed;
7167                  if (len != PyList_GET_SIZE(tmp)) {
7168                      PyErr_SetString(PyExc_RuntimeError, "With field \"items\" changed size during iteration");
7169                      goto failed;
7170                  }
7171                  asdl_seq_SET(items, i, val);
7172              }
7173              Py_CLEAR(tmp);
7174          }
7175          if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
7176              return 1;
7177          }
7178          if (tmp == NULL) {
7179              PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from With");
7180              return 1;
7181          }
7182          else {
7183              int res;
7184              Py_ssize_t len;
7185              Py_ssize_t i;
7186              if (!PyList_Check(tmp)) {
7187                  PyErr_Format(PyExc_TypeError, "With field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7188                  goto failed;
7189              }
7190              len = PyList_GET_SIZE(tmp);
7191              body = _Py_asdl_stmt_seq_new(len, arena);
7192              if (body == NULL) goto failed;
7193              for (i = 0; i < len; i++) {
7194                  stmt_ty val;
7195                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7196                  Py_INCREF(tmp2);
7197                  if (_Py_EnterRecursiveCall(" while traversing 'With' node")) {
7198                      goto failed;
7199                  }
7200                  res = obj2ast_stmt(state, tmp2, &val, arena);
7201                  _Py_LeaveRecursiveCall();
7202                  Py_DECREF(tmp2);
7203                  if (res != 0) goto failed;
7204                  if (len != PyList_GET_SIZE(tmp)) {
7205                      PyErr_SetString(PyExc_RuntimeError, "With field \"body\" changed size during iteration");
7206                      goto failed;
7207                  }
7208                  asdl_seq_SET(body, i, val);
7209              }
7210              Py_CLEAR(tmp);
7211          }
7212          if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) {
7213              return 1;
7214          }
7215          if (tmp == NULL || tmp == Py_None) {
7216              Py_CLEAR(tmp);
7217              type_comment = NULL;
7218          }
7219          else {
7220              int res;
7221              if (_Py_EnterRecursiveCall(" while traversing 'With' node")) {
7222                  goto failed;
7223              }
7224              res = obj2ast_string(state, tmp, &type_comment, arena);
7225              _Py_LeaveRecursiveCall();
7226              if (res != 0) goto failed;
7227              Py_CLEAR(tmp);
7228          }
7229          *out = _PyAST_With(items, body, type_comment, lineno, col_offset,
7230                             end_lineno, end_col_offset, arena);
7231          if (*out == NULL) goto failed;
7232          return 0;
7233      }
7234      tp = state->AsyncWith_type;
7235      isinstance = PyObject_IsInstance(obj, tp);
7236      if (isinstance == -1) {
7237          return 1;
7238      }
7239      if (isinstance) {
7240          asdl_withitem_seq* items;
7241          asdl_stmt_seq* body;
7242          string type_comment;
7243  
7244          if (_PyObject_LookupAttr(obj, state->items, &tmp) < 0) {
7245              return 1;
7246          }
7247          if (tmp == NULL) {
7248              PyErr_SetString(PyExc_TypeError, "required field \"items\" missing from AsyncWith");
7249              return 1;
7250          }
7251          else {
7252              int res;
7253              Py_ssize_t len;
7254              Py_ssize_t i;
7255              if (!PyList_Check(tmp)) {
7256                  PyErr_Format(PyExc_TypeError, "AsyncWith field \"items\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7257                  goto failed;
7258              }
7259              len = PyList_GET_SIZE(tmp);
7260              items = _Py_asdl_withitem_seq_new(len, arena);
7261              if (items == NULL) goto failed;
7262              for (i = 0; i < len; i++) {
7263                  withitem_ty val;
7264                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7265                  Py_INCREF(tmp2);
7266                  if (_Py_EnterRecursiveCall(" while traversing 'AsyncWith' node")) {
7267                      goto failed;
7268                  }
7269                  res = obj2ast_withitem(state, tmp2, &val, arena);
7270                  _Py_LeaveRecursiveCall();
7271                  Py_DECREF(tmp2);
7272                  if (res != 0) goto failed;
7273                  if (len != PyList_GET_SIZE(tmp)) {
7274                      PyErr_SetString(PyExc_RuntimeError, "AsyncWith field \"items\" changed size during iteration");
7275                      goto failed;
7276                  }
7277                  asdl_seq_SET(items, i, val);
7278              }
7279              Py_CLEAR(tmp);
7280          }
7281          if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
7282              return 1;
7283          }
7284          if (tmp == NULL) {
7285              PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from AsyncWith");
7286              return 1;
7287          }
7288          else {
7289              int res;
7290              Py_ssize_t len;
7291              Py_ssize_t i;
7292              if (!PyList_Check(tmp)) {
7293                  PyErr_Format(PyExc_TypeError, "AsyncWith field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7294                  goto failed;
7295              }
7296              len = PyList_GET_SIZE(tmp);
7297              body = _Py_asdl_stmt_seq_new(len, arena);
7298              if (body == NULL) goto failed;
7299              for (i = 0; i < len; i++) {
7300                  stmt_ty val;
7301                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7302                  Py_INCREF(tmp2);
7303                  if (_Py_EnterRecursiveCall(" while traversing 'AsyncWith' node")) {
7304                      goto failed;
7305                  }
7306                  res = obj2ast_stmt(state, tmp2, &val, arena);
7307                  _Py_LeaveRecursiveCall();
7308                  Py_DECREF(tmp2);
7309                  if (res != 0) goto failed;
7310                  if (len != PyList_GET_SIZE(tmp)) {
7311                      PyErr_SetString(PyExc_RuntimeError, "AsyncWith field \"body\" changed size during iteration");
7312                      goto failed;
7313                  }
7314                  asdl_seq_SET(body, i, val);
7315              }
7316              Py_CLEAR(tmp);
7317          }
7318          if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) {
7319              return 1;
7320          }
7321          if (tmp == NULL || tmp == Py_None) {
7322              Py_CLEAR(tmp);
7323              type_comment = NULL;
7324          }
7325          else {
7326              int res;
7327              if (_Py_EnterRecursiveCall(" while traversing 'AsyncWith' node")) {
7328                  goto failed;
7329              }
7330              res = obj2ast_string(state, tmp, &type_comment, arena);
7331              _Py_LeaveRecursiveCall();
7332              if (res != 0) goto failed;
7333              Py_CLEAR(tmp);
7334          }
7335          *out = _PyAST_AsyncWith(items, body, type_comment, lineno, col_offset,
7336                                  end_lineno, end_col_offset, arena);
7337          if (*out == NULL) goto failed;
7338          return 0;
7339      }
7340      tp = state->Match_type;
7341      isinstance = PyObject_IsInstance(obj, tp);
7342      if (isinstance == -1) {
7343          return 1;
7344      }
7345      if (isinstance) {
7346          expr_ty subject;
7347          asdl_match_case_seq* cases;
7348  
7349          if (_PyObject_LookupAttr(obj, state->subject, &tmp) < 0) {
7350              return 1;
7351          }
7352          if (tmp == NULL) {
7353              PyErr_SetString(PyExc_TypeError, "required field \"subject\" missing from Match");
7354              return 1;
7355          }
7356          else {
7357              int res;
7358              if (_Py_EnterRecursiveCall(" while traversing 'Match' node")) {
7359                  goto failed;
7360              }
7361              res = obj2ast_expr(state, tmp, &subject, arena);
7362              _Py_LeaveRecursiveCall();
7363              if (res != 0) goto failed;
7364              Py_CLEAR(tmp);
7365          }
7366          if (_PyObject_LookupAttr(obj, state->cases, &tmp) < 0) {
7367              return 1;
7368          }
7369          if (tmp == NULL) {
7370              PyErr_SetString(PyExc_TypeError, "required field \"cases\" missing from Match");
7371              return 1;
7372          }
7373          else {
7374              int res;
7375              Py_ssize_t len;
7376              Py_ssize_t i;
7377              if (!PyList_Check(tmp)) {
7378                  PyErr_Format(PyExc_TypeError, "Match field \"cases\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7379                  goto failed;
7380              }
7381              len = PyList_GET_SIZE(tmp);
7382              cases = _Py_asdl_match_case_seq_new(len, arena);
7383              if (cases == NULL) goto failed;
7384              for (i = 0; i < len; i++) {
7385                  match_case_ty val;
7386                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7387                  Py_INCREF(tmp2);
7388                  if (_Py_EnterRecursiveCall(" while traversing 'Match' node")) {
7389                      goto failed;
7390                  }
7391                  res = obj2ast_match_case(state, tmp2, &val, arena);
7392                  _Py_LeaveRecursiveCall();
7393                  Py_DECREF(tmp2);
7394                  if (res != 0) goto failed;
7395                  if (len != PyList_GET_SIZE(tmp)) {
7396                      PyErr_SetString(PyExc_RuntimeError, "Match field \"cases\" changed size during iteration");
7397                      goto failed;
7398                  }
7399                  asdl_seq_SET(cases, i, val);
7400              }
7401              Py_CLEAR(tmp);
7402          }
7403          *out = _PyAST_Match(subject, cases, lineno, col_offset, end_lineno,
7404                              end_col_offset, arena);
7405          if (*out == NULL) goto failed;
7406          return 0;
7407      }
7408      tp = state->Raise_type;
7409      isinstance = PyObject_IsInstance(obj, tp);
7410      if (isinstance == -1) {
7411          return 1;
7412      }
7413      if (isinstance) {
7414          expr_ty exc;
7415          expr_ty cause;
7416  
7417          if (_PyObject_LookupAttr(obj, state->exc, &tmp) < 0) {
7418              return 1;
7419          }
7420          if (tmp == NULL || tmp == Py_None) {
7421              Py_CLEAR(tmp);
7422              exc = NULL;
7423          }
7424          else {
7425              int res;
7426              if (_Py_EnterRecursiveCall(" while traversing 'Raise' node")) {
7427                  goto failed;
7428              }
7429              res = obj2ast_expr(state, tmp, &exc, arena);
7430              _Py_LeaveRecursiveCall();
7431              if (res != 0) goto failed;
7432              Py_CLEAR(tmp);
7433          }
7434          if (_PyObject_LookupAttr(obj, state->cause, &tmp) < 0) {
7435              return 1;
7436          }
7437          if (tmp == NULL || tmp == Py_None) {
7438              Py_CLEAR(tmp);
7439              cause = NULL;
7440          }
7441          else {
7442              int res;
7443              if (_Py_EnterRecursiveCall(" while traversing 'Raise' node")) {
7444                  goto failed;
7445              }
7446              res = obj2ast_expr(state, tmp, &cause, arena);
7447              _Py_LeaveRecursiveCall();
7448              if (res != 0) goto failed;
7449              Py_CLEAR(tmp);
7450          }
7451          *out = _PyAST_Raise(exc, cause, lineno, col_offset, end_lineno,
7452                              end_col_offset, arena);
7453          if (*out == NULL) goto failed;
7454          return 0;
7455      }
7456      tp = state->Try_type;
7457      isinstance = PyObject_IsInstance(obj, tp);
7458      if (isinstance == -1) {
7459          return 1;
7460      }
7461      if (isinstance) {
7462          asdl_stmt_seq* body;
7463          asdl_excepthandler_seq* handlers;
7464          asdl_stmt_seq* orelse;
7465          asdl_stmt_seq* finalbody;
7466  
7467          if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
7468              return 1;
7469          }
7470          if (tmp == NULL) {
7471              PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Try");
7472              return 1;
7473          }
7474          else {
7475              int res;
7476              Py_ssize_t len;
7477              Py_ssize_t i;
7478              if (!PyList_Check(tmp)) {
7479                  PyErr_Format(PyExc_TypeError, "Try field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7480                  goto failed;
7481              }
7482              len = PyList_GET_SIZE(tmp);
7483              body = _Py_asdl_stmt_seq_new(len, arena);
7484              if (body == NULL) goto failed;
7485              for (i = 0; i < len; i++) {
7486                  stmt_ty val;
7487                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7488                  Py_INCREF(tmp2);
7489                  if (_Py_EnterRecursiveCall(" while traversing 'Try' node")) {
7490                      goto failed;
7491                  }
7492                  res = obj2ast_stmt(state, tmp2, &val, arena);
7493                  _Py_LeaveRecursiveCall();
7494                  Py_DECREF(tmp2);
7495                  if (res != 0) goto failed;
7496                  if (len != PyList_GET_SIZE(tmp)) {
7497                      PyErr_SetString(PyExc_RuntimeError, "Try field \"body\" changed size during iteration");
7498                      goto failed;
7499                  }
7500                  asdl_seq_SET(body, i, val);
7501              }
7502              Py_CLEAR(tmp);
7503          }
7504          if (_PyObject_LookupAttr(obj, state->handlers, &tmp) < 0) {
7505              return 1;
7506          }
7507          if (tmp == NULL) {
7508              PyErr_SetString(PyExc_TypeError, "required field \"handlers\" missing from Try");
7509              return 1;
7510          }
7511          else {
7512              int res;
7513              Py_ssize_t len;
7514              Py_ssize_t i;
7515              if (!PyList_Check(tmp)) {
7516                  PyErr_Format(PyExc_TypeError, "Try field \"handlers\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7517                  goto failed;
7518              }
7519              len = PyList_GET_SIZE(tmp);
7520              handlers = _Py_asdl_excepthandler_seq_new(len, arena);
7521              if (handlers == NULL) goto failed;
7522              for (i = 0; i < len; i++) {
7523                  excepthandler_ty val;
7524                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7525                  Py_INCREF(tmp2);
7526                  if (_Py_EnterRecursiveCall(" while traversing 'Try' node")) {
7527                      goto failed;
7528                  }
7529                  res = obj2ast_excepthandler(state, tmp2, &val, arena);
7530                  _Py_LeaveRecursiveCall();
7531                  Py_DECREF(tmp2);
7532                  if (res != 0) goto failed;
7533                  if (len != PyList_GET_SIZE(tmp)) {
7534                      PyErr_SetString(PyExc_RuntimeError, "Try field \"handlers\" changed size during iteration");
7535                      goto failed;
7536                  }
7537                  asdl_seq_SET(handlers, i, val);
7538              }
7539              Py_CLEAR(tmp);
7540          }
7541          if (_PyObject_LookupAttr(obj, state->orelse, &tmp) < 0) {
7542              return 1;
7543          }
7544          if (tmp == NULL) {
7545              PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from Try");
7546              return 1;
7547          }
7548          else {
7549              int res;
7550              Py_ssize_t len;
7551              Py_ssize_t i;
7552              if (!PyList_Check(tmp)) {
7553                  PyErr_Format(PyExc_TypeError, "Try field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7554                  goto failed;
7555              }
7556              len = PyList_GET_SIZE(tmp);
7557              orelse = _Py_asdl_stmt_seq_new(len, arena);
7558              if (orelse == NULL) goto failed;
7559              for (i = 0; i < len; i++) {
7560                  stmt_ty val;
7561                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7562                  Py_INCREF(tmp2);
7563                  if (_Py_EnterRecursiveCall(" while traversing 'Try' node")) {
7564                      goto failed;
7565                  }
7566                  res = obj2ast_stmt(state, tmp2, &val, arena);
7567                  _Py_LeaveRecursiveCall();
7568                  Py_DECREF(tmp2);
7569                  if (res != 0) goto failed;
7570                  if (len != PyList_GET_SIZE(tmp)) {
7571                      PyErr_SetString(PyExc_RuntimeError, "Try field \"orelse\" changed size during iteration");
7572                      goto failed;
7573                  }
7574                  asdl_seq_SET(orelse, i, val);
7575              }
7576              Py_CLEAR(tmp);
7577          }
7578          if (_PyObject_LookupAttr(obj, state->finalbody, &tmp) < 0) {
7579              return 1;
7580          }
7581          if (tmp == NULL) {
7582              PyErr_SetString(PyExc_TypeError, "required field \"finalbody\" missing from Try");
7583              return 1;
7584          }
7585          else {
7586              int res;
7587              Py_ssize_t len;
7588              Py_ssize_t i;
7589              if (!PyList_Check(tmp)) {
7590                  PyErr_Format(PyExc_TypeError, "Try field \"finalbody\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7591                  goto failed;
7592              }
7593              len = PyList_GET_SIZE(tmp);
7594              finalbody = _Py_asdl_stmt_seq_new(len, arena);
7595              if (finalbody == NULL) goto failed;
7596              for (i = 0; i < len; i++) {
7597                  stmt_ty val;
7598                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7599                  Py_INCREF(tmp2);
7600                  if (_Py_EnterRecursiveCall(" while traversing 'Try' node")) {
7601                      goto failed;
7602                  }
7603                  res = obj2ast_stmt(state, tmp2, &val, arena);
7604                  _Py_LeaveRecursiveCall();
7605                  Py_DECREF(tmp2);
7606                  if (res != 0) goto failed;
7607                  if (len != PyList_GET_SIZE(tmp)) {
7608                      PyErr_SetString(PyExc_RuntimeError, "Try field \"finalbody\" changed size during iteration");
7609                      goto failed;
7610                  }
7611                  asdl_seq_SET(finalbody, i, val);
7612              }
7613              Py_CLEAR(tmp);
7614          }
7615          *out = _PyAST_Try(body, handlers, orelse, finalbody, lineno,
7616                            col_offset, end_lineno, end_col_offset, arena);
7617          if (*out == NULL) goto failed;
7618          return 0;
7619      }
7620      tp = state->TryStar_type;
7621      isinstance = PyObject_IsInstance(obj, tp);
7622      if (isinstance == -1) {
7623          return 1;
7624      }
7625      if (isinstance) {
7626          asdl_stmt_seq* body;
7627          asdl_excepthandler_seq* handlers;
7628          asdl_stmt_seq* orelse;
7629          asdl_stmt_seq* finalbody;
7630  
7631          if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
7632              return 1;
7633          }
7634          if (tmp == NULL) {
7635              PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from TryStar");
7636              return 1;
7637          }
7638          else {
7639              int res;
7640              Py_ssize_t len;
7641              Py_ssize_t i;
7642              if (!PyList_Check(tmp)) {
7643                  PyErr_Format(PyExc_TypeError, "TryStar field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7644                  goto failed;
7645              }
7646              len = PyList_GET_SIZE(tmp);
7647              body = _Py_asdl_stmt_seq_new(len, arena);
7648              if (body == NULL) goto failed;
7649              for (i = 0; i < len; i++) {
7650                  stmt_ty val;
7651                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7652                  Py_INCREF(tmp2);
7653                  if (_Py_EnterRecursiveCall(" while traversing 'TryStar' node")) {
7654                      goto failed;
7655                  }
7656                  res = obj2ast_stmt(state, tmp2, &val, arena);
7657                  _Py_LeaveRecursiveCall();
7658                  Py_DECREF(tmp2);
7659                  if (res != 0) goto failed;
7660                  if (len != PyList_GET_SIZE(tmp)) {
7661                      PyErr_SetString(PyExc_RuntimeError, "TryStar field \"body\" changed size during iteration");
7662                      goto failed;
7663                  }
7664                  asdl_seq_SET(body, i, val);
7665              }
7666              Py_CLEAR(tmp);
7667          }
7668          if (_PyObject_LookupAttr(obj, state->handlers, &tmp) < 0) {
7669              return 1;
7670          }
7671          if (tmp == NULL) {
7672              PyErr_SetString(PyExc_TypeError, "required field \"handlers\" missing from TryStar");
7673              return 1;
7674          }
7675          else {
7676              int res;
7677              Py_ssize_t len;
7678              Py_ssize_t i;
7679              if (!PyList_Check(tmp)) {
7680                  PyErr_Format(PyExc_TypeError, "TryStar field \"handlers\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7681                  goto failed;
7682              }
7683              len = PyList_GET_SIZE(tmp);
7684              handlers = _Py_asdl_excepthandler_seq_new(len, arena);
7685              if (handlers == NULL) goto failed;
7686              for (i = 0; i < len; i++) {
7687                  excepthandler_ty val;
7688                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7689                  Py_INCREF(tmp2);
7690                  if (_Py_EnterRecursiveCall(" while traversing 'TryStar' node")) {
7691                      goto failed;
7692                  }
7693                  res = obj2ast_excepthandler(state, tmp2, &val, arena);
7694                  _Py_LeaveRecursiveCall();
7695                  Py_DECREF(tmp2);
7696                  if (res != 0) goto failed;
7697                  if (len != PyList_GET_SIZE(tmp)) {
7698                      PyErr_SetString(PyExc_RuntimeError, "TryStar field \"handlers\" changed size during iteration");
7699                      goto failed;
7700                  }
7701                  asdl_seq_SET(handlers, i, val);
7702              }
7703              Py_CLEAR(tmp);
7704          }
7705          if (_PyObject_LookupAttr(obj, state->orelse, &tmp) < 0) {
7706              return 1;
7707          }
7708          if (tmp == NULL) {
7709              PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from TryStar");
7710              return 1;
7711          }
7712          else {
7713              int res;
7714              Py_ssize_t len;
7715              Py_ssize_t i;
7716              if (!PyList_Check(tmp)) {
7717                  PyErr_Format(PyExc_TypeError, "TryStar field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7718                  goto failed;
7719              }
7720              len = PyList_GET_SIZE(tmp);
7721              orelse = _Py_asdl_stmt_seq_new(len, arena);
7722              if (orelse == NULL) goto failed;
7723              for (i = 0; i < len; i++) {
7724                  stmt_ty val;
7725                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7726                  Py_INCREF(tmp2);
7727                  if (_Py_EnterRecursiveCall(" while traversing 'TryStar' node")) {
7728                      goto failed;
7729                  }
7730                  res = obj2ast_stmt(state, tmp2, &val, arena);
7731                  _Py_LeaveRecursiveCall();
7732                  Py_DECREF(tmp2);
7733                  if (res != 0) goto failed;
7734                  if (len != PyList_GET_SIZE(tmp)) {
7735                      PyErr_SetString(PyExc_RuntimeError, "TryStar field \"orelse\" changed size during iteration");
7736                      goto failed;
7737                  }
7738                  asdl_seq_SET(orelse, i, val);
7739              }
7740              Py_CLEAR(tmp);
7741          }
7742          if (_PyObject_LookupAttr(obj, state->finalbody, &tmp) < 0) {
7743              return 1;
7744          }
7745          if (tmp == NULL) {
7746              PyErr_SetString(PyExc_TypeError, "required field \"finalbody\" missing from TryStar");
7747              return 1;
7748          }
7749          else {
7750              int res;
7751              Py_ssize_t len;
7752              Py_ssize_t i;
7753              if (!PyList_Check(tmp)) {
7754                  PyErr_Format(PyExc_TypeError, "TryStar field \"finalbody\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7755                  goto failed;
7756              }
7757              len = PyList_GET_SIZE(tmp);
7758              finalbody = _Py_asdl_stmt_seq_new(len, arena);
7759              if (finalbody == NULL) goto failed;
7760              for (i = 0; i < len; i++) {
7761                  stmt_ty val;
7762                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7763                  Py_INCREF(tmp2);
7764                  if (_Py_EnterRecursiveCall(" while traversing 'TryStar' node")) {
7765                      goto failed;
7766                  }
7767                  res = obj2ast_stmt(state, tmp2, &val, arena);
7768                  _Py_LeaveRecursiveCall();
7769                  Py_DECREF(tmp2);
7770                  if (res != 0) goto failed;
7771                  if (len != PyList_GET_SIZE(tmp)) {
7772                      PyErr_SetString(PyExc_RuntimeError, "TryStar field \"finalbody\" changed size during iteration");
7773                      goto failed;
7774                  }
7775                  asdl_seq_SET(finalbody, i, val);
7776              }
7777              Py_CLEAR(tmp);
7778          }
7779          *out = _PyAST_TryStar(body, handlers, orelse, finalbody, lineno,
7780                                col_offset, end_lineno, end_col_offset, arena);
7781          if (*out == NULL) goto failed;
7782          return 0;
7783      }
7784      tp = state->Assert_type;
7785      isinstance = PyObject_IsInstance(obj, tp);
7786      if (isinstance == -1) {
7787          return 1;
7788      }
7789      if (isinstance) {
7790          expr_ty test;
7791          expr_ty msg;
7792  
7793          if (_PyObject_LookupAttr(obj, state->test, &tmp) < 0) {
7794              return 1;
7795          }
7796          if (tmp == NULL) {
7797              PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from Assert");
7798              return 1;
7799          }
7800          else {
7801              int res;
7802              if (_Py_EnterRecursiveCall(" while traversing 'Assert' node")) {
7803                  goto failed;
7804              }
7805              res = obj2ast_expr(state, tmp, &test, arena);
7806              _Py_LeaveRecursiveCall();
7807              if (res != 0) goto failed;
7808              Py_CLEAR(tmp);
7809          }
7810          if (_PyObject_LookupAttr(obj, state->msg, &tmp) < 0) {
7811              return 1;
7812          }
7813          if (tmp == NULL || tmp == Py_None) {
7814              Py_CLEAR(tmp);
7815              msg = NULL;
7816          }
7817          else {
7818              int res;
7819              if (_Py_EnterRecursiveCall(" while traversing 'Assert' node")) {
7820                  goto failed;
7821              }
7822              res = obj2ast_expr(state, tmp, &msg, arena);
7823              _Py_LeaveRecursiveCall();
7824              if (res != 0) goto failed;
7825              Py_CLEAR(tmp);
7826          }
7827          *out = _PyAST_Assert(test, msg, lineno, col_offset, end_lineno,
7828                               end_col_offset, arena);
7829          if (*out == NULL) goto failed;
7830          return 0;
7831      }
7832      tp = state->Import_type;
7833      isinstance = PyObject_IsInstance(obj, tp);
7834      if (isinstance == -1) {
7835          return 1;
7836      }
7837      if (isinstance) {
7838          asdl_alias_seq* names;
7839  
7840          if (_PyObject_LookupAttr(obj, state->names, &tmp) < 0) {
7841              return 1;
7842          }
7843          if (tmp == NULL) {
7844              PyErr_SetString(PyExc_TypeError, "required field \"names\" missing from Import");
7845              return 1;
7846          }
7847          else {
7848              int res;
7849              Py_ssize_t len;
7850              Py_ssize_t i;
7851              if (!PyList_Check(tmp)) {
7852                  PyErr_Format(PyExc_TypeError, "Import field \"names\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7853                  goto failed;
7854              }
7855              len = PyList_GET_SIZE(tmp);
7856              names = _Py_asdl_alias_seq_new(len, arena);
7857              if (names == NULL) goto failed;
7858              for (i = 0; i < len; i++) {
7859                  alias_ty val;
7860                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7861                  Py_INCREF(tmp2);
7862                  if (_Py_EnterRecursiveCall(" while traversing 'Import' node")) {
7863                      goto failed;
7864                  }
7865                  res = obj2ast_alias(state, tmp2, &val, arena);
7866                  _Py_LeaveRecursiveCall();
7867                  Py_DECREF(tmp2);
7868                  if (res != 0) goto failed;
7869                  if (len != PyList_GET_SIZE(tmp)) {
7870                      PyErr_SetString(PyExc_RuntimeError, "Import field \"names\" changed size during iteration");
7871                      goto failed;
7872                  }
7873                  asdl_seq_SET(names, i, val);
7874              }
7875              Py_CLEAR(tmp);
7876          }
7877          *out = _PyAST_Import(names, lineno, col_offset, end_lineno,
7878                               end_col_offset, arena);
7879          if (*out == NULL) goto failed;
7880          return 0;
7881      }
7882      tp = state->ImportFrom_type;
7883      isinstance = PyObject_IsInstance(obj, tp);
7884      if (isinstance == -1) {
7885          return 1;
7886      }
7887      if (isinstance) {
7888          identifier module;
7889          asdl_alias_seq* names;
7890          int level;
7891  
7892          if (_PyObject_LookupAttr(obj, state->module, &tmp) < 0) {
7893              return 1;
7894          }
7895          if (tmp == NULL || tmp == Py_None) {
7896              Py_CLEAR(tmp);
7897              module = NULL;
7898          }
7899          else {
7900              int res;
7901              if (_Py_EnterRecursiveCall(" while traversing 'ImportFrom' node")) {
7902                  goto failed;
7903              }
7904              res = obj2ast_identifier(state, tmp, &module, arena);
7905              _Py_LeaveRecursiveCall();
7906              if (res != 0) goto failed;
7907              Py_CLEAR(tmp);
7908          }
7909          if (_PyObject_LookupAttr(obj, state->names, &tmp) < 0) {
7910              return 1;
7911          }
7912          if (tmp == NULL) {
7913              PyErr_SetString(PyExc_TypeError, "required field \"names\" missing from ImportFrom");
7914              return 1;
7915          }
7916          else {
7917              int res;
7918              Py_ssize_t len;
7919              Py_ssize_t i;
7920              if (!PyList_Check(tmp)) {
7921                  PyErr_Format(PyExc_TypeError, "ImportFrom field \"names\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7922                  goto failed;
7923              }
7924              len = PyList_GET_SIZE(tmp);
7925              names = _Py_asdl_alias_seq_new(len, arena);
7926              if (names == NULL) goto failed;
7927              for (i = 0; i < len; i++) {
7928                  alias_ty val;
7929                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7930                  Py_INCREF(tmp2);
7931                  if (_Py_EnterRecursiveCall(" while traversing 'ImportFrom' node")) {
7932                      goto failed;
7933                  }
7934                  res = obj2ast_alias(state, tmp2, &val, arena);
7935                  _Py_LeaveRecursiveCall();
7936                  Py_DECREF(tmp2);
7937                  if (res != 0) goto failed;
7938                  if (len != PyList_GET_SIZE(tmp)) {
7939                      PyErr_SetString(PyExc_RuntimeError, "ImportFrom field \"names\" changed size during iteration");
7940                      goto failed;
7941                  }
7942                  asdl_seq_SET(names, i, val);
7943              }
7944              Py_CLEAR(tmp);
7945          }
7946          if (_PyObject_LookupAttr(obj, state->level, &tmp) < 0) {
7947              return 1;
7948          }
7949          if (tmp == NULL || tmp == Py_None) {
7950              Py_CLEAR(tmp);
7951              level = 0;
7952          }
7953          else {
7954              int res;
7955              if (_Py_EnterRecursiveCall(" while traversing 'ImportFrom' node")) {
7956                  goto failed;
7957              }
7958              res = obj2ast_int(state, tmp, &level, arena);
7959              _Py_LeaveRecursiveCall();
7960              if (res != 0) goto failed;
7961              Py_CLEAR(tmp);
7962          }
7963          *out = _PyAST_ImportFrom(module, names, level, lineno, col_offset,
7964                                   end_lineno, end_col_offset, arena);
7965          if (*out == NULL) goto failed;
7966          return 0;
7967      }
7968      tp = state->Global_type;
7969      isinstance = PyObject_IsInstance(obj, tp);
7970      if (isinstance == -1) {
7971          return 1;
7972      }
7973      if (isinstance) {
7974          asdl_identifier_seq* names;
7975  
7976          if (_PyObject_LookupAttr(obj, state->names, &tmp) < 0) {
7977              return 1;
7978          }
7979          if (tmp == NULL) {
7980              PyErr_SetString(PyExc_TypeError, "required field \"names\" missing from Global");
7981              return 1;
7982          }
7983          else {
7984              int res;
7985              Py_ssize_t len;
7986              Py_ssize_t i;
7987              if (!PyList_Check(tmp)) {
7988                  PyErr_Format(PyExc_TypeError, "Global field \"names\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
7989                  goto failed;
7990              }
7991              len = PyList_GET_SIZE(tmp);
7992              names = _Py_asdl_identifier_seq_new(len, arena);
7993              if (names == NULL) goto failed;
7994              for (i = 0; i < len; i++) {
7995                  identifier val;
7996                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
7997                  Py_INCREF(tmp2);
7998                  if (_Py_EnterRecursiveCall(" while traversing 'Global' node")) {
7999                      goto failed;
8000                  }
8001                  res = obj2ast_identifier(state, tmp2, &val, arena);
8002                  _Py_LeaveRecursiveCall();
8003                  Py_DECREF(tmp2);
8004                  if (res != 0) goto failed;
8005                  if (len != PyList_GET_SIZE(tmp)) {
8006                      PyErr_SetString(PyExc_RuntimeError, "Global field \"names\" changed size during iteration");
8007                      goto failed;
8008                  }
8009                  asdl_seq_SET(names, i, val);
8010              }
8011              Py_CLEAR(tmp);
8012          }
8013          *out = _PyAST_Global(names, lineno, col_offset, end_lineno,
8014                               end_col_offset, arena);
8015          if (*out == NULL) goto failed;
8016          return 0;
8017      }
8018      tp = state->Nonlocal_type;
8019      isinstance = PyObject_IsInstance(obj, tp);
8020      if (isinstance == -1) {
8021          return 1;
8022      }
8023      if (isinstance) {
8024          asdl_identifier_seq* names;
8025  
8026          if (_PyObject_LookupAttr(obj, state->names, &tmp) < 0) {
8027              return 1;
8028          }
8029          if (tmp == NULL) {
8030              PyErr_SetString(PyExc_TypeError, "required field \"names\" missing from Nonlocal");
8031              return 1;
8032          }
8033          else {
8034              int res;
8035              Py_ssize_t len;
8036              Py_ssize_t i;
8037              if (!PyList_Check(tmp)) {
8038                  PyErr_Format(PyExc_TypeError, "Nonlocal field \"names\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
8039                  goto failed;
8040              }
8041              len = PyList_GET_SIZE(tmp);
8042              names = _Py_asdl_identifier_seq_new(len, arena);
8043              if (names == NULL) goto failed;
8044              for (i = 0; i < len; i++) {
8045                  identifier val;
8046                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
8047                  Py_INCREF(tmp2);
8048                  if (_Py_EnterRecursiveCall(" while traversing 'Nonlocal' node")) {
8049                      goto failed;
8050                  }
8051                  res = obj2ast_identifier(state, tmp2, &val, arena);
8052                  _Py_LeaveRecursiveCall();
8053                  Py_DECREF(tmp2);
8054                  if (res != 0) goto failed;
8055                  if (len != PyList_GET_SIZE(tmp)) {
8056                      PyErr_SetString(PyExc_RuntimeError, "Nonlocal field \"names\" changed size during iteration");
8057                      goto failed;
8058                  }
8059                  asdl_seq_SET(names, i, val);
8060              }
8061              Py_CLEAR(tmp);
8062          }
8063          *out = _PyAST_Nonlocal(names, lineno, col_offset, end_lineno,
8064                                 end_col_offset, arena);
8065          if (*out == NULL) goto failed;
8066          return 0;
8067      }
8068      tp = state->Expr_type;
8069      isinstance = PyObject_IsInstance(obj, tp);
8070      if (isinstance == -1) {
8071          return 1;
8072      }
8073      if (isinstance) {
8074          expr_ty value;
8075  
8076          if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
8077              return 1;
8078          }
8079          if (tmp == NULL) {
8080              PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Expr");
8081              return 1;
8082          }
8083          else {
8084              int res;
8085              if (_Py_EnterRecursiveCall(" while traversing 'Expr' node")) {
8086                  goto failed;
8087              }
8088              res = obj2ast_expr(state, tmp, &value, arena);
8089              _Py_LeaveRecursiveCall();
8090              if (res != 0) goto failed;
8091              Py_CLEAR(tmp);
8092          }
8093          *out = _PyAST_Expr(value, lineno, col_offset, end_lineno,
8094                             end_col_offset, arena);
8095          if (*out == NULL) goto failed;
8096          return 0;
8097      }
8098      tp = state->Pass_type;
8099      isinstance = PyObject_IsInstance(obj, tp);
8100      if (isinstance == -1) {
8101          return 1;
8102      }
8103      if (isinstance) {
8104  
8105          *out = _PyAST_Pass(lineno, col_offset, end_lineno, end_col_offset,
8106                             arena);
8107          if (*out == NULL) goto failed;
8108          return 0;
8109      }
8110      tp = state->Break_type;
8111      isinstance = PyObject_IsInstance(obj, tp);
8112      if (isinstance == -1) {
8113          return 1;
8114      }
8115      if (isinstance) {
8116  
8117          *out = _PyAST_Break(lineno, col_offset, end_lineno, end_col_offset,
8118                              arena);
8119          if (*out == NULL) goto failed;
8120          return 0;
8121      }
8122      tp = state->Continue_type;
8123      isinstance = PyObject_IsInstance(obj, tp);
8124      if (isinstance == -1) {
8125          return 1;
8126      }
8127      if (isinstance) {
8128  
8129          *out = _PyAST_Continue(lineno, col_offset, end_lineno, end_col_offset,
8130                                 arena);
8131          if (*out == NULL) goto failed;
8132          return 0;
8133      }
8134  
8135      PyErr_Format(PyExc_TypeError, "expected some sort of stmt, but got %R", obj);
8136      failed:
8137      Py_XDECREF(tmp);
8138      return 1;
8139  }
8140  
8141  int
obj2ast_expr(struct ast_state * state,PyObject * obj,expr_ty * out,PyArena * arena)8142  obj2ast_expr(struct ast_state *state, PyObject* obj, expr_ty* out, PyArena*
8143               arena)
8144  {
8145      int isinstance;
8146  
8147      PyObject *tmp = NULL;
8148      PyObject *tp;
8149      int lineno;
8150      int col_offset;
8151      int end_lineno;
8152      int end_col_offset;
8153  
8154      if (obj == Py_None) {
8155          *out = NULL;
8156          return 0;
8157      }
8158      if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) {
8159          return 1;
8160      }
8161      if (tmp == NULL) {
8162          PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from expr");
8163          return 1;
8164      }
8165      else {
8166          int res;
8167          if (_Py_EnterRecursiveCall(" while traversing 'expr' node")) {
8168              goto failed;
8169          }
8170          res = obj2ast_int(state, tmp, &lineno, arena);
8171          _Py_LeaveRecursiveCall();
8172          if (res != 0) goto failed;
8173          Py_CLEAR(tmp);
8174      }
8175      if (_PyObject_LookupAttr(obj, state->col_offset, &tmp) < 0) {
8176          return 1;
8177      }
8178      if (tmp == NULL) {
8179          PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from expr");
8180          return 1;
8181      }
8182      else {
8183          int res;
8184          if (_Py_EnterRecursiveCall(" while traversing 'expr' node")) {
8185              goto failed;
8186          }
8187          res = obj2ast_int(state, tmp, &col_offset, arena);
8188          _Py_LeaveRecursiveCall();
8189          if (res != 0) goto failed;
8190          Py_CLEAR(tmp);
8191      }
8192      if (_PyObject_LookupAttr(obj, state->end_lineno, &tmp) < 0) {
8193          return 1;
8194      }
8195      if (tmp == NULL || tmp == Py_None) {
8196          Py_CLEAR(tmp);
8197          end_lineno = lineno;
8198      }
8199      else {
8200          int res;
8201          if (_Py_EnterRecursiveCall(" while traversing 'expr' node")) {
8202              goto failed;
8203          }
8204          res = obj2ast_int(state, tmp, &end_lineno, arena);
8205          _Py_LeaveRecursiveCall();
8206          if (res != 0) goto failed;
8207          Py_CLEAR(tmp);
8208      }
8209      if (_PyObject_LookupAttr(obj, state->end_col_offset, &tmp) < 0) {
8210          return 1;
8211      }
8212      if (tmp == NULL || tmp == Py_None) {
8213          Py_CLEAR(tmp);
8214          end_col_offset = col_offset;
8215      }
8216      else {
8217          int res;
8218          if (_Py_EnterRecursiveCall(" while traversing 'expr' node")) {
8219              goto failed;
8220          }
8221          res = obj2ast_int(state, tmp, &end_col_offset, arena);
8222          _Py_LeaveRecursiveCall();
8223          if (res != 0) goto failed;
8224          Py_CLEAR(tmp);
8225      }
8226      tp = state->BoolOp_type;
8227      isinstance = PyObject_IsInstance(obj, tp);
8228      if (isinstance == -1) {
8229          return 1;
8230      }
8231      if (isinstance) {
8232          boolop_ty op;
8233          asdl_expr_seq* values;
8234  
8235          if (_PyObject_LookupAttr(obj, state->op, &tmp) < 0) {
8236              return 1;
8237          }
8238          if (tmp == NULL) {
8239              PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from BoolOp");
8240              return 1;
8241          }
8242          else {
8243              int res;
8244              if (_Py_EnterRecursiveCall(" while traversing 'BoolOp' node")) {
8245                  goto failed;
8246              }
8247              res = obj2ast_boolop(state, tmp, &op, arena);
8248              _Py_LeaveRecursiveCall();
8249              if (res != 0) goto failed;
8250              Py_CLEAR(tmp);
8251          }
8252          if (_PyObject_LookupAttr(obj, state->values, &tmp) < 0) {
8253              return 1;
8254          }
8255          if (tmp == NULL) {
8256              PyErr_SetString(PyExc_TypeError, "required field \"values\" missing from BoolOp");
8257              return 1;
8258          }
8259          else {
8260              int res;
8261              Py_ssize_t len;
8262              Py_ssize_t i;
8263              if (!PyList_Check(tmp)) {
8264                  PyErr_Format(PyExc_TypeError, "BoolOp field \"values\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
8265                  goto failed;
8266              }
8267              len = PyList_GET_SIZE(tmp);
8268              values = _Py_asdl_expr_seq_new(len, arena);
8269              if (values == NULL) goto failed;
8270              for (i = 0; i < len; i++) {
8271                  expr_ty val;
8272                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
8273                  Py_INCREF(tmp2);
8274                  if (_Py_EnterRecursiveCall(" while traversing 'BoolOp' node")) {
8275                      goto failed;
8276                  }
8277                  res = obj2ast_expr(state, tmp2, &val, arena);
8278                  _Py_LeaveRecursiveCall();
8279                  Py_DECREF(tmp2);
8280                  if (res != 0) goto failed;
8281                  if (len != PyList_GET_SIZE(tmp)) {
8282                      PyErr_SetString(PyExc_RuntimeError, "BoolOp field \"values\" changed size during iteration");
8283                      goto failed;
8284                  }
8285                  asdl_seq_SET(values, i, val);
8286              }
8287              Py_CLEAR(tmp);
8288          }
8289          *out = _PyAST_BoolOp(op, values, lineno, col_offset, end_lineno,
8290                               end_col_offset, arena);
8291          if (*out == NULL) goto failed;
8292          return 0;
8293      }
8294      tp = state->NamedExpr_type;
8295      isinstance = PyObject_IsInstance(obj, tp);
8296      if (isinstance == -1) {
8297          return 1;
8298      }
8299      if (isinstance) {
8300          expr_ty target;
8301          expr_ty value;
8302  
8303          if (_PyObject_LookupAttr(obj, state->target, &tmp) < 0) {
8304              return 1;
8305          }
8306          if (tmp == NULL) {
8307              PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from NamedExpr");
8308              return 1;
8309          }
8310          else {
8311              int res;
8312              if (_Py_EnterRecursiveCall(" while traversing 'NamedExpr' node")) {
8313                  goto failed;
8314              }
8315              res = obj2ast_expr(state, tmp, &target, arena);
8316              _Py_LeaveRecursiveCall();
8317              if (res != 0) goto failed;
8318              Py_CLEAR(tmp);
8319          }
8320          if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
8321              return 1;
8322          }
8323          if (tmp == NULL) {
8324              PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from NamedExpr");
8325              return 1;
8326          }
8327          else {
8328              int res;
8329              if (_Py_EnterRecursiveCall(" while traversing 'NamedExpr' node")) {
8330                  goto failed;
8331              }
8332              res = obj2ast_expr(state, tmp, &value, arena);
8333              _Py_LeaveRecursiveCall();
8334              if (res != 0) goto failed;
8335              Py_CLEAR(tmp);
8336          }
8337          *out = _PyAST_NamedExpr(target, value, lineno, col_offset, end_lineno,
8338                                  end_col_offset, arena);
8339          if (*out == NULL) goto failed;
8340          return 0;
8341      }
8342      tp = state->BinOp_type;
8343      isinstance = PyObject_IsInstance(obj, tp);
8344      if (isinstance == -1) {
8345          return 1;
8346      }
8347      if (isinstance) {
8348          expr_ty left;
8349          operator_ty op;
8350          expr_ty right;
8351  
8352          if (_PyObject_LookupAttr(obj, state->left, &tmp) < 0) {
8353              return 1;
8354          }
8355          if (tmp == NULL) {
8356              PyErr_SetString(PyExc_TypeError, "required field \"left\" missing from BinOp");
8357              return 1;
8358          }
8359          else {
8360              int res;
8361              if (_Py_EnterRecursiveCall(" while traversing 'BinOp' node")) {
8362                  goto failed;
8363              }
8364              res = obj2ast_expr(state, tmp, &left, arena);
8365              _Py_LeaveRecursiveCall();
8366              if (res != 0) goto failed;
8367              Py_CLEAR(tmp);
8368          }
8369          if (_PyObject_LookupAttr(obj, state->op, &tmp) < 0) {
8370              return 1;
8371          }
8372          if (tmp == NULL) {
8373              PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from BinOp");
8374              return 1;
8375          }
8376          else {
8377              int res;
8378              if (_Py_EnterRecursiveCall(" while traversing 'BinOp' node")) {
8379                  goto failed;
8380              }
8381              res = obj2ast_operator(state, tmp, &op, arena);
8382              _Py_LeaveRecursiveCall();
8383              if (res != 0) goto failed;
8384              Py_CLEAR(tmp);
8385          }
8386          if (_PyObject_LookupAttr(obj, state->right, &tmp) < 0) {
8387              return 1;
8388          }
8389          if (tmp == NULL) {
8390              PyErr_SetString(PyExc_TypeError, "required field \"right\" missing from BinOp");
8391              return 1;
8392          }
8393          else {
8394              int res;
8395              if (_Py_EnterRecursiveCall(" while traversing 'BinOp' node")) {
8396                  goto failed;
8397              }
8398              res = obj2ast_expr(state, tmp, &right, arena);
8399              _Py_LeaveRecursiveCall();
8400              if (res != 0) goto failed;
8401              Py_CLEAR(tmp);
8402          }
8403          *out = _PyAST_BinOp(left, op, right, lineno, col_offset, end_lineno,
8404                              end_col_offset, arena);
8405          if (*out == NULL) goto failed;
8406          return 0;
8407      }
8408      tp = state->UnaryOp_type;
8409      isinstance = PyObject_IsInstance(obj, tp);
8410      if (isinstance == -1) {
8411          return 1;
8412      }
8413      if (isinstance) {
8414          unaryop_ty op;
8415          expr_ty operand;
8416  
8417          if (_PyObject_LookupAttr(obj, state->op, &tmp) < 0) {
8418              return 1;
8419          }
8420          if (tmp == NULL) {
8421              PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from UnaryOp");
8422              return 1;
8423          }
8424          else {
8425              int res;
8426              if (_Py_EnterRecursiveCall(" while traversing 'UnaryOp' node")) {
8427                  goto failed;
8428              }
8429              res = obj2ast_unaryop(state, tmp, &op, arena);
8430              _Py_LeaveRecursiveCall();
8431              if (res != 0) goto failed;
8432              Py_CLEAR(tmp);
8433          }
8434          if (_PyObject_LookupAttr(obj, state->operand, &tmp) < 0) {
8435              return 1;
8436          }
8437          if (tmp == NULL) {
8438              PyErr_SetString(PyExc_TypeError, "required field \"operand\" missing from UnaryOp");
8439              return 1;
8440          }
8441          else {
8442              int res;
8443              if (_Py_EnterRecursiveCall(" while traversing 'UnaryOp' node")) {
8444                  goto failed;
8445              }
8446              res = obj2ast_expr(state, tmp, &operand, arena);
8447              _Py_LeaveRecursiveCall();
8448              if (res != 0) goto failed;
8449              Py_CLEAR(tmp);
8450          }
8451          *out = _PyAST_UnaryOp(op, operand, lineno, col_offset, end_lineno,
8452                                end_col_offset, arena);
8453          if (*out == NULL) goto failed;
8454          return 0;
8455      }
8456      tp = state->Lambda_type;
8457      isinstance = PyObject_IsInstance(obj, tp);
8458      if (isinstance == -1) {
8459          return 1;
8460      }
8461      if (isinstance) {
8462          arguments_ty args;
8463          expr_ty body;
8464  
8465          if (_PyObject_LookupAttr(obj, state->args, &tmp) < 0) {
8466              return 1;
8467          }
8468          if (tmp == NULL) {
8469              PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from Lambda");
8470              return 1;
8471          }
8472          else {
8473              int res;
8474              if (_Py_EnterRecursiveCall(" while traversing 'Lambda' node")) {
8475                  goto failed;
8476              }
8477              res = obj2ast_arguments(state, tmp, &args, arena);
8478              _Py_LeaveRecursiveCall();
8479              if (res != 0) goto failed;
8480              Py_CLEAR(tmp);
8481          }
8482          if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
8483              return 1;
8484          }
8485          if (tmp == NULL) {
8486              PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Lambda");
8487              return 1;
8488          }
8489          else {
8490              int res;
8491              if (_Py_EnterRecursiveCall(" while traversing 'Lambda' node")) {
8492                  goto failed;
8493              }
8494              res = obj2ast_expr(state, tmp, &body, arena);
8495              _Py_LeaveRecursiveCall();
8496              if (res != 0) goto failed;
8497              Py_CLEAR(tmp);
8498          }
8499          *out = _PyAST_Lambda(args, body, lineno, col_offset, end_lineno,
8500                               end_col_offset, arena);
8501          if (*out == NULL) goto failed;
8502          return 0;
8503      }
8504      tp = state->IfExp_type;
8505      isinstance = PyObject_IsInstance(obj, tp);
8506      if (isinstance == -1) {
8507          return 1;
8508      }
8509      if (isinstance) {
8510          expr_ty test;
8511          expr_ty body;
8512          expr_ty orelse;
8513  
8514          if (_PyObject_LookupAttr(obj, state->test, &tmp) < 0) {
8515              return 1;
8516          }
8517          if (tmp == NULL) {
8518              PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from IfExp");
8519              return 1;
8520          }
8521          else {
8522              int res;
8523              if (_Py_EnterRecursiveCall(" while traversing 'IfExp' node")) {
8524                  goto failed;
8525              }
8526              res = obj2ast_expr(state, tmp, &test, arena);
8527              _Py_LeaveRecursiveCall();
8528              if (res != 0) goto failed;
8529              Py_CLEAR(tmp);
8530          }
8531          if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
8532              return 1;
8533          }
8534          if (tmp == NULL) {
8535              PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from IfExp");
8536              return 1;
8537          }
8538          else {
8539              int res;
8540              if (_Py_EnterRecursiveCall(" while traversing 'IfExp' node")) {
8541                  goto failed;
8542              }
8543              res = obj2ast_expr(state, tmp, &body, arena);
8544              _Py_LeaveRecursiveCall();
8545              if (res != 0) goto failed;
8546              Py_CLEAR(tmp);
8547          }
8548          if (_PyObject_LookupAttr(obj, state->orelse, &tmp) < 0) {
8549              return 1;
8550          }
8551          if (tmp == NULL) {
8552              PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from IfExp");
8553              return 1;
8554          }
8555          else {
8556              int res;
8557              if (_Py_EnterRecursiveCall(" while traversing 'IfExp' node")) {
8558                  goto failed;
8559              }
8560              res = obj2ast_expr(state, tmp, &orelse, arena);
8561              _Py_LeaveRecursiveCall();
8562              if (res != 0) goto failed;
8563              Py_CLEAR(tmp);
8564          }
8565          *out = _PyAST_IfExp(test, body, orelse, lineno, col_offset, end_lineno,
8566                              end_col_offset, arena);
8567          if (*out == NULL) goto failed;
8568          return 0;
8569      }
8570      tp = state->Dict_type;
8571      isinstance = PyObject_IsInstance(obj, tp);
8572      if (isinstance == -1) {
8573          return 1;
8574      }
8575      if (isinstance) {
8576          asdl_expr_seq* keys;
8577          asdl_expr_seq* values;
8578  
8579          if (_PyObject_LookupAttr(obj, state->keys, &tmp) < 0) {
8580              return 1;
8581          }
8582          if (tmp == NULL) {
8583              PyErr_SetString(PyExc_TypeError, "required field \"keys\" missing from Dict");
8584              return 1;
8585          }
8586          else {
8587              int res;
8588              Py_ssize_t len;
8589              Py_ssize_t i;
8590              if (!PyList_Check(tmp)) {
8591                  PyErr_Format(PyExc_TypeError, "Dict field \"keys\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
8592                  goto failed;
8593              }
8594              len = PyList_GET_SIZE(tmp);
8595              keys = _Py_asdl_expr_seq_new(len, arena);
8596              if (keys == NULL) goto failed;
8597              for (i = 0; i < len; i++) {
8598                  expr_ty val;
8599                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
8600                  Py_INCREF(tmp2);
8601                  if (_Py_EnterRecursiveCall(" while traversing 'Dict' node")) {
8602                      goto failed;
8603                  }
8604                  res = obj2ast_expr(state, tmp2, &val, arena);
8605                  _Py_LeaveRecursiveCall();
8606                  Py_DECREF(tmp2);
8607                  if (res != 0) goto failed;
8608                  if (len != PyList_GET_SIZE(tmp)) {
8609                      PyErr_SetString(PyExc_RuntimeError, "Dict field \"keys\" changed size during iteration");
8610                      goto failed;
8611                  }
8612                  asdl_seq_SET(keys, i, val);
8613              }
8614              Py_CLEAR(tmp);
8615          }
8616          if (_PyObject_LookupAttr(obj, state->values, &tmp) < 0) {
8617              return 1;
8618          }
8619          if (tmp == NULL) {
8620              PyErr_SetString(PyExc_TypeError, "required field \"values\" missing from Dict");
8621              return 1;
8622          }
8623          else {
8624              int res;
8625              Py_ssize_t len;
8626              Py_ssize_t i;
8627              if (!PyList_Check(tmp)) {
8628                  PyErr_Format(PyExc_TypeError, "Dict field \"values\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
8629                  goto failed;
8630              }
8631              len = PyList_GET_SIZE(tmp);
8632              values = _Py_asdl_expr_seq_new(len, arena);
8633              if (values == NULL) goto failed;
8634              for (i = 0; i < len; i++) {
8635                  expr_ty val;
8636                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
8637                  Py_INCREF(tmp2);
8638                  if (_Py_EnterRecursiveCall(" while traversing 'Dict' node")) {
8639                      goto failed;
8640                  }
8641                  res = obj2ast_expr(state, tmp2, &val, arena);
8642                  _Py_LeaveRecursiveCall();
8643                  Py_DECREF(tmp2);
8644                  if (res != 0) goto failed;
8645                  if (len != PyList_GET_SIZE(tmp)) {
8646                      PyErr_SetString(PyExc_RuntimeError, "Dict field \"values\" changed size during iteration");
8647                      goto failed;
8648                  }
8649                  asdl_seq_SET(values, i, val);
8650              }
8651              Py_CLEAR(tmp);
8652          }
8653          *out = _PyAST_Dict(keys, values, lineno, col_offset, end_lineno,
8654                             end_col_offset, arena);
8655          if (*out == NULL) goto failed;
8656          return 0;
8657      }
8658      tp = state->Set_type;
8659      isinstance = PyObject_IsInstance(obj, tp);
8660      if (isinstance == -1) {
8661          return 1;
8662      }
8663      if (isinstance) {
8664          asdl_expr_seq* elts;
8665  
8666          if (_PyObject_LookupAttr(obj, state->elts, &tmp) < 0) {
8667              return 1;
8668          }
8669          if (tmp == NULL) {
8670              PyErr_SetString(PyExc_TypeError, "required field \"elts\" missing from Set");
8671              return 1;
8672          }
8673          else {
8674              int res;
8675              Py_ssize_t len;
8676              Py_ssize_t i;
8677              if (!PyList_Check(tmp)) {
8678                  PyErr_Format(PyExc_TypeError, "Set field \"elts\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
8679                  goto failed;
8680              }
8681              len = PyList_GET_SIZE(tmp);
8682              elts = _Py_asdl_expr_seq_new(len, arena);
8683              if (elts == NULL) goto failed;
8684              for (i = 0; i < len; i++) {
8685                  expr_ty val;
8686                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
8687                  Py_INCREF(tmp2);
8688                  if (_Py_EnterRecursiveCall(" while traversing 'Set' node")) {
8689                      goto failed;
8690                  }
8691                  res = obj2ast_expr(state, tmp2, &val, arena);
8692                  _Py_LeaveRecursiveCall();
8693                  Py_DECREF(tmp2);
8694                  if (res != 0) goto failed;
8695                  if (len != PyList_GET_SIZE(tmp)) {
8696                      PyErr_SetString(PyExc_RuntimeError, "Set field \"elts\" changed size during iteration");
8697                      goto failed;
8698                  }
8699                  asdl_seq_SET(elts, i, val);
8700              }
8701              Py_CLEAR(tmp);
8702          }
8703          *out = _PyAST_Set(elts, lineno, col_offset, end_lineno, end_col_offset,
8704                            arena);
8705          if (*out == NULL) goto failed;
8706          return 0;
8707      }
8708      tp = state->ListComp_type;
8709      isinstance = PyObject_IsInstance(obj, tp);
8710      if (isinstance == -1) {
8711          return 1;
8712      }
8713      if (isinstance) {
8714          expr_ty elt;
8715          asdl_comprehension_seq* generators;
8716  
8717          if (_PyObject_LookupAttr(obj, state->elt, &tmp) < 0) {
8718              return 1;
8719          }
8720          if (tmp == NULL) {
8721              PyErr_SetString(PyExc_TypeError, "required field \"elt\" missing from ListComp");
8722              return 1;
8723          }
8724          else {
8725              int res;
8726              if (_Py_EnterRecursiveCall(" while traversing 'ListComp' node")) {
8727                  goto failed;
8728              }
8729              res = obj2ast_expr(state, tmp, &elt, arena);
8730              _Py_LeaveRecursiveCall();
8731              if (res != 0) goto failed;
8732              Py_CLEAR(tmp);
8733          }
8734          if (_PyObject_LookupAttr(obj, state->generators, &tmp) < 0) {
8735              return 1;
8736          }
8737          if (tmp == NULL) {
8738              PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from ListComp");
8739              return 1;
8740          }
8741          else {
8742              int res;
8743              Py_ssize_t len;
8744              Py_ssize_t i;
8745              if (!PyList_Check(tmp)) {
8746                  PyErr_Format(PyExc_TypeError, "ListComp field \"generators\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
8747                  goto failed;
8748              }
8749              len = PyList_GET_SIZE(tmp);
8750              generators = _Py_asdl_comprehension_seq_new(len, arena);
8751              if (generators == NULL) goto failed;
8752              for (i = 0; i < len; i++) {
8753                  comprehension_ty val;
8754                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
8755                  Py_INCREF(tmp2);
8756                  if (_Py_EnterRecursiveCall(" while traversing 'ListComp' node")) {
8757                      goto failed;
8758                  }
8759                  res = obj2ast_comprehension(state, tmp2, &val, arena);
8760                  _Py_LeaveRecursiveCall();
8761                  Py_DECREF(tmp2);
8762                  if (res != 0) goto failed;
8763                  if (len != PyList_GET_SIZE(tmp)) {
8764                      PyErr_SetString(PyExc_RuntimeError, "ListComp field \"generators\" changed size during iteration");
8765                      goto failed;
8766                  }
8767                  asdl_seq_SET(generators, i, val);
8768              }
8769              Py_CLEAR(tmp);
8770          }
8771          *out = _PyAST_ListComp(elt, generators, lineno, col_offset, end_lineno,
8772                                 end_col_offset, arena);
8773          if (*out == NULL) goto failed;
8774          return 0;
8775      }
8776      tp = state->SetComp_type;
8777      isinstance = PyObject_IsInstance(obj, tp);
8778      if (isinstance == -1) {
8779          return 1;
8780      }
8781      if (isinstance) {
8782          expr_ty elt;
8783          asdl_comprehension_seq* generators;
8784  
8785          if (_PyObject_LookupAttr(obj, state->elt, &tmp) < 0) {
8786              return 1;
8787          }
8788          if (tmp == NULL) {
8789              PyErr_SetString(PyExc_TypeError, "required field \"elt\" missing from SetComp");
8790              return 1;
8791          }
8792          else {
8793              int res;
8794              if (_Py_EnterRecursiveCall(" while traversing 'SetComp' node")) {
8795                  goto failed;
8796              }
8797              res = obj2ast_expr(state, tmp, &elt, arena);
8798              _Py_LeaveRecursiveCall();
8799              if (res != 0) goto failed;
8800              Py_CLEAR(tmp);
8801          }
8802          if (_PyObject_LookupAttr(obj, state->generators, &tmp) < 0) {
8803              return 1;
8804          }
8805          if (tmp == NULL) {
8806              PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from SetComp");
8807              return 1;
8808          }
8809          else {
8810              int res;
8811              Py_ssize_t len;
8812              Py_ssize_t i;
8813              if (!PyList_Check(tmp)) {
8814                  PyErr_Format(PyExc_TypeError, "SetComp field \"generators\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
8815                  goto failed;
8816              }
8817              len = PyList_GET_SIZE(tmp);
8818              generators = _Py_asdl_comprehension_seq_new(len, arena);
8819              if (generators == NULL) goto failed;
8820              for (i = 0; i < len; i++) {
8821                  comprehension_ty val;
8822                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
8823                  Py_INCREF(tmp2);
8824                  if (_Py_EnterRecursiveCall(" while traversing 'SetComp' node")) {
8825                      goto failed;
8826                  }
8827                  res = obj2ast_comprehension(state, tmp2, &val, arena);
8828                  _Py_LeaveRecursiveCall();
8829                  Py_DECREF(tmp2);
8830                  if (res != 0) goto failed;
8831                  if (len != PyList_GET_SIZE(tmp)) {
8832                      PyErr_SetString(PyExc_RuntimeError, "SetComp field \"generators\" changed size during iteration");
8833                      goto failed;
8834                  }
8835                  asdl_seq_SET(generators, i, val);
8836              }
8837              Py_CLEAR(tmp);
8838          }
8839          *out = _PyAST_SetComp(elt, generators, lineno, col_offset, end_lineno,
8840                                end_col_offset, arena);
8841          if (*out == NULL) goto failed;
8842          return 0;
8843      }
8844      tp = state->DictComp_type;
8845      isinstance = PyObject_IsInstance(obj, tp);
8846      if (isinstance == -1) {
8847          return 1;
8848      }
8849      if (isinstance) {
8850          expr_ty key;
8851          expr_ty value;
8852          asdl_comprehension_seq* generators;
8853  
8854          if (_PyObject_LookupAttr(obj, state->key, &tmp) < 0) {
8855              return 1;
8856          }
8857          if (tmp == NULL) {
8858              PyErr_SetString(PyExc_TypeError, "required field \"key\" missing from DictComp");
8859              return 1;
8860          }
8861          else {
8862              int res;
8863              if (_Py_EnterRecursiveCall(" while traversing 'DictComp' node")) {
8864                  goto failed;
8865              }
8866              res = obj2ast_expr(state, tmp, &key, arena);
8867              _Py_LeaveRecursiveCall();
8868              if (res != 0) goto failed;
8869              Py_CLEAR(tmp);
8870          }
8871          if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
8872              return 1;
8873          }
8874          if (tmp == NULL) {
8875              PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from DictComp");
8876              return 1;
8877          }
8878          else {
8879              int res;
8880              if (_Py_EnterRecursiveCall(" while traversing 'DictComp' node")) {
8881                  goto failed;
8882              }
8883              res = obj2ast_expr(state, tmp, &value, arena);
8884              _Py_LeaveRecursiveCall();
8885              if (res != 0) goto failed;
8886              Py_CLEAR(tmp);
8887          }
8888          if (_PyObject_LookupAttr(obj, state->generators, &tmp) < 0) {
8889              return 1;
8890          }
8891          if (tmp == NULL) {
8892              PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from DictComp");
8893              return 1;
8894          }
8895          else {
8896              int res;
8897              Py_ssize_t len;
8898              Py_ssize_t i;
8899              if (!PyList_Check(tmp)) {
8900                  PyErr_Format(PyExc_TypeError, "DictComp field \"generators\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
8901                  goto failed;
8902              }
8903              len = PyList_GET_SIZE(tmp);
8904              generators = _Py_asdl_comprehension_seq_new(len, arena);
8905              if (generators == NULL) goto failed;
8906              for (i = 0; i < len; i++) {
8907                  comprehension_ty val;
8908                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
8909                  Py_INCREF(tmp2);
8910                  if (_Py_EnterRecursiveCall(" while traversing 'DictComp' node")) {
8911                      goto failed;
8912                  }
8913                  res = obj2ast_comprehension(state, tmp2, &val, arena);
8914                  _Py_LeaveRecursiveCall();
8915                  Py_DECREF(tmp2);
8916                  if (res != 0) goto failed;
8917                  if (len != PyList_GET_SIZE(tmp)) {
8918                      PyErr_SetString(PyExc_RuntimeError, "DictComp field \"generators\" changed size during iteration");
8919                      goto failed;
8920                  }
8921                  asdl_seq_SET(generators, i, val);
8922              }
8923              Py_CLEAR(tmp);
8924          }
8925          *out = _PyAST_DictComp(key, value, generators, lineno, col_offset,
8926                                 end_lineno, end_col_offset, arena);
8927          if (*out == NULL) goto failed;
8928          return 0;
8929      }
8930      tp = state->GeneratorExp_type;
8931      isinstance = PyObject_IsInstance(obj, tp);
8932      if (isinstance == -1) {
8933          return 1;
8934      }
8935      if (isinstance) {
8936          expr_ty elt;
8937          asdl_comprehension_seq* generators;
8938  
8939          if (_PyObject_LookupAttr(obj, state->elt, &tmp) < 0) {
8940              return 1;
8941          }
8942          if (tmp == NULL) {
8943              PyErr_SetString(PyExc_TypeError, "required field \"elt\" missing from GeneratorExp");
8944              return 1;
8945          }
8946          else {
8947              int res;
8948              if (_Py_EnterRecursiveCall(" while traversing 'GeneratorExp' node")) {
8949                  goto failed;
8950              }
8951              res = obj2ast_expr(state, tmp, &elt, arena);
8952              _Py_LeaveRecursiveCall();
8953              if (res != 0) goto failed;
8954              Py_CLEAR(tmp);
8955          }
8956          if (_PyObject_LookupAttr(obj, state->generators, &tmp) < 0) {
8957              return 1;
8958          }
8959          if (tmp == NULL) {
8960              PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from GeneratorExp");
8961              return 1;
8962          }
8963          else {
8964              int res;
8965              Py_ssize_t len;
8966              Py_ssize_t i;
8967              if (!PyList_Check(tmp)) {
8968                  PyErr_Format(PyExc_TypeError, "GeneratorExp field \"generators\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
8969                  goto failed;
8970              }
8971              len = PyList_GET_SIZE(tmp);
8972              generators = _Py_asdl_comprehension_seq_new(len, arena);
8973              if (generators == NULL) goto failed;
8974              for (i = 0; i < len; i++) {
8975                  comprehension_ty val;
8976                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
8977                  Py_INCREF(tmp2);
8978                  if (_Py_EnterRecursiveCall(" while traversing 'GeneratorExp' node")) {
8979                      goto failed;
8980                  }
8981                  res = obj2ast_comprehension(state, tmp2, &val, arena);
8982                  _Py_LeaveRecursiveCall();
8983                  Py_DECREF(tmp2);
8984                  if (res != 0) goto failed;
8985                  if (len != PyList_GET_SIZE(tmp)) {
8986                      PyErr_SetString(PyExc_RuntimeError, "GeneratorExp field \"generators\" changed size during iteration");
8987                      goto failed;
8988                  }
8989                  asdl_seq_SET(generators, i, val);
8990              }
8991              Py_CLEAR(tmp);
8992          }
8993          *out = _PyAST_GeneratorExp(elt, generators, lineno, col_offset,
8994                                     end_lineno, end_col_offset, arena);
8995          if (*out == NULL) goto failed;
8996          return 0;
8997      }
8998      tp = state->Await_type;
8999      isinstance = PyObject_IsInstance(obj, tp);
9000      if (isinstance == -1) {
9001          return 1;
9002      }
9003      if (isinstance) {
9004          expr_ty value;
9005  
9006          if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
9007              return 1;
9008          }
9009          if (tmp == NULL) {
9010              PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Await");
9011              return 1;
9012          }
9013          else {
9014              int res;
9015              if (_Py_EnterRecursiveCall(" while traversing 'Await' node")) {
9016                  goto failed;
9017              }
9018              res = obj2ast_expr(state, tmp, &value, arena);
9019              _Py_LeaveRecursiveCall();
9020              if (res != 0) goto failed;
9021              Py_CLEAR(tmp);
9022          }
9023          *out = _PyAST_Await(value, lineno, col_offset, end_lineno,
9024                              end_col_offset, arena);
9025          if (*out == NULL) goto failed;
9026          return 0;
9027      }
9028      tp = state->Yield_type;
9029      isinstance = PyObject_IsInstance(obj, tp);
9030      if (isinstance == -1) {
9031          return 1;
9032      }
9033      if (isinstance) {
9034          expr_ty value;
9035  
9036          if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
9037              return 1;
9038          }
9039          if (tmp == NULL || tmp == Py_None) {
9040              Py_CLEAR(tmp);
9041              value = NULL;
9042          }
9043          else {
9044              int res;
9045              if (_Py_EnterRecursiveCall(" while traversing 'Yield' node")) {
9046                  goto failed;
9047              }
9048              res = obj2ast_expr(state, tmp, &value, arena);
9049              _Py_LeaveRecursiveCall();
9050              if (res != 0) goto failed;
9051              Py_CLEAR(tmp);
9052          }
9053          *out = _PyAST_Yield(value, lineno, col_offset, end_lineno,
9054                              end_col_offset, arena);
9055          if (*out == NULL) goto failed;
9056          return 0;
9057      }
9058      tp = state->YieldFrom_type;
9059      isinstance = PyObject_IsInstance(obj, tp);
9060      if (isinstance == -1) {
9061          return 1;
9062      }
9063      if (isinstance) {
9064          expr_ty value;
9065  
9066          if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
9067              return 1;
9068          }
9069          if (tmp == NULL) {
9070              PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from YieldFrom");
9071              return 1;
9072          }
9073          else {
9074              int res;
9075              if (_Py_EnterRecursiveCall(" while traversing 'YieldFrom' node")) {
9076                  goto failed;
9077              }
9078              res = obj2ast_expr(state, tmp, &value, arena);
9079              _Py_LeaveRecursiveCall();
9080              if (res != 0) goto failed;
9081              Py_CLEAR(tmp);
9082          }
9083          *out = _PyAST_YieldFrom(value, lineno, col_offset, end_lineno,
9084                                  end_col_offset, arena);
9085          if (*out == NULL) goto failed;
9086          return 0;
9087      }
9088      tp = state->Compare_type;
9089      isinstance = PyObject_IsInstance(obj, tp);
9090      if (isinstance == -1) {
9091          return 1;
9092      }
9093      if (isinstance) {
9094          expr_ty left;
9095          asdl_int_seq* ops;
9096          asdl_expr_seq* comparators;
9097  
9098          if (_PyObject_LookupAttr(obj, state->left, &tmp) < 0) {
9099              return 1;
9100          }
9101          if (tmp == NULL) {
9102              PyErr_SetString(PyExc_TypeError, "required field \"left\" missing from Compare");
9103              return 1;
9104          }
9105          else {
9106              int res;
9107              if (_Py_EnterRecursiveCall(" while traversing 'Compare' node")) {
9108                  goto failed;
9109              }
9110              res = obj2ast_expr(state, tmp, &left, arena);
9111              _Py_LeaveRecursiveCall();
9112              if (res != 0) goto failed;
9113              Py_CLEAR(tmp);
9114          }
9115          if (_PyObject_LookupAttr(obj, state->ops, &tmp) < 0) {
9116              return 1;
9117          }
9118          if (tmp == NULL) {
9119              PyErr_SetString(PyExc_TypeError, "required field \"ops\" missing from Compare");
9120              return 1;
9121          }
9122          else {
9123              int res;
9124              Py_ssize_t len;
9125              Py_ssize_t i;
9126              if (!PyList_Check(tmp)) {
9127                  PyErr_Format(PyExc_TypeError, "Compare field \"ops\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
9128                  goto failed;
9129              }
9130              len = PyList_GET_SIZE(tmp);
9131              ops = _Py_asdl_int_seq_new(len, arena);
9132              if (ops == NULL) goto failed;
9133              for (i = 0; i < len; i++) {
9134                  cmpop_ty val;
9135                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
9136                  Py_INCREF(tmp2);
9137                  if (_Py_EnterRecursiveCall(" while traversing 'Compare' node")) {
9138                      goto failed;
9139                  }
9140                  res = obj2ast_cmpop(state, tmp2, &val, arena);
9141                  _Py_LeaveRecursiveCall();
9142                  Py_DECREF(tmp2);
9143                  if (res != 0) goto failed;
9144                  if (len != PyList_GET_SIZE(tmp)) {
9145                      PyErr_SetString(PyExc_RuntimeError, "Compare field \"ops\" changed size during iteration");
9146                      goto failed;
9147                  }
9148                  asdl_seq_SET(ops, i, val);
9149              }
9150              Py_CLEAR(tmp);
9151          }
9152          if (_PyObject_LookupAttr(obj, state->comparators, &tmp) < 0) {
9153              return 1;
9154          }
9155          if (tmp == NULL) {
9156              PyErr_SetString(PyExc_TypeError, "required field \"comparators\" missing from Compare");
9157              return 1;
9158          }
9159          else {
9160              int res;
9161              Py_ssize_t len;
9162              Py_ssize_t i;
9163              if (!PyList_Check(tmp)) {
9164                  PyErr_Format(PyExc_TypeError, "Compare field \"comparators\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
9165                  goto failed;
9166              }
9167              len = PyList_GET_SIZE(tmp);
9168              comparators = _Py_asdl_expr_seq_new(len, arena);
9169              if (comparators == NULL) goto failed;
9170              for (i = 0; i < len; i++) {
9171                  expr_ty val;
9172                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
9173                  Py_INCREF(tmp2);
9174                  if (_Py_EnterRecursiveCall(" while traversing 'Compare' node")) {
9175                      goto failed;
9176                  }
9177                  res = obj2ast_expr(state, tmp2, &val, arena);
9178                  _Py_LeaveRecursiveCall();
9179                  Py_DECREF(tmp2);
9180                  if (res != 0) goto failed;
9181                  if (len != PyList_GET_SIZE(tmp)) {
9182                      PyErr_SetString(PyExc_RuntimeError, "Compare field \"comparators\" changed size during iteration");
9183                      goto failed;
9184                  }
9185                  asdl_seq_SET(comparators, i, val);
9186              }
9187              Py_CLEAR(tmp);
9188          }
9189          *out = _PyAST_Compare(left, ops, comparators, lineno, col_offset,
9190                                end_lineno, end_col_offset, arena);
9191          if (*out == NULL) goto failed;
9192          return 0;
9193      }
9194      tp = state->Call_type;
9195      isinstance = PyObject_IsInstance(obj, tp);
9196      if (isinstance == -1) {
9197          return 1;
9198      }
9199      if (isinstance) {
9200          expr_ty func;
9201          asdl_expr_seq* args;
9202          asdl_keyword_seq* keywords;
9203  
9204          if (_PyObject_LookupAttr(obj, state->func, &tmp) < 0) {
9205              return 1;
9206          }
9207          if (tmp == NULL) {
9208              PyErr_SetString(PyExc_TypeError, "required field \"func\" missing from Call");
9209              return 1;
9210          }
9211          else {
9212              int res;
9213              if (_Py_EnterRecursiveCall(" while traversing 'Call' node")) {
9214                  goto failed;
9215              }
9216              res = obj2ast_expr(state, tmp, &func, arena);
9217              _Py_LeaveRecursiveCall();
9218              if (res != 0) goto failed;
9219              Py_CLEAR(tmp);
9220          }
9221          if (_PyObject_LookupAttr(obj, state->args, &tmp) < 0) {
9222              return 1;
9223          }
9224          if (tmp == NULL) {
9225              PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from Call");
9226              return 1;
9227          }
9228          else {
9229              int res;
9230              Py_ssize_t len;
9231              Py_ssize_t i;
9232              if (!PyList_Check(tmp)) {
9233                  PyErr_Format(PyExc_TypeError, "Call field \"args\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
9234                  goto failed;
9235              }
9236              len = PyList_GET_SIZE(tmp);
9237              args = _Py_asdl_expr_seq_new(len, arena);
9238              if (args == NULL) goto failed;
9239              for (i = 0; i < len; i++) {
9240                  expr_ty val;
9241                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
9242                  Py_INCREF(tmp2);
9243                  if (_Py_EnterRecursiveCall(" while traversing 'Call' node")) {
9244                      goto failed;
9245                  }
9246                  res = obj2ast_expr(state, tmp2, &val, arena);
9247                  _Py_LeaveRecursiveCall();
9248                  Py_DECREF(tmp2);
9249                  if (res != 0) goto failed;
9250                  if (len != PyList_GET_SIZE(tmp)) {
9251                      PyErr_SetString(PyExc_RuntimeError, "Call field \"args\" changed size during iteration");
9252                      goto failed;
9253                  }
9254                  asdl_seq_SET(args, i, val);
9255              }
9256              Py_CLEAR(tmp);
9257          }
9258          if (_PyObject_LookupAttr(obj, state->keywords, &tmp) < 0) {
9259              return 1;
9260          }
9261          if (tmp == NULL) {
9262              PyErr_SetString(PyExc_TypeError, "required field \"keywords\" missing from Call");
9263              return 1;
9264          }
9265          else {
9266              int res;
9267              Py_ssize_t len;
9268              Py_ssize_t i;
9269              if (!PyList_Check(tmp)) {
9270                  PyErr_Format(PyExc_TypeError, "Call field \"keywords\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
9271                  goto failed;
9272              }
9273              len = PyList_GET_SIZE(tmp);
9274              keywords = _Py_asdl_keyword_seq_new(len, arena);
9275              if (keywords == NULL) goto failed;
9276              for (i = 0; i < len; i++) {
9277                  keyword_ty val;
9278                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
9279                  Py_INCREF(tmp2);
9280                  if (_Py_EnterRecursiveCall(" while traversing 'Call' node")) {
9281                      goto failed;
9282                  }
9283                  res = obj2ast_keyword(state, tmp2, &val, arena);
9284                  _Py_LeaveRecursiveCall();
9285                  Py_DECREF(tmp2);
9286                  if (res != 0) goto failed;
9287                  if (len != PyList_GET_SIZE(tmp)) {
9288                      PyErr_SetString(PyExc_RuntimeError, "Call field \"keywords\" changed size during iteration");
9289                      goto failed;
9290                  }
9291                  asdl_seq_SET(keywords, i, val);
9292              }
9293              Py_CLEAR(tmp);
9294          }
9295          *out = _PyAST_Call(func, args, keywords, lineno, col_offset,
9296                             end_lineno, end_col_offset, arena);
9297          if (*out == NULL) goto failed;
9298          return 0;
9299      }
9300      tp = state->FormattedValue_type;
9301      isinstance = PyObject_IsInstance(obj, tp);
9302      if (isinstance == -1) {
9303          return 1;
9304      }
9305      if (isinstance) {
9306          expr_ty value;
9307          int conversion;
9308          expr_ty format_spec;
9309  
9310          if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
9311              return 1;
9312          }
9313          if (tmp == NULL) {
9314              PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from FormattedValue");
9315              return 1;
9316          }
9317          else {
9318              int res;
9319              if (_Py_EnterRecursiveCall(" while traversing 'FormattedValue' node")) {
9320                  goto failed;
9321              }
9322              res = obj2ast_expr(state, tmp, &value, arena);
9323              _Py_LeaveRecursiveCall();
9324              if (res != 0) goto failed;
9325              Py_CLEAR(tmp);
9326          }
9327          if (_PyObject_LookupAttr(obj, state->conversion, &tmp) < 0) {
9328              return 1;
9329          }
9330          if (tmp == NULL) {
9331              PyErr_SetString(PyExc_TypeError, "required field \"conversion\" missing from FormattedValue");
9332              return 1;
9333          }
9334          else {
9335              int res;
9336              if (_Py_EnterRecursiveCall(" while traversing 'FormattedValue' node")) {
9337                  goto failed;
9338              }
9339              res = obj2ast_int(state, tmp, &conversion, arena);
9340              _Py_LeaveRecursiveCall();
9341              if (res != 0) goto failed;
9342              Py_CLEAR(tmp);
9343          }
9344          if (_PyObject_LookupAttr(obj, state->format_spec, &tmp) < 0) {
9345              return 1;
9346          }
9347          if (tmp == NULL || tmp == Py_None) {
9348              Py_CLEAR(tmp);
9349              format_spec = NULL;
9350          }
9351          else {
9352              int res;
9353              if (_Py_EnterRecursiveCall(" while traversing 'FormattedValue' node")) {
9354                  goto failed;
9355              }
9356              res = obj2ast_expr(state, tmp, &format_spec, arena);
9357              _Py_LeaveRecursiveCall();
9358              if (res != 0) goto failed;
9359              Py_CLEAR(tmp);
9360          }
9361          *out = _PyAST_FormattedValue(value, conversion, format_spec, lineno,
9362                                       col_offset, end_lineno, end_col_offset,
9363                                       arena);
9364          if (*out == NULL) goto failed;
9365          return 0;
9366      }
9367      tp = state->JoinedStr_type;
9368      isinstance = PyObject_IsInstance(obj, tp);
9369      if (isinstance == -1) {
9370          return 1;
9371      }
9372      if (isinstance) {
9373          asdl_expr_seq* values;
9374  
9375          if (_PyObject_LookupAttr(obj, state->values, &tmp) < 0) {
9376              return 1;
9377          }
9378          if (tmp == NULL) {
9379              PyErr_SetString(PyExc_TypeError, "required field \"values\" missing from JoinedStr");
9380              return 1;
9381          }
9382          else {
9383              int res;
9384              Py_ssize_t len;
9385              Py_ssize_t i;
9386              if (!PyList_Check(tmp)) {
9387                  PyErr_Format(PyExc_TypeError, "JoinedStr field \"values\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
9388                  goto failed;
9389              }
9390              len = PyList_GET_SIZE(tmp);
9391              values = _Py_asdl_expr_seq_new(len, arena);
9392              if (values == NULL) goto failed;
9393              for (i = 0; i < len; i++) {
9394                  expr_ty val;
9395                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
9396                  Py_INCREF(tmp2);
9397                  if (_Py_EnterRecursiveCall(" while traversing 'JoinedStr' node")) {
9398                      goto failed;
9399                  }
9400                  res = obj2ast_expr(state, tmp2, &val, arena);
9401                  _Py_LeaveRecursiveCall();
9402                  Py_DECREF(tmp2);
9403                  if (res != 0) goto failed;
9404                  if (len != PyList_GET_SIZE(tmp)) {
9405                      PyErr_SetString(PyExc_RuntimeError, "JoinedStr field \"values\" changed size during iteration");
9406                      goto failed;
9407                  }
9408                  asdl_seq_SET(values, i, val);
9409              }
9410              Py_CLEAR(tmp);
9411          }
9412          *out = _PyAST_JoinedStr(values, lineno, col_offset, end_lineno,
9413                                  end_col_offset, arena);
9414          if (*out == NULL) goto failed;
9415          return 0;
9416      }
9417      tp = state->Constant_type;
9418      isinstance = PyObject_IsInstance(obj, tp);
9419      if (isinstance == -1) {
9420          return 1;
9421      }
9422      if (isinstance) {
9423          constant value;
9424          string kind;
9425  
9426          if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
9427              return 1;
9428          }
9429          if (tmp == NULL) {
9430              PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Constant");
9431              return 1;
9432          }
9433          else {
9434              int res;
9435              if (_Py_EnterRecursiveCall(" while traversing 'Constant' node")) {
9436                  goto failed;
9437              }
9438              res = obj2ast_constant(state, tmp, &value, arena);
9439              _Py_LeaveRecursiveCall();
9440              if (res != 0) goto failed;
9441              Py_CLEAR(tmp);
9442          }
9443          if (_PyObject_LookupAttr(obj, state->kind, &tmp) < 0) {
9444              return 1;
9445          }
9446          if (tmp == NULL || tmp == Py_None) {
9447              Py_CLEAR(tmp);
9448              kind = NULL;
9449          }
9450          else {
9451              int res;
9452              if (_Py_EnterRecursiveCall(" while traversing 'Constant' node")) {
9453                  goto failed;
9454              }
9455              res = obj2ast_string(state, tmp, &kind, arena);
9456              _Py_LeaveRecursiveCall();
9457              if (res != 0) goto failed;
9458              Py_CLEAR(tmp);
9459          }
9460          *out = _PyAST_Constant(value, kind, lineno, col_offset, end_lineno,
9461                                 end_col_offset, arena);
9462          if (*out == NULL) goto failed;
9463          return 0;
9464      }
9465      tp = state->Attribute_type;
9466      isinstance = PyObject_IsInstance(obj, tp);
9467      if (isinstance == -1) {
9468          return 1;
9469      }
9470      if (isinstance) {
9471          expr_ty value;
9472          identifier attr;
9473          expr_context_ty ctx;
9474  
9475          if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
9476              return 1;
9477          }
9478          if (tmp == NULL) {
9479              PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Attribute");
9480              return 1;
9481          }
9482          else {
9483              int res;
9484              if (_Py_EnterRecursiveCall(" while traversing 'Attribute' node")) {
9485                  goto failed;
9486              }
9487              res = obj2ast_expr(state, tmp, &value, arena);
9488              _Py_LeaveRecursiveCall();
9489              if (res != 0) goto failed;
9490              Py_CLEAR(tmp);
9491          }
9492          if (_PyObject_LookupAttr(obj, state->attr, &tmp) < 0) {
9493              return 1;
9494          }
9495          if (tmp == NULL) {
9496              PyErr_SetString(PyExc_TypeError, "required field \"attr\" missing from Attribute");
9497              return 1;
9498          }
9499          else {
9500              int res;
9501              if (_Py_EnterRecursiveCall(" while traversing 'Attribute' node")) {
9502                  goto failed;
9503              }
9504              res = obj2ast_identifier(state, tmp, &attr, arena);
9505              _Py_LeaveRecursiveCall();
9506              if (res != 0) goto failed;
9507              Py_CLEAR(tmp);
9508          }
9509          if (_PyObject_LookupAttr(obj, state->ctx, &tmp) < 0) {
9510              return 1;
9511          }
9512          if (tmp == NULL) {
9513              PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Attribute");
9514              return 1;
9515          }
9516          else {
9517              int res;
9518              if (_Py_EnterRecursiveCall(" while traversing 'Attribute' node")) {
9519                  goto failed;
9520              }
9521              res = obj2ast_expr_context(state, tmp, &ctx, arena);
9522              _Py_LeaveRecursiveCall();
9523              if (res != 0) goto failed;
9524              Py_CLEAR(tmp);
9525          }
9526          *out = _PyAST_Attribute(value, attr, ctx, lineno, col_offset,
9527                                  end_lineno, end_col_offset, arena);
9528          if (*out == NULL) goto failed;
9529          return 0;
9530      }
9531      tp = state->Subscript_type;
9532      isinstance = PyObject_IsInstance(obj, tp);
9533      if (isinstance == -1) {
9534          return 1;
9535      }
9536      if (isinstance) {
9537          expr_ty value;
9538          expr_ty slice;
9539          expr_context_ty ctx;
9540  
9541          if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
9542              return 1;
9543          }
9544          if (tmp == NULL) {
9545              PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Subscript");
9546              return 1;
9547          }
9548          else {
9549              int res;
9550              if (_Py_EnterRecursiveCall(" while traversing 'Subscript' node")) {
9551                  goto failed;
9552              }
9553              res = obj2ast_expr(state, tmp, &value, arena);
9554              _Py_LeaveRecursiveCall();
9555              if (res != 0) goto failed;
9556              Py_CLEAR(tmp);
9557          }
9558          if (_PyObject_LookupAttr(obj, state->slice, &tmp) < 0) {
9559              return 1;
9560          }
9561          if (tmp == NULL) {
9562              PyErr_SetString(PyExc_TypeError, "required field \"slice\" missing from Subscript");
9563              return 1;
9564          }
9565          else {
9566              int res;
9567              if (_Py_EnterRecursiveCall(" while traversing 'Subscript' node")) {
9568                  goto failed;
9569              }
9570              res = obj2ast_expr(state, tmp, &slice, arena);
9571              _Py_LeaveRecursiveCall();
9572              if (res != 0) goto failed;
9573              Py_CLEAR(tmp);
9574          }
9575          if (_PyObject_LookupAttr(obj, state->ctx, &tmp) < 0) {
9576              return 1;
9577          }
9578          if (tmp == NULL) {
9579              PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Subscript");
9580              return 1;
9581          }
9582          else {
9583              int res;
9584              if (_Py_EnterRecursiveCall(" while traversing 'Subscript' node")) {
9585                  goto failed;
9586              }
9587              res = obj2ast_expr_context(state, tmp, &ctx, arena);
9588              _Py_LeaveRecursiveCall();
9589              if (res != 0) goto failed;
9590              Py_CLEAR(tmp);
9591          }
9592          *out = _PyAST_Subscript(value, slice, ctx, lineno, col_offset,
9593                                  end_lineno, end_col_offset, arena);
9594          if (*out == NULL) goto failed;
9595          return 0;
9596      }
9597      tp = state->Starred_type;
9598      isinstance = PyObject_IsInstance(obj, tp);
9599      if (isinstance == -1) {
9600          return 1;
9601      }
9602      if (isinstance) {
9603          expr_ty value;
9604          expr_context_ty ctx;
9605  
9606          if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
9607              return 1;
9608          }
9609          if (tmp == NULL) {
9610              PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Starred");
9611              return 1;
9612          }
9613          else {
9614              int res;
9615              if (_Py_EnterRecursiveCall(" while traversing 'Starred' node")) {
9616                  goto failed;
9617              }
9618              res = obj2ast_expr(state, tmp, &value, arena);
9619              _Py_LeaveRecursiveCall();
9620              if (res != 0) goto failed;
9621              Py_CLEAR(tmp);
9622          }
9623          if (_PyObject_LookupAttr(obj, state->ctx, &tmp) < 0) {
9624              return 1;
9625          }
9626          if (tmp == NULL) {
9627              PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Starred");
9628              return 1;
9629          }
9630          else {
9631              int res;
9632              if (_Py_EnterRecursiveCall(" while traversing 'Starred' node")) {
9633                  goto failed;
9634              }
9635              res = obj2ast_expr_context(state, tmp, &ctx, arena);
9636              _Py_LeaveRecursiveCall();
9637              if (res != 0) goto failed;
9638              Py_CLEAR(tmp);
9639          }
9640          *out = _PyAST_Starred(value, ctx, lineno, col_offset, end_lineno,
9641                                end_col_offset, arena);
9642          if (*out == NULL) goto failed;
9643          return 0;
9644      }
9645      tp = state->Name_type;
9646      isinstance = PyObject_IsInstance(obj, tp);
9647      if (isinstance == -1) {
9648          return 1;
9649      }
9650      if (isinstance) {
9651          identifier id;
9652          expr_context_ty ctx;
9653  
9654          if (_PyObject_LookupAttr(obj, state->id, &tmp) < 0) {
9655              return 1;
9656          }
9657          if (tmp == NULL) {
9658              PyErr_SetString(PyExc_TypeError, "required field \"id\" missing from Name");
9659              return 1;
9660          }
9661          else {
9662              int res;
9663              if (_Py_EnterRecursiveCall(" while traversing 'Name' node")) {
9664                  goto failed;
9665              }
9666              res = obj2ast_identifier(state, tmp, &id, arena);
9667              _Py_LeaveRecursiveCall();
9668              if (res != 0) goto failed;
9669              Py_CLEAR(tmp);
9670          }
9671          if (_PyObject_LookupAttr(obj, state->ctx, &tmp) < 0) {
9672              return 1;
9673          }
9674          if (tmp == NULL) {
9675              PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Name");
9676              return 1;
9677          }
9678          else {
9679              int res;
9680              if (_Py_EnterRecursiveCall(" while traversing 'Name' node")) {
9681                  goto failed;
9682              }
9683              res = obj2ast_expr_context(state, tmp, &ctx, arena);
9684              _Py_LeaveRecursiveCall();
9685              if (res != 0) goto failed;
9686              Py_CLEAR(tmp);
9687          }
9688          *out = _PyAST_Name(id, ctx, lineno, col_offset, end_lineno,
9689                             end_col_offset, arena);
9690          if (*out == NULL) goto failed;
9691          return 0;
9692      }
9693      tp = state->List_type;
9694      isinstance = PyObject_IsInstance(obj, tp);
9695      if (isinstance == -1) {
9696          return 1;
9697      }
9698      if (isinstance) {
9699          asdl_expr_seq* elts;
9700          expr_context_ty ctx;
9701  
9702          if (_PyObject_LookupAttr(obj, state->elts, &tmp) < 0) {
9703              return 1;
9704          }
9705          if (tmp == NULL) {
9706              PyErr_SetString(PyExc_TypeError, "required field \"elts\" missing from List");
9707              return 1;
9708          }
9709          else {
9710              int res;
9711              Py_ssize_t len;
9712              Py_ssize_t i;
9713              if (!PyList_Check(tmp)) {
9714                  PyErr_Format(PyExc_TypeError, "List field \"elts\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
9715                  goto failed;
9716              }
9717              len = PyList_GET_SIZE(tmp);
9718              elts = _Py_asdl_expr_seq_new(len, arena);
9719              if (elts == NULL) goto failed;
9720              for (i = 0; i < len; i++) {
9721                  expr_ty val;
9722                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
9723                  Py_INCREF(tmp2);
9724                  if (_Py_EnterRecursiveCall(" while traversing 'List' node")) {
9725                      goto failed;
9726                  }
9727                  res = obj2ast_expr(state, tmp2, &val, arena);
9728                  _Py_LeaveRecursiveCall();
9729                  Py_DECREF(tmp2);
9730                  if (res != 0) goto failed;
9731                  if (len != PyList_GET_SIZE(tmp)) {
9732                      PyErr_SetString(PyExc_RuntimeError, "List field \"elts\" changed size during iteration");
9733                      goto failed;
9734                  }
9735                  asdl_seq_SET(elts, i, val);
9736              }
9737              Py_CLEAR(tmp);
9738          }
9739          if (_PyObject_LookupAttr(obj, state->ctx, &tmp) < 0) {
9740              return 1;
9741          }
9742          if (tmp == NULL) {
9743              PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from List");
9744              return 1;
9745          }
9746          else {
9747              int res;
9748              if (_Py_EnterRecursiveCall(" while traversing 'List' node")) {
9749                  goto failed;
9750              }
9751              res = obj2ast_expr_context(state, tmp, &ctx, arena);
9752              _Py_LeaveRecursiveCall();
9753              if (res != 0) goto failed;
9754              Py_CLEAR(tmp);
9755          }
9756          *out = _PyAST_List(elts, ctx, lineno, col_offset, end_lineno,
9757                             end_col_offset, arena);
9758          if (*out == NULL) goto failed;
9759          return 0;
9760      }
9761      tp = state->Tuple_type;
9762      isinstance = PyObject_IsInstance(obj, tp);
9763      if (isinstance == -1) {
9764          return 1;
9765      }
9766      if (isinstance) {
9767          asdl_expr_seq* elts;
9768          expr_context_ty ctx;
9769  
9770          if (_PyObject_LookupAttr(obj, state->elts, &tmp) < 0) {
9771              return 1;
9772          }
9773          if (tmp == NULL) {
9774              PyErr_SetString(PyExc_TypeError, "required field \"elts\" missing from Tuple");
9775              return 1;
9776          }
9777          else {
9778              int res;
9779              Py_ssize_t len;
9780              Py_ssize_t i;
9781              if (!PyList_Check(tmp)) {
9782                  PyErr_Format(PyExc_TypeError, "Tuple field \"elts\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
9783                  goto failed;
9784              }
9785              len = PyList_GET_SIZE(tmp);
9786              elts = _Py_asdl_expr_seq_new(len, arena);
9787              if (elts == NULL) goto failed;
9788              for (i = 0; i < len; i++) {
9789                  expr_ty val;
9790                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
9791                  Py_INCREF(tmp2);
9792                  if (_Py_EnterRecursiveCall(" while traversing 'Tuple' node")) {
9793                      goto failed;
9794                  }
9795                  res = obj2ast_expr(state, tmp2, &val, arena);
9796                  _Py_LeaveRecursiveCall();
9797                  Py_DECREF(tmp2);
9798                  if (res != 0) goto failed;
9799                  if (len != PyList_GET_SIZE(tmp)) {
9800                      PyErr_SetString(PyExc_RuntimeError, "Tuple field \"elts\" changed size during iteration");
9801                      goto failed;
9802                  }
9803                  asdl_seq_SET(elts, i, val);
9804              }
9805              Py_CLEAR(tmp);
9806          }
9807          if (_PyObject_LookupAttr(obj, state->ctx, &tmp) < 0) {
9808              return 1;
9809          }
9810          if (tmp == NULL) {
9811              PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Tuple");
9812              return 1;
9813          }
9814          else {
9815              int res;
9816              if (_Py_EnterRecursiveCall(" while traversing 'Tuple' node")) {
9817                  goto failed;
9818              }
9819              res = obj2ast_expr_context(state, tmp, &ctx, arena);
9820              _Py_LeaveRecursiveCall();
9821              if (res != 0) goto failed;
9822              Py_CLEAR(tmp);
9823          }
9824          *out = _PyAST_Tuple(elts, ctx, lineno, col_offset, end_lineno,
9825                              end_col_offset, arena);
9826          if (*out == NULL) goto failed;
9827          return 0;
9828      }
9829      tp = state->Slice_type;
9830      isinstance = PyObject_IsInstance(obj, tp);
9831      if (isinstance == -1) {
9832          return 1;
9833      }
9834      if (isinstance) {
9835          expr_ty lower;
9836          expr_ty upper;
9837          expr_ty step;
9838  
9839          if (_PyObject_LookupAttr(obj, state->lower, &tmp) < 0) {
9840              return 1;
9841          }
9842          if (tmp == NULL || tmp == Py_None) {
9843              Py_CLEAR(tmp);
9844              lower = NULL;
9845          }
9846          else {
9847              int res;
9848              if (_Py_EnterRecursiveCall(" while traversing 'Slice' node")) {
9849                  goto failed;
9850              }
9851              res = obj2ast_expr(state, tmp, &lower, arena);
9852              _Py_LeaveRecursiveCall();
9853              if (res != 0) goto failed;
9854              Py_CLEAR(tmp);
9855          }
9856          if (_PyObject_LookupAttr(obj, state->upper, &tmp) < 0) {
9857              return 1;
9858          }
9859          if (tmp == NULL || tmp == Py_None) {
9860              Py_CLEAR(tmp);
9861              upper = NULL;
9862          }
9863          else {
9864              int res;
9865              if (_Py_EnterRecursiveCall(" while traversing 'Slice' node")) {
9866                  goto failed;
9867              }
9868              res = obj2ast_expr(state, tmp, &upper, arena);
9869              _Py_LeaveRecursiveCall();
9870              if (res != 0) goto failed;
9871              Py_CLEAR(tmp);
9872          }
9873          if (_PyObject_LookupAttr(obj, state->step, &tmp) < 0) {
9874              return 1;
9875          }
9876          if (tmp == NULL || tmp == Py_None) {
9877              Py_CLEAR(tmp);
9878              step = NULL;
9879          }
9880          else {
9881              int res;
9882              if (_Py_EnterRecursiveCall(" while traversing 'Slice' node")) {
9883                  goto failed;
9884              }
9885              res = obj2ast_expr(state, tmp, &step, arena);
9886              _Py_LeaveRecursiveCall();
9887              if (res != 0) goto failed;
9888              Py_CLEAR(tmp);
9889          }
9890          *out = _PyAST_Slice(lower, upper, step, lineno, col_offset, end_lineno,
9891                              end_col_offset, arena);
9892          if (*out == NULL) goto failed;
9893          return 0;
9894      }
9895  
9896      PyErr_Format(PyExc_TypeError, "expected some sort of expr, but got %R", obj);
9897      failed:
9898      Py_XDECREF(tmp);
9899      return 1;
9900  }
9901  
9902  int
obj2ast_expr_context(struct ast_state * state,PyObject * obj,expr_context_ty * out,PyArena * arena)9903  obj2ast_expr_context(struct ast_state *state, PyObject* obj, expr_context_ty*
9904                       out, PyArena* arena)
9905  {
9906      int isinstance;
9907  
9908      isinstance = PyObject_IsInstance(obj, state->Load_type);
9909      if (isinstance == -1) {
9910          return 1;
9911      }
9912      if (isinstance) {
9913          *out = Load;
9914          return 0;
9915      }
9916      isinstance = PyObject_IsInstance(obj, state->Store_type);
9917      if (isinstance == -1) {
9918          return 1;
9919      }
9920      if (isinstance) {
9921          *out = Store;
9922          return 0;
9923      }
9924      isinstance = PyObject_IsInstance(obj, state->Del_type);
9925      if (isinstance == -1) {
9926          return 1;
9927      }
9928      if (isinstance) {
9929          *out = Del;
9930          return 0;
9931      }
9932  
9933      PyErr_Format(PyExc_TypeError, "expected some sort of expr_context, but got %R", obj);
9934      return 1;
9935  }
9936  
9937  int
obj2ast_boolop(struct ast_state * state,PyObject * obj,boolop_ty * out,PyArena * arena)9938  obj2ast_boolop(struct ast_state *state, PyObject* obj, boolop_ty* out, PyArena*
9939                 arena)
9940  {
9941      int isinstance;
9942  
9943      isinstance = PyObject_IsInstance(obj, state->And_type);
9944      if (isinstance == -1) {
9945          return 1;
9946      }
9947      if (isinstance) {
9948          *out = And;
9949          return 0;
9950      }
9951      isinstance = PyObject_IsInstance(obj, state->Or_type);
9952      if (isinstance == -1) {
9953          return 1;
9954      }
9955      if (isinstance) {
9956          *out = Or;
9957          return 0;
9958      }
9959  
9960      PyErr_Format(PyExc_TypeError, "expected some sort of boolop, but got %R", obj);
9961      return 1;
9962  }
9963  
9964  int
obj2ast_operator(struct ast_state * state,PyObject * obj,operator_ty * out,PyArena * arena)9965  obj2ast_operator(struct ast_state *state, PyObject* obj, operator_ty* out,
9966                   PyArena* arena)
9967  {
9968      int isinstance;
9969  
9970      isinstance = PyObject_IsInstance(obj, state->Add_type);
9971      if (isinstance == -1) {
9972          return 1;
9973      }
9974      if (isinstance) {
9975          *out = Add;
9976          return 0;
9977      }
9978      isinstance = PyObject_IsInstance(obj, state->Sub_type);
9979      if (isinstance == -1) {
9980          return 1;
9981      }
9982      if (isinstance) {
9983          *out = Sub;
9984          return 0;
9985      }
9986      isinstance = PyObject_IsInstance(obj, state->Mult_type);
9987      if (isinstance == -1) {
9988          return 1;
9989      }
9990      if (isinstance) {
9991          *out = Mult;
9992          return 0;
9993      }
9994      isinstance = PyObject_IsInstance(obj, state->MatMult_type);
9995      if (isinstance == -1) {
9996          return 1;
9997      }
9998      if (isinstance) {
9999          *out = MatMult;
10000          return 0;
10001      }
10002      isinstance = PyObject_IsInstance(obj, state->Div_type);
10003      if (isinstance == -1) {
10004          return 1;
10005      }
10006      if (isinstance) {
10007          *out = Div;
10008          return 0;
10009      }
10010      isinstance = PyObject_IsInstance(obj, state->Mod_type);
10011      if (isinstance == -1) {
10012          return 1;
10013      }
10014      if (isinstance) {
10015          *out = Mod;
10016          return 0;
10017      }
10018      isinstance = PyObject_IsInstance(obj, state->Pow_type);
10019      if (isinstance == -1) {
10020          return 1;
10021      }
10022      if (isinstance) {
10023          *out = Pow;
10024          return 0;
10025      }
10026      isinstance = PyObject_IsInstance(obj, state->LShift_type);
10027      if (isinstance == -1) {
10028          return 1;
10029      }
10030      if (isinstance) {
10031          *out = LShift;
10032          return 0;
10033      }
10034      isinstance = PyObject_IsInstance(obj, state->RShift_type);
10035      if (isinstance == -1) {
10036          return 1;
10037      }
10038      if (isinstance) {
10039          *out = RShift;
10040          return 0;
10041      }
10042      isinstance = PyObject_IsInstance(obj, state->BitOr_type);
10043      if (isinstance == -1) {
10044          return 1;
10045      }
10046      if (isinstance) {
10047          *out = BitOr;
10048          return 0;
10049      }
10050      isinstance = PyObject_IsInstance(obj, state->BitXor_type);
10051      if (isinstance == -1) {
10052          return 1;
10053      }
10054      if (isinstance) {
10055          *out = BitXor;
10056          return 0;
10057      }
10058      isinstance = PyObject_IsInstance(obj, state->BitAnd_type);
10059      if (isinstance == -1) {
10060          return 1;
10061      }
10062      if (isinstance) {
10063          *out = BitAnd;
10064          return 0;
10065      }
10066      isinstance = PyObject_IsInstance(obj, state->FloorDiv_type);
10067      if (isinstance == -1) {
10068          return 1;
10069      }
10070      if (isinstance) {
10071          *out = FloorDiv;
10072          return 0;
10073      }
10074  
10075      PyErr_Format(PyExc_TypeError, "expected some sort of operator, but got %R", obj);
10076      return 1;
10077  }
10078  
10079  int
obj2ast_unaryop(struct ast_state * state,PyObject * obj,unaryop_ty * out,PyArena * arena)10080  obj2ast_unaryop(struct ast_state *state, PyObject* obj, unaryop_ty* out,
10081                  PyArena* arena)
10082  {
10083      int isinstance;
10084  
10085      isinstance = PyObject_IsInstance(obj, state->Invert_type);
10086      if (isinstance == -1) {
10087          return 1;
10088      }
10089      if (isinstance) {
10090          *out = Invert;
10091          return 0;
10092      }
10093      isinstance = PyObject_IsInstance(obj, state->Not_type);
10094      if (isinstance == -1) {
10095          return 1;
10096      }
10097      if (isinstance) {
10098          *out = Not;
10099          return 0;
10100      }
10101      isinstance = PyObject_IsInstance(obj, state->UAdd_type);
10102      if (isinstance == -1) {
10103          return 1;
10104      }
10105      if (isinstance) {
10106          *out = UAdd;
10107          return 0;
10108      }
10109      isinstance = PyObject_IsInstance(obj, state->USub_type);
10110      if (isinstance == -1) {
10111          return 1;
10112      }
10113      if (isinstance) {
10114          *out = USub;
10115          return 0;
10116      }
10117  
10118      PyErr_Format(PyExc_TypeError, "expected some sort of unaryop, but got %R", obj);
10119      return 1;
10120  }
10121  
10122  int
obj2ast_cmpop(struct ast_state * state,PyObject * obj,cmpop_ty * out,PyArena * arena)10123  obj2ast_cmpop(struct ast_state *state, PyObject* obj, cmpop_ty* out, PyArena*
10124                arena)
10125  {
10126      int isinstance;
10127  
10128      isinstance = PyObject_IsInstance(obj, state->Eq_type);
10129      if (isinstance == -1) {
10130          return 1;
10131      }
10132      if (isinstance) {
10133          *out = Eq;
10134          return 0;
10135      }
10136      isinstance = PyObject_IsInstance(obj, state->NotEq_type);
10137      if (isinstance == -1) {
10138          return 1;
10139      }
10140      if (isinstance) {
10141          *out = NotEq;
10142          return 0;
10143      }
10144      isinstance = PyObject_IsInstance(obj, state->Lt_type);
10145      if (isinstance == -1) {
10146          return 1;
10147      }
10148      if (isinstance) {
10149          *out = Lt;
10150          return 0;
10151      }
10152      isinstance = PyObject_IsInstance(obj, state->LtE_type);
10153      if (isinstance == -1) {
10154          return 1;
10155      }
10156      if (isinstance) {
10157          *out = LtE;
10158          return 0;
10159      }
10160      isinstance = PyObject_IsInstance(obj, state->Gt_type);
10161      if (isinstance == -1) {
10162          return 1;
10163      }
10164      if (isinstance) {
10165          *out = Gt;
10166          return 0;
10167      }
10168      isinstance = PyObject_IsInstance(obj, state->GtE_type);
10169      if (isinstance == -1) {
10170          return 1;
10171      }
10172      if (isinstance) {
10173          *out = GtE;
10174          return 0;
10175      }
10176      isinstance = PyObject_IsInstance(obj, state->Is_type);
10177      if (isinstance == -1) {
10178          return 1;
10179      }
10180      if (isinstance) {
10181          *out = Is;
10182          return 0;
10183      }
10184      isinstance = PyObject_IsInstance(obj, state->IsNot_type);
10185      if (isinstance == -1) {
10186          return 1;
10187      }
10188      if (isinstance) {
10189          *out = IsNot;
10190          return 0;
10191      }
10192      isinstance = PyObject_IsInstance(obj, state->In_type);
10193      if (isinstance == -1) {
10194          return 1;
10195      }
10196      if (isinstance) {
10197          *out = In;
10198          return 0;
10199      }
10200      isinstance = PyObject_IsInstance(obj, state->NotIn_type);
10201      if (isinstance == -1) {
10202          return 1;
10203      }
10204      if (isinstance) {
10205          *out = NotIn;
10206          return 0;
10207      }
10208  
10209      PyErr_Format(PyExc_TypeError, "expected some sort of cmpop, but got %R", obj);
10210      return 1;
10211  }
10212  
10213  int
obj2ast_comprehension(struct ast_state * state,PyObject * obj,comprehension_ty * out,PyArena * arena)10214  obj2ast_comprehension(struct ast_state *state, PyObject* obj, comprehension_ty*
10215                        out, PyArena* arena)
10216  {
10217      PyObject* tmp = NULL;
10218      expr_ty target;
10219      expr_ty iter;
10220      asdl_expr_seq* ifs;
10221      int is_async;
10222  
10223      if (_PyObject_LookupAttr(obj, state->target, &tmp) < 0) {
10224          return 1;
10225      }
10226      if (tmp == NULL) {
10227          PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from comprehension");
10228          return 1;
10229      }
10230      else {
10231          int res;
10232          if (_Py_EnterRecursiveCall(" while traversing 'comprehension' node")) {
10233              goto failed;
10234          }
10235          res = obj2ast_expr(state, tmp, &target, arena);
10236          _Py_LeaveRecursiveCall();
10237          if (res != 0) goto failed;
10238          Py_CLEAR(tmp);
10239      }
10240      if (_PyObject_LookupAttr(obj, state->iter, &tmp) < 0) {
10241          return 1;
10242      }
10243      if (tmp == NULL) {
10244          PyErr_SetString(PyExc_TypeError, "required field \"iter\" missing from comprehension");
10245          return 1;
10246      }
10247      else {
10248          int res;
10249          if (_Py_EnterRecursiveCall(" while traversing 'comprehension' node")) {
10250              goto failed;
10251          }
10252          res = obj2ast_expr(state, tmp, &iter, arena);
10253          _Py_LeaveRecursiveCall();
10254          if (res != 0) goto failed;
10255          Py_CLEAR(tmp);
10256      }
10257      if (_PyObject_LookupAttr(obj, state->ifs, &tmp) < 0) {
10258          return 1;
10259      }
10260      if (tmp == NULL) {
10261          PyErr_SetString(PyExc_TypeError, "required field \"ifs\" missing from comprehension");
10262          return 1;
10263      }
10264      else {
10265          int res;
10266          Py_ssize_t len;
10267          Py_ssize_t i;
10268          if (!PyList_Check(tmp)) {
10269              PyErr_Format(PyExc_TypeError, "comprehension field \"ifs\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
10270              goto failed;
10271          }
10272          len = PyList_GET_SIZE(tmp);
10273          ifs = _Py_asdl_expr_seq_new(len, arena);
10274          if (ifs == NULL) goto failed;
10275          for (i = 0; i < len; i++) {
10276              expr_ty val;
10277              PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
10278              Py_INCREF(tmp2);
10279              if (_Py_EnterRecursiveCall(" while traversing 'comprehension' node")) {
10280                  goto failed;
10281              }
10282              res = obj2ast_expr(state, tmp2, &val, arena);
10283              _Py_LeaveRecursiveCall();
10284              Py_DECREF(tmp2);
10285              if (res != 0) goto failed;
10286              if (len != PyList_GET_SIZE(tmp)) {
10287                  PyErr_SetString(PyExc_RuntimeError, "comprehension field \"ifs\" changed size during iteration");
10288                  goto failed;
10289              }
10290              asdl_seq_SET(ifs, i, val);
10291          }
10292          Py_CLEAR(tmp);
10293      }
10294      if (_PyObject_LookupAttr(obj, state->is_async, &tmp) < 0) {
10295          return 1;
10296      }
10297      if (tmp == NULL) {
10298          PyErr_SetString(PyExc_TypeError, "required field \"is_async\" missing from comprehension");
10299          return 1;
10300      }
10301      else {
10302          int res;
10303          if (_Py_EnterRecursiveCall(" while traversing 'comprehension' node")) {
10304              goto failed;
10305          }
10306          res = obj2ast_int(state, tmp, &is_async, arena);
10307          _Py_LeaveRecursiveCall();
10308          if (res != 0) goto failed;
10309          Py_CLEAR(tmp);
10310      }
10311      *out = _PyAST_comprehension(target, iter, ifs, is_async, arena);
10312      return 0;
10313  failed:
10314      Py_XDECREF(tmp);
10315      return 1;
10316  }
10317  
10318  int
obj2ast_excepthandler(struct ast_state * state,PyObject * obj,excepthandler_ty * out,PyArena * arena)10319  obj2ast_excepthandler(struct ast_state *state, PyObject* obj, excepthandler_ty*
10320                        out, PyArena* arena)
10321  {
10322      int isinstance;
10323  
10324      PyObject *tmp = NULL;
10325      PyObject *tp;
10326      int lineno;
10327      int col_offset;
10328      int end_lineno;
10329      int end_col_offset;
10330  
10331      if (obj == Py_None) {
10332          *out = NULL;
10333          return 0;
10334      }
10335      if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) {
10336          return 1;
10337      }
10338      if (tmp == NULL) {
10339          PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from excepthandler");
10340          return 1;
10341      }
10342      else {
10343          int res;
10344          if (_Py_EnterRecursiveCall(" while traversing 'excepthandler' node")) {
10345              goto failed;
10346          }
10347          res = obj2ast_int(state, tmp, &lineno, arena);
10348          _Py_LeaveRecursiveCall();
10349          if (res != 0) goto failed;
10350          Py_CLEAR(tmp);
10351      }
10352      if (_PyObject_LookupAttr(obj, state->col_offset, &tmp) < 0) {
10353          return 1;
10354      }
10355      if (tmp == NULL) {
10356          PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from excepthandler");
10357          return 1;
10358      }
10359      else {
10360          int res;
10361          if (_Py_EnterRecursiveCall(" while traversing 'excepthandler' node")) {
10362              goto failed;
10363          }
10364          res = obj2ast_int(state, tmp, &col_offset, arena);
10365          _Py_LeaveRecursiveCall();
10366          if (res != 0) goto failed;
10367          Py_CLEAR(tmp);
10368      }
10369      if (_PyObject_LookupAttr(obj, state->end_lineno, &tmp) < 0) {
10370          return 1;
10371      }
10372      if (tmp == NULL || tmp == Py_None) {
10373          Py_CLEAR(tmp);
10374          end_lineno = lineno;
10375      }
10376      else {
10377          int res;
10378          if (_Py_EnterRecursiveCall(" while traversing 'excepthandler' node")) {
10379              goto failed;
10380          }
10381          res = obj2ast_int(state, tmp, &end_lineno, arena);
10382          _Py_LeaveRecursiveCall();
10383          if (res != 0) goto failed;
10384          Py_CLEAR(tmp);
10385      }
10386      if (_PyObject_LookupAttr(obj, state->end_col_offset, &tmp) < 0) {
10387          return 1;
10388      }
10389      if (tmp == NULL || tmp == Py_None) {
10390          Py_CLEAR(tmp);
10391          end_col_offset = col_offset;
10392      }
10393      else {
10394          int res;
10395          if (_Py_EnterRecursiveCall(" while traversing 'excepthandler' node")) {
10396              goto failed;
10397          }
10398          res = obj2ast_int(state, tmp, &end_col_offset, arena);
10399          _Py_LeaveRecursiveCall();
10400          if (res != 0) goto failed;
10401          Py_CLEAR(tmp);
10402      }
10403      tp = state->ExceptHandler_type;
10404      isinstance = PyObject_IsInstance(obj, tp);
10405      if (isinstance == -1) {
10406          return 1;
10407      }
10408      if (isinstance) {
10409          expr_ty type;
10410          identifier name;
10411          asdl_stmt_seq* body;
10412  
10413          if (_PyObject_LookupAttr(obj, state->type, &tmp) < 0) {
10414              return 1;
10415          }
10416          if (tmp == NULL || tmp == Py_None) {
10417              Py_CLEAR(tmp);
10418              type = NULL;
10419          }
10420          else {
10421              int res;
10422              if (_Py_EnterRecursiveCall(" while traversing 'ExceptHandler' node")) {
10423                  goto failed;
10424              }
10425              res = obj2ast_expr(state, tmp, &type, arena);
10426              _Py_LeaveRecursiveCall();
10427              if (res != 0) goto failed;
10428              Py_CLEAR(tmp);
10429          }
10430          if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) {
10431              return 1;
10432          }
10433          if (tmp == NULL || tmp == Py_None) {
10434              Py_CLEAR(tmp);
10435              name = NULL;
10436          }
10437          else {
10438              int res;
10439              if (_Py_EnterRecursiveCall(" while traversing 'ExceptHandler' node")) {
10440                  goto failed;
10441              }
10442              res = obj2ast_identifier(state, tmp, &name, arena);
10443              _Py_LeaveRecursiveCall();
10444              if (res != 0) goto failed;
10445              Py_CLEAR(tmp);
10446          }
10447          if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
10448              return 1;
10449          }
10450          if (tmp == NULL) {
10451              PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from ExceptHandler");
10452              return 1;
10453          }
10454          else {
10455              int res;
10456              Py_ssize_t len;
10457              Py_ssize_t i;
10458              if (!PyList_Check(tmp)) {
10459                  PyErr_Format(PyExc_TypeError, "ExceptHandler field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
10460                  goto failed;
10461              }
10462              len = PyList_GET_SIZE(tmp);
10463              body = _Py_asdl_stmt_seq_new(len, arena);
10464              if (body == NULL) goto failed;
10465              for (i = 0; i < len; i++) {
10466                  stmt_ty val;
10467                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
10468                  Py_INCREF(tmp2);
10469                  if (_Py_EnterRecursiveCall(" while traversing 'ExceptHandler' node")) {
10470                      goto failed;
10471                  }
10472                  res = obj2ast_stmt(state, tmp2, &val, arena);
10473                  _Py_LeaveRecursiveCall();
10474                  Py_DECREF(tmp2);
10475                  if (res != 0) goto failed;
10476                  if (len != PyList_GET_SIZE(tmp)) {
10477                      PyErr_SetString(PyExc_RuntimeError, "ExceptHandler field \"body\" changed size during iteration");
10478                      goto failed;
10479                  }
10480                  asdl_seq_SET(body, i, val);
10481              }
10482              Py_CLEAR(tmp);
10483          }
10484          *out = _PyAST_ExceptHandler(type, name, body, lineno, col_offset,
10485                                      end_lineno, end_col_offset, arena);
10486          if (*out == NULL) goto failed;
10487          return 0;
10488      }
10489  
10490      PyErr_Format(PyExc_TypeError, "expected some sort of excepthandler, but got %R", obj);
10491      failed:
10492      Py_XDECREF(tmp);
10493      return 1;
10494  }
10495  
10496  int
obj2ast_arguments(struct ast_state * state,PyObject * obj,arguments_ty * out,PyArena * arena)10497  obj2ast_arguments(struct ast_state *state, PyObject* obj, arguments_ty* out,
10498                    PyArena* arena)
10499  {
10500      PyObject* tmp = NULL;
10501      asdl_arg_seq* posonlyargs;
10502      asdl_arg_seq* args;
10503      arg_ty vararg;
10504      asdl_arg_seq* kwonlyargs;
10505      asdl_expr_seq* kw_defaults;
10506      arg_ty kwarg;
10507      asdl_expr_seq* defaults;
10508  
10509      if (_PyObject_LookupAttr(obj, state->posonlyargs, &tmp) < 0) {
10510          return 1;
10511      }
10512      if (tmp == NULL) {
10513          PyErr_SetString(PyExc_TypeError, "required field \"posonlyargs\" missing from arguments");
10514          return 1;
10515      }
10516      else {
10517          int res;
10518          Py_ssize_t len;
10519          Py_ssize_t i;
10520          if (!PyList_Check(tmp)) {
10521              PyErr_Format(PyExc_TypeError, "arguments field \"posonlyargs\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
10522              goto failed;
10523          }
10524          len = PyList_GET_SIZE(tmp);
10525          posonlyargs = _Py_asdl_arg_seq_new(len, arena);
10526          if (posonlyargs == NULL) goto failed;
10527          for (i = 0; i < len; i++) {
10528              arg_ty val;
10529              PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
10530              Py_INCREF(tmp2);
10531              if (_Py_EnterRecursiveCall(" while traversing 'arguments' node")) {
10532                  goto failed;
10533              }
10534              res = obj2ast_arg(state, tmp2, &val, arena);
10535              _Py_LeaveRecursiveCall();
10536              Py_DECREF(tmp2);
10537              if (res != 0) goto failed;
10538              if (len != PyList_GET_SIZE(tmp)) {
10539                  PyErr_SetString(PyExc_RuntimeError, "arguments field \"posonlyargs\" changed size during iteration");
10540                  goto failed;
10541              }
10542              asdl_seq_SET(posonlyargs, i, val);
10543          }
10544          Py_CLEAR(tmp);
10545      }
10546      if (_PyObject_LookupAttr(obj, state->args, &tmp) < 0) {
10547          return 1;
10548      }
10549      if (tmp == NULL) {
10550          PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from arguments");
10551          return 1;
10552      }
10553      else {
10554          int res;
10555          Py_ssize_t len;
10556          Py_ssize_t i;
10557          if (!PyList_Check(tmp)) {
10558              PyErr_Format(PyExc_TypeError, "arguments field \"args\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
10559              goto failed;
10560          }
10561          len = PyList_GET_SIZE(tmp);
10562          args = _Py_asdl_arg_seq_new(len, arena);
10563          if (args == NULL) goto failed;
10564          for (i = 0; i < len; i++) {
10565              arg_ty val;
10566              PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
10567              Py_INCREF(tmp2);
10568              if (_Py_EnterRecursiveCall(" while traversing 'arguments' node")) {
10569                  goto failed;
10570              }
10571              res = obj2ast_arg(state, tmp2, &val, arena);
10572              _Py_LeaveRecursiveCall();
10573              Py_DECREF(tmp2);
10574              if (res != 0) goto failed;
10575              if (len != PyList_GET_SIZE(tmp)) {
10576                  PyErr_SetString(PyExc_RuntimeError, "arguments field \"args\" changed size during iteration");
10577                  goto failed;
10578              }
10579              asdl_seq_SET(args, i, val);
10580          }
10581          Py_CLEAR(tmp);
10582      }
10583      if (_PyObject_LookupAttr(obj, state->vararg, &tmp) < 0) {
10584          return 1;
10585      }
10586      if (tmp == NULL || tmp == Py_None) {
10587          Py_CLEAR(tmp);
10588          vararg = NULL;
10589      }
10590      else {
10591          int res;
10592          if (_Py_EnterRecursiveCall(" while traversing 'arguments' node")) {
10593              goto failed;
10594          }
10595          res = obj2ast_arg(state, tmp, &vararg, arena);
10596          _Py_LeaveRecursiveCall();
10597          if (res != 0) goto failed;
10598          Py_CLEAR(tmp);
10599      }
10600      if (_PyObject_LookupAttr(obj, state->kwonlyargs, &tmp) < 0) {
10601          return 1;
10602      }
10603      if (tmp == NULL) {
10604          PyErr_SetString(PyExc_TypeError, "required field \"kwonlyargs\" missing from arguments");
10605          return 1;
10606      }
10607      else {
10608          int res;
10609          Py_ssize_t len;
10610          Py_ssize_t i;
10611          if (!PyList_Check(tmp)) {
10612              PyErr_Format(PyExc_TypeError, "arguments field \"kwonlyargs\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
10613              goto failed;
10614          }
10615          len = PyList_GET_SIZE(tmp);
10616          kwonlyargs = _Py_asdl_arg_seq_new(len, arena);
10617          if (kwonlyargs == NULL) goto failed;
10618          for (i = 0; i < len; i++) {
10619              arg_ty val;
10620              PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
10621              Py_INCREF(tmp2);
10622              if (_Py_EnterRecursiveCall(" while traversing 'arguments' node")) {
10623                  goto failed;
10624              }
10625              res = obj2ast_arg(state, tmp2, &val, arena);
10626              _Py_LeaveRecursiveCall();
10627              Py_DECREF(tmp2);
10628              if (res != 0) goto failed;
10629              if (len != PyList_GET_SIZE(tmp)) {
10630                  PyErr_SetString(PyExc_RuntimeError, "arguments field \"kwonlyargs\" changed size during iteration");
10631                  goto failed;
10632              }
10633              asdl_seq_SET(kwonlyargs, i, val);
10634          }
10635          Py_CLEAR(tmp);
10636      }
10637      if (_PyObject_LookupAttr(obj, state->kw_defaults, &tmp) < 0) {
10638          return 1;
10639      }
10640      if (tmp == NULL) {
10641          PyErr_SetString(PyExc_TypeError, "required field \"kw_defaults\" missing from arguments");
10642          return 1;
10643      }
10644      else {
10645          int res;
10646          Py_ssize_t len;
10647          Py_ssize_t i;
10648          if (!PyList_Check(tmp)) {
10649              PyErr_Format(PyExc_TypeError, "arguments field \"kw_defaults\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
10650              goto failed;
10651          }
10652          len = PyList_GET_SIZE(tmp);
10653          kw_defaults = _Py_asdl_expr_seq_new(len, arena);
10654          if (kw_defaults == NULL) goto failed;
10655          for (i = 0; i < len; i++) {
10656              expr_ty val;
10657              PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
10658              Py_INCREF(tmp2);
10659              if (_Py_EnterRecursiveCall(" while traversing 'arguments' node")) {
10660                  goto failed;
10661              }
10662              res = obj2ast_expr(state, tmp2, &val, arena);
10663              _Py_LeaveRecursiveCall();
10664              Py_DECREF(tmp2);
10665              if (res != 0) goto failed;
10666              if (len != PyList_GET_SIZE(tmp)) {
10667                  PyErr_SetString(PyExc_RuntimeError, "arguments field \"kw_defaults\" changed size during iteration");
10668                  goto failed;
10669              }
10670              asdl_seq_SET(kw_defaults, i, val);
10671          }
10672          Py_CLEAR(tmp);
10673      }
10674      if (_PyObject_LookupAttr(obj, state->kwarg, &tmp) < 0) {
10675          return 1;
10676      }
10677      if (tmp == NULL || tmp == Py_None) {
10678          Py_CLEAR(tmp);
10679          kwarg = NULL;
10680      }
10681      else {
10682          int res;
10683          if (_Py_EnterRecursiveCall(" while traversing 'arguments' node")) {
10684              goto failed;
10685          }
10686          res = obj2ast_arg(state, tmp, &kwarg, arena);
10687          _Py_LeaveRecursiveCall();
10688          if (res != 0) goto failed;
10689          Py_CLEAR(tmp);
10690      }
10691      if (_PyObject_LookupAttr(obj, state->defaults, &tmp) < 0) {
10692          return 1;
10693      }
10694      if (tmp == NULL) {
10695          PyErr_SetString(PyExc_TypeError, "required field \"defaults\" missing from arguments");
10696          return 1;
10697      }
10698      else {
10699          int res;
10700          Py_ssize_t len;
10701          Py_ssize_t i;
10702          if (!PyList_Check(tmp)) {
10703              PyErr_Format(PyExc_TypeError, "arguments field \"defaults\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
10704              goto failed;
10705          }
10706          len = PyList_GET_SIZE(tmp);
10707          defaults = _Py_asdl_expr_seq_new(len, arena);
10708          if (defaults == NULL) goto failed;
10709          for (i = 0; i < len; i++) {
10710              expr_ty val;
10711              PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
10712              Py_INCREF(tmp2);
10713              if (_Py_EnterRecursiveCall(" while traversing 'arguments' node")) {
10714                  goto failed;
10715              }
10716              res = obj2ast_expr(state, tmp2, &val, arena);
10717              _Py_LeaveRecursiveCall();
10718              Py_DECREF(tmp2);
10719              if (res != 0) goto failed;
10720              if (len != PyList_GET_SIZE(tmp)) {
10721                  PyErr_SetString(PyExc_RuntimeError, "arguments field \"defaults\" changed size during iteration");
10722                  goto failed;
10723              }
10724              asdl_seq_SET(defaults, i, val);
10725          }
10726          Py_CLEAR(tmp);
10727      }
10728      *out = _PyAST_arguments(posonlyargs, args, vararg, kwonlyargs, kw_defaults,
10729                              kwarg, defaults, arena);
10730      return 0;
10731  failed:
10732      Py_XDECREF(tmp);
10733      return 1;
10734  }
10735  
10736  int
obj2ast_arg(struct ast_state * state,PyObject * obj,arg_ty * out,PyArena * arena)10737  obj2ast_arg(struct ast_state *state, PyObject* obj, arg_ty* out, PyArena* arena)
10738  {
10739      PyObject* tmp = NULL;
10740      identifier arg;
10741      expr_ty annotation;
10742      string type_comment;
10743      int lineno;
10744      int col_offset;
10745      int end_lineno;
10746      int end_col_offset;
10747  
10748      if (_PyObject_LookupAttr(obj, state->arg, &tmp) < 0) {
10749          return 1;
10750      }
10751      if (tmp == NULL) {
10752          PyErr_SetString(PyExc_TypeError, "required field \"arg\" missing from arg");
10753          return 1;
10754      }
10755      else {
10756          int res;
10757          if (_Py_EnterRecursiveCall(" while traversing 'arg' node")) {
10758              goto failed;
10759          }
10760          res = obj2ast_identifier(state, tmp, &arg, arena);
10761          _Py_LeaveRecursiveCall();
10762          if (res != 0) goto failed;
10763          Py_CLEAR(tmp);
10764      }
10765      if (_PyObject_LookupAttr(obj, state->annotation, &tmp) < 0) {
10766          return 1;
10767      }
10768      if (tmp == NULL || tmp == Py_None) {
10769          Py_CLEAR(tmp);
10770          annotation = NULL;
10771      }
10772      else {
10773          int res;
10774          if (_Py_EnterRecursiveCall(" while traversing 'arg' node")) {
10775              goto failed;
10776          }
10777          res = obj2ast_expr(state, tmp, &annotation, arena);
10778          _Py_LeaveRecursiveCall();
10779          if (res != 0) goto failed;
10780          Py_CLEAR(tmp);
10781      }
10782      if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) {
10783          return 1;
10784      }
10785      if (tmp == NULL || tmp == Py_None) {
10786          Py_CLEAR(tmp);
10787          type_comment = NULL;
10788      }
10789      else {
10790          int res;
10791          if (_Py_EnterRecursiveCall(" while traversing 'arg' node")) {
10792              goto failed;
10793          }
10794          res = obj2ast_string(state, tmp, &type_comment, arena);
10795          _Py_LeaveRecursiveCall();
10796          if (res != 0) goto failed;
10797          Py_CLEAR(tmp);
10798      }
10799      if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) {
10800          return 1;
10801      }
10802      if (tmp == NULL) {
10803          PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from arg");
10804          return 1;
10805      }
10806      else {
10807          int res;
10808          if (_Py_EnterRecursiveCall(" while traversing 'arg' node")) {
10809              goto failed;
10810          }
10811          res = obj2ast_int(state, tmp, &lineno, arena);
10812          _Py_LeaveRecursiveCall();
10813          if (res != 0) goto failed;
10814          Py_CLEAR(tmp);
10815      }
10816      if (_PyObject_LookupAttr(obj, state->col_offset, &tmp) < 0) {
10817          return 1;
10818      }
10819      if (tmp == NULL) {
10820          PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from arg");
10821          return 1;
10822      }
10823      else {
10824          int res;
10825          if (_Py_EnterRecursiveCall(" while traversing 'arg' node")) {
10826              goto failed;
10827          }
10828          res = obj2ast_int(state, tmp, &col_offset, arena);
10829          _Py_LeaveRecursiveCall();
10830          if (res != 0) goto failed;
10831          Py_CLEAR(tmp);
10832      }
10833      if (_PyObject_LookupAttr(obj, state->end_lineno, &tmp) < 0) {
10834          return 1;
10835      }
10836      if (tmp == NULL || tmp == Py_None) {
10837          Py_CLEAR(tmp);
10838          end_lineno = lineno;
10839      }
10840      else {
10841          int res;
10842          if (_Py_EnterRecursiveCall(" while traversing 'arg' node")) {
10843              goto failed;
10844          }
10845          res = obj2ast_int(state, tmp, &end_lineno, arena);
10846          _Py_LeaveRecursiveCall();
10847          if (res != 0) goto failed;
10848          Py_CLEAR(tmp);
10849      }
10850      if (_PyObject_LookupAttr(obj, state->end_col_offset, &tmp) < 0) {
10851          return 1;
10852      }
10853      if (tmp == NULL || tmp == Py_None) {
10854          Py_CLEAR(tmp);
10855          end_col_offset = col_offset;
10856      }
10857      else {
10858          int res;
10859          if (_Py_EnterRecursiveCall(" while traversing 'arg' node")) {
10860              goto failed;
10861          }
10862          res = obj2ast_int(state, tmp, &end_col_offset, arena);
10863          _Py_LeaveRecursiveCall();
10864          if (res != 0) goto failed;
10865          Py_CLEAR(tmp);
10866      }
10867      *out = _PyAST_arg(arg, annotation, type_comment, lineno, col_offset,
10868                        end_lineno, end_col_offset, arena);
10869      return 0;
10870  failed:
10871      Py_XDECREF(tmp);
10872      return 1;
10873  }
10874  
10875  int
obj2ast_keyword(struct ast_state * state,PyObject * obj,keyword_ty * out,PyArena * arena)10876  obj2ast_keyword(struct ast_state *state, PyObject* obj, keyword_ty* out,
10877                  PyArena* arena)
10878  {
10879      PyObject* tmp = NULL;
10880      identifier arg;
10881      expr_ty value;
10882      int lineno;
10883      int col_offset;
10884      int end_lineno;
10885      int end_col_offset;
10886  
10887      if (_PyObject_LookupAttr(obj, state->arg, &tmp) < 0) {
10888          return 1;
10889      }
10890      if (tmp == NULL || tmp == Py_None) {
10891          Py_CLEAR(tmp);
10892          arg = NULL;
10893      }
10894      else {
10895          int res;
10896          if (_Py_EnterRecursiveCall(" while traversing 'keyword' node")) {
10897              goto failed;
10898          }
10899          res = obj2ast_identifier(state, tmp, &arg, arena);
10900          _Py_LeaveRecursiveCall();
10901          if (res != 0) goto failed;
10902          Py_CLEAR(tmp);
10903      }
10904      if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
10905          return 1;
10906      }
10907      if (tmp == NULL) {
10908          PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from keyword");
10909          return 1;
10910      }
10911      else {
10912          int res;
10913          if (_Py_EnterRecursiveCall(" while traversing 'keyword' node")) {
10914              goto failed;
10915          }
10916          res = obj2ast_expr(state, tmp, &value, arena);
10917          _Py_LeaveRecursiveCall();
10918          if (res != 0) goto failed;
10919          Py_CLEAR(tmp);
10920      }
10921      if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) {
10922          return 1;
10923      }
10924      if (tmp == NULL) {
10925          PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from keyword");
10926          return 1;
10927      }
10928      else {
10929          int res;
10930          if (_Py_EnterRecursiveCall(" while traversing 'keyword' node")) {
10931              goto failed;
10932          }
10933          res = obj2ast_int(state, tmp, &lineno, arena);
10934          _Py_LeaveRecursiveCall();
10935          if (res != 0) goto failed;
10936          Py_CLEAR(tmp);
10937      }
10938      if (_PyObject_LookupAttr(obj, state->col_offset, &tmp) < 0) {
10939          return 1;
10940      }
10941      if (tmp == NULL) {
10942          PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from keyword");
10943          return 1;
10944      }
10945      else {
10946          int res;
10947          if (_Py_EnterRecursiveCall(" while traversing 'keyword' node")) {
10948              goto failed;
10949          }
10950          res = obj2ast_int(state, tmp, &col_offset, arena);
10951          _Py_LeaveRecursiveCall();
10952          if (res != 0) goto failed;
10953          Py_CLEAR(tmp);
10954      }
10955      if (_PyObject_LookupAttr(obj, state->end_lineno, &tmp) < 0) {
10956          return 1;
10957      }
10958      if (tmp == NULL || tmp == Py_None) {
10959          Py_CLEAR(tmp);
10960          end_lineno = lineno;
10961      }
10962      else {
10963          int res;
10964          if (_Py_EnterRecursiveCall(" while traversing 'keyword' node")) {
10965              goto failed;
10966          }
10967          res = obj2ast_int(state, tmp, &end_lineno, arena);
10968          _Py_LeaveRecursiveCall();
10969          if (res != 0) goto failed;
10970          Py_CLEAR(tmp);
10971      }
10972      if (_PyObject_LookupAttr(obj, state->end_col_offset, &tmp) < 0) {
10973          return 1;
10974      }
10975      if (tmp == NULL || tmp == Py_None) {
10976          Py_CLEAR(tmp);
10977          end_col_offset = col_offset;
10978      }
10979      else {
10980          int res;
10981          if (_Py_EnterRecursiveCall(" while traversing 'keyword' node")) {
10982              goto failed;
10983          }
10984          res = obj2ast_int(state, tmp, &end_col_offset, arena);
10985          _Py_LeaveRecursiveCall();
10986          if (res != 0) goto failed;
10987          Py_CLEAR(tmp);
10988      }
10989      *out = _PyAST_keyword(arg, value, lineno, col_offset, end_lineno,
10990                            end_col_offset, arena);
10991      return 0;
10992  failed:
10993      Py_XDECREF(tmp);
10994      return 1;
10995  }
10996  
10997  int
obj2ast_alias(struct ast_state * state,PyObject * obj,alias_ty * out,PyArena * arena)10998  obj2ast_alias(struct ast_state *state, PyObject* obj, alias_ty* out, PyArena*
10999                arena)
11000  {
11001      PyObject* tmp = NULL;
11002      identifier name;
11003      identifier asname;
11004      int lineno;
11005      int col_offset;
11006      int end_lineno;
11007      int end_col_offset;
11008  
11009      if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) {
11010          return 1;
11011      }
11012      if (tmp == NULL) {
11013          PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from alias");
11014          return 1;
11015      }
11016      else {
11017          int res;
11018          if (_Py_EnterRecursiveCall(" while traversing 'alias' node")) {
11019              goto failed;
11020          }
11021          res = obj2ast_identifier(state, tmp, &name, arena);
11022          _Py_LeaveRecursiveCall();
11023          if (res != 0) goto failed;
11024          Py_CLEAR(tmp);
11025      }
11026      if (_PyObject_LookupAttr(obj, state->asname, &tmp) < 0) {
11027          return 1;
11028      }
11029      if (tmp == NULL || tmp == Py_None) {
11030          Py_CLEAR(tmp);
11031          asname = NULL;
11032      }
11033      else {
11034          int res;
11035          if (_Py_EnterRecursiveCall(" while traversing 'alias' node")) {
11036              goto failed;
11037          }
11038          res = obj2ast_identifier(state, tmp, &asname, arena);
11039          _Py_LeaveRecursiveCall();
11040          if (res != 0) goto failed;
11041          Py_CLEAR(tmp);
11042      }
11043      if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) {
11044          return 1;
11045      }
11046      if (tmp == NULL) {
11047          PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from alias");
11048          return 1;
11049      }
11050      else {
11051          int res;
11052          if (_Py_EnterRecursiveCall(" while traversing 'alias' node")) {
11053              goto failed;
11054          }
11055          res = obj2ast_int(state, tmp, &lineno, arena);
11056          _Py_LeaveRecursiveCall();
11057          if (res != 0) goto failed;
11058          Py_CLEAR(tmp);
11059      }
11060      if (_PyObject_LookupAttr(obj, state->col_offset, &tmp) < 0) {
11061          return 1;
11062      }
11063      if (tmp == NULL) {
11064          PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from alias");
11065          return 1;
11066      }
11067      else {
11068          int res;
11069          if (_Py_EnterRecursiveCall(" while traversing 'alias' node")) {
11070              goto failed;
11071          }
11072          res = obj2ast_int(state, tmp, &col_offset, arena);
11073          _Py_LeaveRecursiveCall();
11074          if (res != 0) goto failed;
11075          Py_CLEAR(tmp);
11076      }
11077      if (_PyObject_LookupAttr(obj, state->end_lineno, &tmp) < 0) {
11078          return 1;
11079      }
11080      if (tmp == NULL || tmp == Py_None) {
11081          Py_CLEAR(tmp);
11082          end_lineno = lineno;
11083      }
11084      else {
11085          int res;
11086          if (_Py_EnterRecursiveCall(" while traversing 'alias' node")) {
11087              goto failed;
11088          }
11089          res = obj2ast_int(state, tmp, &end_lineno, arena);
11090          _Py_LeaveRecursiveCall();
11091          if (res != 0) goto failed;
11092          Py_CLEAR(tmp);
11093      }
11094      if (_PyObject_LookupAttr(obj, state->end_col_offset, &tmp) < 0) {
11095          return 1;
11096      }
11097      if (tmp == NULL || tmp == Py_None) {
11098          Py_CLEAR(tmp);
11099          end_col_offset = col_offset;
11100      }
11101      else {
11102          int res;
11103          if (_Py_EnterRecursiveCall(" while traversing 'alias' node")) {
11104              goto failed;
11105          }
11106          res = obj2ast_int(state, tmp, &end_col_offset, arena);
11107          _Py_LeaveRecursiveCall();
11108          if (res != 0) goto failed;
11109          Py_CLEAR(tmp);
11110      }
11111      *out = _PyAST_alias(name, asname, lineno, col_offset, end_lineno,
11112                          end_col_offset, arena);
11113      return 0;
11114  failed:
11115      Py_XDECREF(tmp);
11116      return 1;
11117  }
11118  
11119  int
obj2ast_withitem(struct ast_state * state,PyObject * obj,withitem_ty * out,PyArena * arena)11120  obj2ast_withitem(struct ast_state *state, PyObject* obj, withitem_ty* out,
11121                   PyArena* arena)
11122  {
11123      PyObject* tmp = NULL;
11124      expr_ty context_expr;
11125      expr_ty optional_vars;
11126  
11127      if (_PyObject_LookupAttr(obj, state->context_expr, &tmp) < 0) {
11128          return 1;
11129      }
11130      if (tmp == NULL) {
11131          PyErr_SetString(PyExc_TypeError, "required field \"context_expr\" missing from withitem");
11132          return 1;
11133      }
11134      else {
11135          int res;
11136          if (_Py_EnterRecursiveCall(" while traversing 'withitem' node")) {
11137              goto failed;
11138          }
11139          res = obj2ast_expr(state, tmp, &context_expr, arena);
11140          _Py_LeaveRecursiveCall();
11141          if (res != 0) goto failed;
11142          Py_CLEAR(tmp);
11143      }
11144      if (_PyObject_LookupAttr(obj, state->optional_vars, &tmp) < 0) {
11145          return 1;
11146      }
11147      if (tmp == NULL || tmp == Py_None) {
11148          Py_CLEAR(tmp);
11149          optional_vars = NULL;
11150      }
11151      else {
11152          int res;
11153          if (_Py_EnterRecursiveCall(" while traversing 'withitem' node")) {
11154              goto failed;
11155          }
11156          res = obj2ast_expr(state, tmp, &optional_vars, arena);
11157          _Py_LeaveRecursiveCall();
11158          if (res != 0) goto failed;
11159          Py_CLEAR(tmp);
11160      }
11161      *out = _PyAST_withitem(context_expr, optional_vars, arena);
11162      return 0;
11163  failed:
11164      Py_XDECREF(tmp);
11165      return 1;
11166  }
11167  
11168  int
obj2ast_match_case(struct ast_state * state,PyObject * obj,match_case_ty * out,PyArena * arena)11169  obj2ast_match_case(struct ast_state *state, PyObject* obj, match_case_ty* out,
11170                     PyArena* arena)
11171  {
11172      PyObject* tmp = NULL;
11173      pattern_ty pattern;
11174      expr_ty guard;
11175      asdl_stmt_seq* body;
11176  
11177      if (_PyObject_LookupAttr(obj, state->pattern, &tmp) < 0) {
11178          return 1;
11179      }
11180      if (tmp == NULL) {
11181          PyErr_SetString(PyExc_TypeError, "required field \"pattern\" missing from match_case");
11182          return 1;
11183      }
11184      else {
11185          int res;
11186          if (_Py_EnterRecursiveCall(" while traversing 'match_case' node")) {
11187              goto failed;
11188          }
11189          res = obj2ast_pattern(state, tmp, &pattern, arena);
11190          _Py_LeaveRecursiveCall();
11191          if (res != 0) goto failed;
11192          Py_CLEAR(tmp);
11193      }
11194      if (_PyObject_LookupAttr(obj, state->guard, &tmp) < 0) {
11195          return 1;
11196      }
11197      if (tmp == NULL || tmp == Py_None) {
11198          Py_CLEAR(tmp);
11199          guard = NULL;
11200      }
11201      else {
11202          int res;
11203          if (_Py_EnterRecursiveCall(" while traversing 'match_case' node")) {
11204              goto failed;
11205          }
11206          res = obj2ast_expr(state, tmp, &guard, arena);
11207          _Py_LeaveRecursiveCall();
11208          if (res != 0) goto failed;
11209          Py_CLEAR(tmp);
11210      }
11211      if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
11212          return 1;
11213      }
11214      if (tmp == NULL) {
11215          PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from match_case");
11216          return 1;
11217      }
11218      else {
11219          int res;
11220          Py_ssize_t len;
11221          Py_ssize_t i;
11222          if (!PyList_Check(tmp)) {
11223              PyErr_Format(PyExc_TypeError, "match_case field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
11224              goto failed;
11225          }
11226          len = PyList_GET_SIZE(tmp);
11227          body = _Py_asdl_stmt_seq_new(len, arena);
11228          if (body == NULL) goto failed;
11229          for (i = 0; i < len; i++) {
11230              stmt_ty val;
11231              PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
11232              Py_INCREF(tmp2);
11233              if (_Py_EnterRecursiveCall(" while traversing 'match_case' node")) {
11234                  goto failed;
11235              }
11236              res = obj2ast_stmt(state, tmp2, &val, arena);
11237              _Py_LeaveRecursiveCall();
11238              Py_DECREF(tmp2);
11239              if (res != 0) goto failed;
11240              if (len != PyList_GET_SIZE(tmp)) {
11241                  PyErr_SetString(PyExc_RuntimeError, "match_case field \"body\" changed size during iteration");
11242                  goto failed;
11243              }
11244              asdl_seq_SET(body, i, val);
11245          }
11246          Py_CLEAR(tmp);
11247      }
11248      *out = _PyAST_match_case(pattern, guard, body, arena);
11249      return 0;
11250  failed:
11251      Py_XDECREF(tmp);
11252      return 1;
11253  }
11254  
11255  int
obj2ast_pattern(struct ast_state * state,PyObject * obj,pattern_ty * out,PyArena * arena)11256  obj2ast_pattern(struct ast_state *state, PyObject* obj, pattern_ty* out,
11257                  PyArena* arena)
11258  {
11259      int isinstance;
11260  
11261      PyObject *tmp = NULL;
11262      PyObject *tp;
11263      int lineno;
11264      int col_offset;
11265      int end_lineno;
11266      int end_col_offset;
11267  
11268      if (obj == Py_None) {
11269          *out = NULL;
11270          return 0;
11271      }
11272      if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) {
11273          return 1;
11274      }
11275      if (tmp == NULL) {
11276          PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from pattern");
11277          return 1;
11278      }
11279      else {
11280          int res;
11281          if (_Py_EnterRecursiveCall(" while traversing 'pattern' node")) {
11282              goto failed;
11283          }
11284          res = obj2ast_int(state, tmp, &lineno, arena);
11285          _Py_LeaveRecursiveCall();
11286          if (res != 0) goto failed;
11287          Py_CLEAR(tmp);
11288      }
11289      if (_PyObject_LookupAttr(obj, state->col_offset, &tmp) < 0) {
11290          return 1;
11291      }
11292      if (tmp == NULL) {
11293          PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from pattern");
11294          return 1;
11295      }
11296      else {
11297          int res;
11298          if (_Py_EnterRecursiveCall(" while traversing 'pattern' node")) {
11299              goto failed;
11300          }
11301          res = obj2ast_int(state, tmp, &col_offset, arena);
11302          _Py_LeaveRecursiveCall();
11303          if (res != 0) goto failed;
11304          Py_CLEAR(tmp);
11305      }
11306      if (_PyObject_LookupAttr(obj, state->end_lineno, &tmp) < 0) {
11307          return 1;
11308      }
11309      if (tmp == NULL) {
11310          PyErr_SetString(PyExc_TypeError, "required field \"end_lineno\" missing from pattern");
11311          return 1;
11312      }
11313      else {
11314          int res;
11315          if (_Py_EnterRecursiveCall(" while traversing 'pattern' node")) {
11316              goto failed;
11317          }
11318          res = obj2ast_int(state, tmp, &end_lineno, arena);
11319          _Py_LeaveRecursiveCall();
11320          if (res != 0) goto failed;
11321          Py_CLEAR(tmp);
11322      }
11323      if (_PyObject_LookupAttr(obj, state->end_col_offset, &tmp) < 0) {
11324          return 1;
11325      }
11326      if (tmp == NULL) {
11327          PyErr_SetString(PyExc_TypeError, "required field \"end_col_offset\" missing from pattern");
11328          return 1;
11329      }
11330      else {
11331          int res;
11332          if (_Py_EnterRecursiveCall(" while traversing 'pattern' node")) {
11333              goto failed;
11334          }
11335          res = obj2ast_int(state, tmp, &end_col_offset, arena);
11336          _Py_LeaveRecursiveCall();
11337          if (res != 0) goto failed;
11338          Py_CLEAR(tmp);
11339      }
11340      tp = state->MatchValue_type;
11341      isinstance = PyObject_IsInstance(obj, tp);
11342      if (isinstance == -1) {
11343          return 1;
11344      }
11345      if (isinstance) {
11346          expr_ty value;
11347  
11348          if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
11349              return 1;
11350          }
11351          if (tmp == NULL) {
11352              PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from MatchValue");
11353              return 1;
11354          }
11355          else {
11356              int res;
11357              if (_Py_EnterRecursiveCall(" while traversing 'MatchValue' node")) {
11358                  goto failed;
11359              }
11360              res = obj2ast_expr(state, tmp, &value, arena);
11361              _Py_LeaveRecursiveCall();
11362              if (res != 0) goto failed;
11363              Py_CLEAR(tmp);
11364          }
11365          *out = _PyAST_MatchValue(value, lineno, col_offset, end_lineno,
11366                                   end_col_offset, arena);
11367          if (*out == NULL) goto failed;
11368          return 0;
11369      }
11370      tp = state->MatchSingleton_type;
11371      isinstance = PyObject_IsInstance(obj, tp);
11372      if (isinstance == -1) {
11373          return 1;
11374      }
11375      if (isinstance) {
11376          constant value;
11377  
11378          if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
11379              return 1;
11380          }
11381          if (tmp == NULL) {
11382              PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from MatchSingleton");
11383              return 1;
11384          }
11385          else {
11386              int res;
11387              if (_Py_EnterRecursiveCall(" while traversing 'MatchSingleton' node")) {
11388                  goto failed;
11389              }
11390              res = obj2ast_constant(state, tmp, &value, arena);
11391              _Py_LeaveRecursiveCall();
11392              if (res != 0) goto failed;
11393              Py_CLEAR(tmp);
11394          }
11395          *out = _PyAST_MatchSingleton(value, lineno, col_offset, end_lineno,
11396                                       end_col_offset, arena);
11397          if (*out == NULL) goto failed;
11398          return 0;
11399      }
11400      tp = state->MatchSequence_type;
11401      isinstance = PyObject_IsInstance(obj, tp);
11402      if (isinstance == -1) {
11403          return 1;
11404      }
11405      if (isinstance) {
11406          asdl_pattern_seq* patterns;
11407  
11408          if (_PyObject_LookupAttr(obj, state->patterns, &tmp) < 0) {
11409              return 1;
11410          }
11411          if (tmp == NULL) {
11412              PyErr_SetString(PyExc_TypeError, "required field \"patterns\" missing from MatchSequence");
11413              return 1;
11414          }
11415          else {
11416              int res;
11417              Py_ssize_t len;
11418              Py_ssize_t i;
11419              if (!PyList_Check(tmp)) {
11420                  PyErr_Format(PyExc_TypeError, "MatchSequence field \"patterns\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
11421                  goto failed;
11422              }
11423              len = PyList_GET_SIZE(tmp);
11424              patterns = _Py_asdl_pattern_seq_new(len, arena);
11425              if (patterns == NULL) goto failed;
11426              for (i = 0; i < len; i++) {
11427                  pattern_ty val;
11428                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
11429                  Py_INCREF(tmp2);
11430                  if (_Py_EnterRecursiveCall(" while traversing 'MatchSequence' node")) {
11431                      goto failed;
11432                  }
11433                  res = obj2ast_pattern(state, tmp2, &val, arena);
11434                  _Py_LeaveRecursiveCall();
11435                  Py_DECREF(tmp2);
11436                  if (res != 0) goto failed;
11437                  if (len != PyList_GET_SIZE(tmp)) {
11438                      PyErr_SetString(PyExc_RuntimeError, "MatchSequence field \"patterns\" changed size during iteration");
11439                      goto failed;
11440                  }
11441                  asdl_seq_SET(patterns, i, val);
11442              }
11443              Py_CLEAR(tmp);
11444          }
11445          *out = _PyAST_MatchSequence(patterns, lineno, col_offset, end_lineno,
11446                                      end_col_offset, arena);
11447          if (*out == NULL) goto failed;
11448          return 0;
11449      }
11450      tp = state->MatchMapping_type;
11451      isinstance = PyObject_IsInstance(obj, tp);
11452      if (isinstance == -1) {
11453          return 1;
11454      }
11455      if (isinstance) {
11456          asdl_expr_seq* keys;
11457          asdl_pattern_seq* patterns;
11458          identifier rest;
11459  
11460          if (_PyObject_LookupAttr(obj, state->keys, &tmp) < 0) {
11461              return 1;
11462          }
11463          if (tmp == NULL) {
11464              PyErr_SetString(PyExc_TypeError, "required field \"keys\" missing from MatchMapping");
11465              return 1;
11466          }
11467          else {
11468              int res;
11469              Py_ssize_t len;
11470              Py_ssize_t i;
11471              if (!PyList_Check(tmp)) {
11472                  PyErr_Format(PyExc_TypeError, "MatchMapping field \"keys\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
11473                  goto failed;
11474              }
11475              len = PyList_GET_SIZE(tmp);
11476              keys = _Py_asdl_expr_seq_new(len, arena);
11477              if (keys == NULL) goto failed;
11478              for (i = 0; i < len; i++) {
11479                  expr_ty val;
11480                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
11481                  Py_INCREF(tmp2);
11482                  if (_Py_EnterRecursiveCall(" while traversing 'MatchMapping' node")) {
11483                      goto failed;
11484                  }
11485                  res = obj2ast_expr(state, tmp2, &val, arena);
11486                  _Py_LeaveRecursiveCall();
11487                  Py_DECREF(tmp2);
11488                  if (res != 0) goto failed;
11489                  if (len != PyList_GET_SIZE(tmp)) {
11490                      PyErr_SetString(PyExc_RuntimeError, "MatchMapping field \"keys\" changed size during iteration");
11491                      goto failed;
11492                  }
11493                  asdl_seq_SET(keys, i, val);
11494              }
11495              Py_CLEAR(tmp);
11496          }
11497          if (_PyObject_LookupAttr(obj, state->patterns, &tmp) < 0) {
11498              return 1;
11499          }
11500          if (tmp == NULL) {
11501              PyErr_SetString(PyExc_TypeError, "required field \"patterns\" missing from MatchMapping");
11502              return 1;
11503          }
11504          else {
11505              int res;
11506              Py_ssize_t len;
11507              Py_ssize_t i;
11508              if (!PyList_Check(tmp)) {
11509                  PyErr_Format(PyExc_TypeError, "MatchMapping field \"patterns\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
11510                  goto failed;
11511              }
11512              len = PyList_GET_SIZE(tmp);
11513              patterns = _Py_asdl_pattern_seq_new(len, arena);
11514              if (patterns == NULL) goto failed;
11515              for (i = 0; i < len; i++) {
11516                  pattern_ty val;
11517                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
11518                  Py_INCREF(tmp2);
11519                  if (_Py_EnterRecursiveCall(" while traversing 'MatchMapping' node")) {
11520                      goto failed;
11521                  }
11522                  res = obj2ast_pattern(state, tmp2, &val, arena);
11523                  _Py_LeaveRecursiveCall();
11524                  Py_DECREF(tmp2);
11525                  if (res != 0) goto failed;
11526                  if (len != PyList_GET_SIZE(tmp)) {
11527                      PyErr_SetString(PyExc_RuntimeError, "MatchMapping field \"patterns\" changed size during iteration");
11528                      goto failed;
11529                  }
11530                  asdl_seq_SET(patterns, i, val);
11531              }
11532              Py_CLEAR(tmp);
11533          }
11534          if (_PyObject_LookupAttr(obj, state->rest, &tmp) < 0) {
11535              return 1;
11536          }
11537          if (tmp == NULL || tmp == Py_None) {
11538              Py_CLEAR(tmp);
11539              rest = NULL;
11540          }
11541          else {
11542              int res;
11543              if (_Py_EnterRecursiveCall(" while traversing 'MatchMapping' node")) {
11544                  goto failed;
11545              }
11546              res = obj2ast_identifier(state, tmp, &rest, arena);
11547              _Py_LeaveRecursiveCall();
11548              if (res != 0) goto failed;
11549              Py_CLEAR(tmp);
11550          }
11551          *out = _PyAST_MatchMapping(keys, patterns, rest, lineno, col_offset,
11552                                     end_lineno, end_col_offset, arena);
11553          if (*out == NULL) goto failed;
11554          return 0;
11555      }
11556      tp = state->MatchClass_type;
11557      isinstance = PyObject_IsInstance(obj, tp);
11558      if (isinstance == -1) {
11559          return 1;
11560      }
11561      if (isinstance) {
11562          expr_ty cls;
11563          asdl_pattern_seq* patterns;
11564          asdl_identifier_seq* kwd_attrs;
11565          asdl_pattern_seq* kwd_patterns;
11566  
11567          if (_PyObject_LookupAttr(obj, state->cls, &tmp) < 0) {
11568              return 1;
11569          }
11570          if (tmp == NULL) {
11571              PyErr_SetString(PyExc_TypeError, "required field \"cls\" missing from MatchClass");
11572              return 1;
11573          }
11574          else {
11575              int res;
11576              if (_Py_EnterRecursiveCall(" while traversing 'MatchClass' node")) {
11577                  goto failed;
11578              }
11579              res = obj2ast_expr(state, tmp, &cls, arena);
11580              _Py_LeaveRecursiveCall();
11581              if (res != 0) goto failed;
11582              Py_CLEAR(tmp);
11583          }
11584          if (_PyObject_LookupAttr(obj, state->patterns, &tmp) < 0) {
11585              return 1;
11586          }
11587          if (tmp == NULL) {
11588              PyErr_SetString(PyExc_TypeError, "required field \"patterns\" missing from MatchClass");
11589              return 1;
11590          }
11591          else {
11592              int res;
11593              Py_ssize_t len;
11594              Py_ssize_t i;
11595              if (!PyList_Check(tmp)) {
11596                  PyErr_Format(PyExc_TypeError, "MatchClass field \"patterns\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
11597                  goto failed;
11598              }
11599              len = PyList_GET_SIZE(tmp);
11600              patterns = _Py_asdl_pattern_seq_new(len, arena);
11601              if (patterns == NULL) goto failed;
11602              for (i = 0; i < len; i++) {
11603                  pattern_ty val;
11604                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
11605                  Py_INCREF(tmp2);
11606                  if (_Py_EnterRecursiveCall(" while traversing 'MatchClass' node")) {
11607                      goto failed;
11608                  }
11609                  res = obj2ast_pattern(state, tmp2, &val, arena);
11610                  _Py_LeaveRecursiveCall();
11611                  Py_DECREF(tmp2);
11612                  if (res != 0) goto failed;
11613                  if (len != PyList_GET_SIZE(tmp)) {
11614                      PyErr_SetString(PyExc_RuntimeError, "MatchClass field \"patterns\" changed size during iteration");
11615                      goto failed;
11616                  }
11617                  asdl_seq_SET(patterns, i, val);
11618              }
11619              Py_CLEAR(tmp);
11620          }
11621          if (_PyObject_LookupAttr(obj, state->kwd_attrs, &tmp) < 0) {
11622              return 1;
11623          }
11624          if (tmp == NULL) {
11625              PyErr_SetString(PyExc_TypeError, "required field \"kwd_attrs\" missing from MatchClass");
11626              return 1;
11627          }
11628          else {
11629              int res;
11630              Py_ssize_t len;
11631              Py_ssize_t i;
11632              if (!PyList_Check(tmp)) {
11633                  PyErr_Format(PyExc_TypeError, "MatchClass field \"kwd_attrs\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
11634                  goto failed;
11635              }
11636              len = PyList_GET_SIZE(tmp);
11637              kwd_attrs = _Py_asdl_identifier_seq_new(len, arena);
11638              if (kwd_attrs == NULL) goto failed;
11639              for (i = 0; i < len; i++) {
11640                  identifier val;
11641                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
11642                  Py_INCREF(tmp2);
11643                  if (_Py_EnterRecursiveCall(" while traversing 'MatchClass' node")) {
11644                      goto failed;
11645                  }
11646                  res = obj2ast_identifier(state, tmp2, &val, arena);
11647                  _Py_LeaveRecursiveCall();
11648                  Py_DECREF(tmp2);
11649                  if (res != 0) goto failed;
11650                  if (len != PyList_GET_SIZE(tmp)) {
11651                      PyErr_SetString(PyExc_RuntimeError, "MatchClass field \"kwd_attrs\" changed size during iteration");
11652                      goto failed;
11653                  }
11654                  asdl_seq_SET(kwd_attrs, i, val);
11655              }
11656              Py_CLEAR(tmp);
11657          }
11658          if (_PyObject_LookupAttr(obj, state->kwd_patterns, &tmp) < 0) {
11659              return 1;
11660          }
11661          if (tmp == NULL) {
11662              PyErr_SetString(PyExc_TypeError, "required field \"kwd_patterns\" missing from MatchClass");
11663              return 1;
11664          }
11665          else {
11666              int res;
11667              Py_ssize_t len;
11668              Py_ssize_t i;
11669              if (!PyList_Check(tmp)) {
11670                  PyErr_Format(PyExc_TypeError, "MatchClass field \"kwd_patterns\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
11671                  goto failed;
11672              }
11673              len = PyList_GET_SIZE(tmp);
11674              kwd_patterns = _Py_asdl_pattern_seq_new(len, arena);
11675              if (kwd_patterns == NULL) goto failed;
11676              for (i = 0; i < len; i++) {
11677                  pattern_ty val;
11678                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
11679                  Py_INCREF(tmp2);
11680                  if (_Py_EnterRecursiveCall(" while traversing 'MatchClass' node")) {
11681                      goto failed;
11682                  }
11683                  res = obj2ast_pattern(state, tmp2, &val, arena);
11684                  _Py_LeaveRecursiveCall();
11685                  Py_DECREF(tmp2);
11686                  if (res != 0) goto failed;
11687                  if (len != PyList_GET_SIZE(tmp)) {
11688                      PyErr_SetString(PyExc_RuntimeError, "MatchClass field \"kwd_patterns\" changed size during iteration");
11689                      goto failed;
11690                  }
11691                  asdl_seq_SET(kwd_patterns, i, val);
11692              }
11693              Py_CLEAR(tmp);
11694          }
11695          *out = _PyAST_MatchClass(cls, patterns, kwd_attrs, kwd_patterns,
11696                                   lineno, col_offset, end_lineno,
11697                                   end_col_offset, arena);
11698          if (*out == NULL) goto failed;
11699          return 0;
11700      }
11701      tp = state->MatchStar_type;
11702      isinstance = PyObject_IsInstance(obj, tp);
11703      if (isinstance == -1) {
11704          return 1;
11705      }
11706      if (isinstance) {
11707          identifier name;
11708  
11709          if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) {
11710              return 1;
11711          }
11712          if (tmp == NULL || tmp == Py_None) {
11713              Py_CLEAR(tmp);
11714              name = NULL;
11715          }
11716          else {
11717              int res;
11718              if (_Py_EnterRecursiveCall(" while traversing 'MatchStar' node")) {
11719                  goto failed;
11720              }
11721              res = obj2ast_identifier(state, tmp, &name, arena);
11722              _Py_LeaveRecursiveCall();
11723              if (res != 0) goto failed;
11724              Py_CLEAR(tmp);
11725          }
11726          *out = _PyAST_MatchStar(name, lineno, col_offset, end_lineno,
11727                                  end_col_offset, arena);
11728          if (*out == NULL) goto failed;
11729          return 0;
11730      }
11731      tp = state->MatchAs_type;
11732      isinstance = PyObject_IsInstance(obj, tp);
11733      if (isinstance == -1) {
11734          return 1;
11735      }
11736      if (isinstance) {
11737          pattern_ty pattern;
11738          identifier name;
11739  
11740          if (_PyObject_LookupAttr(obj, state->pattern, &tmp) < 0) {
11741              return 1;
11742          }
11743          if (tmp == NULL || tmp == Py_None) {
11744              Py_CLEAR(tmp);
11745              pattern = NULL;
11746          }
11747          else {
11748              int res;
11749              if (_Py_EnterRecursiveCall(" while traversing 'MatchAs' node")) {
11750                  goto failed;
11751              }
11752              res = obj2ast_pattern(state, tmp, &pattern, arena);
11753              _Py_LeaveRecursiveCall();
11754              if (res != 0) goto failed;
11755              Py_CLEAR(tmp);
11756          }
11757          if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) {
11758              return 1;
11759          }
11760          if (tmp == NULL || tmp == Py_None) {
11761              Py_CLEAR(tmp);
11762              name = NULL;
11763          }
11764          else {
11765              int res;
11766              if (_Py_EnterRecursiveCall(" while traversing 'MatchAs' node")) {
11767                  goto failed;
11768              }
11769              res = obj2ast_identifier(state, tmp, &name, arena);
11770              _Py_LeaveRecursiveCall();
11771              if (res != 0) goto failed;
11772              Py_CLEAR(tmp);
11773          }
11774          *out = _PyAST_MatchAs(pattern, name, lineno, col_offset, end_lineno,
11775                                end_col_offset, arena);
11776          if (*out == NULL) goto failed;
11777          return 0;
11778      }
11779      tp = state->MatchOr_type;
11780      isinstance = PyObject_IsInstance(obj, tp);
11781      if (isinstance == -1) {
11782          return 1;
11783      }
11784      if (isinstance) {
11785          asdl_pattern_seq* patterns;
11786  
11787          if (_PyObject_LookupAttr(obj, state->patterns, &tmp) < 0) {
11788              return 1;
11789          }
11790          if (tmp == NULL) {
11791              PyErr_SetString(PyExc_TypeError, "required field \"patterns\" missing from MatchOr");
11792              return 1;
11793          }
11794          else {
11795              int res;
11796              Py_ssize_t len;
11797              Py_ssize_t i;
11798              if (!PyList_Check(tmp)) {
11799                  PyErr_Format(PyExc_TypeError, "MatchOr field \"patterns\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
11800                  goto failed;
11801              }
11802              len = PyList_GET_SIZE(tmp);
11803              patterns = _Py_asdl_pattern_seq_new(len, arena);
11804              if (patterns == NULL) goto failed;
11805              for (i = 0; i < len; i++) {
11806                  pattern_ty val;
11807                  PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
11808                  Py_INCREF(tmp2);
11809                  if (_Py_EnterRecursiveCall(" while traversing 'MatchOr' node")) {
11810                      goto failed;
11811                  }
11812                  res = obj2ast_pattern(state, tmp2, &val, arena);
11813                  _Py_LeaveRecursiveCall();
11814                  Py_DECREF(tmp2);
11815                  if (res != 0) goto failed;
11816                  if (len != PyList_GET_SIZE(tmp)) {
11817                      PyErr_SetString(PyExc_RuntimeError, "MatchOr field \"patterns\" changed size during iteration");
11818                      goto failed;
11819                  }
11820                  asdl_seq_SET(patterns, i, val);
11821              }
11822              Py_CLEAR(tmp);
11823          }
11824          *out = _PyAST_MatchOr(patterns, lineno, col_offset, end_lineno,
11825                                end_col_offset, arena);
11826          if (*out == NULL) goto failed;
11827          return 0;
11828      }
11829  
11830      PyErr_Format(PyExc_TypeError, "expected some sort of pattern, but got %R", obj);
11831      failed:
11832      Py_XDECREF(tmp);
11833      return 1;
11834  }
11835  
11836  int
obj2ast_type_ignore(struct ast_state * state,PyObject * obj,type_ignore_ty * out,PyArena * arena)11837  obj2ast_type_ignore(struct ast_state *state, PyObject* obj, type_ignore_ty*
11838                      out, PyArena* arena)
11839  {
11840      int isinstance;
11841  
11842      PyObject *tmp = NULL;
11843      PyObject *tp;
11844  
11845      if (obj == Py_None) {
11846          *out = NULL;
11847          return 0;
11848      }
11849      tp = state->TypeIgnore_type;
11850      isinstance = PyObject_IsInstance(obj, tp);
11851      if (isinstance == -1) {
11852          return 1;
11853      }
11854      if (isinstance) {
11855          int lineno;
11856          string tag;
11857  
11858          if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) {
11859              return 1;
11860          }
11861          if (tmp == NULL) {
11862              PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from TypeIgnore");
11863              return 1;
11864          }
11865          else {
11866              int res;
11867              if (_Py_EnterRecursiveCall(" while traversing 'TypeIgnore' node")) {
11868                  goto failed;
11869              }
11870              res = obj2ast_int(state, tmp, &lineno, arena);
11871              _Py_LeaveRecursiveCall();
11872              if (res != 0) goto failed;
11873              Py_CLEAR(tmp);
11874          }
11875          if (_PyObject_LookupAttr(obj, state->tag, &tmp) < 0) {
11876              return 1;
11877          }
11878          if (tmp == NULL) {
11879              PyErr_SetString(PyExc_TypeError, "required field \"tag\" missing from TypeIgnore");
11880              return 1;
11881          }
11882          else {
11883              int res;
11884              if (_Py_EnterRecursiveCall(" while traversing 'TypeIgnore' node")) {
11885                  goto failed;
11886              }
11887              res = obj2ast_string(state, tmp, &tag, arena);
11888              _Py_LeaveRecursiveCall();
11889              if (res != 0) goto failed;
11890              Py_CLEAR(tmp);
11891          }
11892          *out = _PyAST_TypeIgnore(lineno, tag, arena);
11893          if (*out == NULL) goto failed;
11894          return 0;
11895      }
11896  
11897      PyErr_Format(PyExc_TypeError, "expected some sort of type_ignore, but got %R", obj);
11898      failed:
11899      Py_XDECREF(tmp);
11900      return 1;
11901  }
11902  
11903  
11904  static int
astmodule_exec(PyObject * m)11905  astmodule_exec(PyObject *m)
11906  {
11907      struct ast_state *state = get_ast_state();
11908      if (state == NULL) {
11909          return -1;
11910      }
11911      if (PyModule_AddObjectRef(m, "AST", state->AST_type) < 0) {
11912          return -1;
11913      }
11914      if (PyModule_AddIntMacro(m, PyCF_ALLOW_TOP_LEVEL_AWAIT) < 0) {
11915          return -1;
11916      }
11917      if (PyModule_AddIntMacro(m, PyCF_ONLY_AST) < 0) {
11918          return -1;
11919      }
11920      if (PyModule_AddIntMacro(m, PyCF_TYPE_COMMENTS) < 0) {
11921          return -1;
11922      }
11923      if (PyModule_AddObjectRef(m, "mod", state->mod_type) < 0) {
11924          return -1;
11925      }
11926      if (PyModule_AddObjectRef(m, "Module", state->Module_type) < 0) {
11927          return -1;
11928      }
11929      if (PyModule_AddObjectRef(m, "Interactive", state->Interactive_type) < 0) {
11930          return -1;
11931      }
11932      if (PyModule_AddObjectRef(m, "Expression", state->Expression_type) < 0) {
11933          return -1;
11934      }
11935      if (PyModule_AddObjectRef(m, "FunctionType", state->FunctionType_type) < 0)
11936          {
11937          return -1;
11938      }
11939      if (PyModule_AddObjectRef(m, "stmt", state->stmt_type) < 0) {
11940          return -1;
11941      }
11942      if (PyModule_AddObjectRef(m, "FunctionDef", state->FunctionDef_type) < 0) {
11943          return -1;
11944      }
11945      if (PyModule_AddObjectRef(m, "AsyncFunctionDef",
11946          state->AsyncFunctionDef_type) < 0) {
11947          return -1;
11948      }
11949      if (PyModule_AddObjectRef(m, "ClassDef", state->ClassDef_type) < 0) {
11950          return -1;
11951      }
11952      if (PyModule_AddObjectRef(m, "Return", state->Return_type) < 0) {
11953          return -1;
11954      }
11955      if (PyModule_AddObjectRef(m, "Delete", state->Delete_type) < 0) {
11956          return -1;
11957      }
11958      if (PyModule_AddObjectRef(m, "Assign", state->Assign_type) < 0) {
11959          return -1;
11960      }
11961      if (PyModule_AddObjectRef(m, "AugAssign", state->AugAssign_type) < 0) {
11962          return -1;
11963      }
11964      if (PyModule_AddObjectRef(m, "AnnAssign", state->AnnAssign_type) < 0) {
11965          return -1;
11966      }
11967      if (PyModule_AddObjectRef(m, "For", state->For_type) < 0) {
11968          return -1;
11969      }
11970      if (PyModule_AddObjectRef(m, "AsyncFor", state->AsyncFor_type) < 0) {
11971          return -1;
11972      }
11973      if (PyModule_AddObjectRef(m, "While", state->While_type) < 0) {
11974          return -1;
11975      }
11976      if (PyModule_AddObjectRef(m, "If", state->If_type) < 0) {
11977          return -1;
11978      }
11979      if (PyModule_AddObjectRef(m, "With", state->With_type) < 0) {
11980          return -1;
11981      }
11982      if (PyModule_AddObjectRef(m, "AsyncWith", state->AsyncWith_type) < 0) {
11983          return -1;
11984      }
11985      if (PyModule_AddObjectRef(m, "Match", state->Match_type) < 0) {
11986          return -1;
11987      }
11988      if (PyModule_AddObjectRef(m, "Raise", state->Raise_type) < 0) {
11989          return -1;
11990      }
11991      if (PyModule_AddObjectRef(m, "Try", state->Try_type) < 0) {
11992          return -1;
11993      }
11994      if (PyModule_AddObjectRef(m, "TryStar", state->TryStar_type) < 0) {
11995          return -1;
11996      }
11997      if (PyModule_AddObjectRef(m, "Assert", state->Assert_type) < 0) {
11998          return -1;
11999      }
12000      if (PyModule_AddObjectRef(m, "Import", state->Import_type) < 0) {
12001          return -1;
12002      }
12003      if (PyModule_AddObjectRef(m, "ImportFrom", state->ImportFrom_type) < 0) {
12004          return -1;
12005      }
12006      if (PyModule_AddObjectRef(m, "Global", state->Global_type) < 0) {
12007          return -1;
12008      }
12009      if (PyModule_AddObjectRef(m, "Nonlocal", state->Nonlocal_type) < 0) {
12010          return -1;
12011      }
12012      if (PyModule_AddObjectRef(m, "Expr", state->Expr_type) < 0) {
12013          return -1;
12014      }
12015      if (PyModule_AddObjectRef(m, "Pass", state->Pass_type) < 0) {
12016          return -1;
12017      }
12018      if (PyModule_AddObjectRef(m, "Break", state->Break_type) < 0) {
12019          return -1;
12020      }
12021      if (PyModule_AddObjectRef(m, "Continue", state->Continue_type) < 0) {
12022          return -1;
12023      }
12024      if (PyModule_AddObjectRef(m, "expr", state->expr_type) < 0) {
12025          return -1;
12026      }
12027      if (PyModule_AddObjectRef(m, "BoolOp", state->BoolOp_type) < 0) {
12028          return -1;
12029      }
12030      if (PyModule_AddObjectRef(m, "NamedExpr", state->NamedExpr_type) < 0) {
12031          return -1;
12032      }
12033      if (PyModule_AddObjectRef(m, "BinOp", state->BinOp_type) < 0) {
12034          return -1;
12035      }
12036      if (PyModule_AddObjectRef(m, "UnaryOp", state->UnaryOp_type) < 0) {
12037          return -1;
12038      }
12039      if (PyModule_AddObjectRef(m, "Lambda", state->Lambda_type) < 0) {
12040          return -1;
12041      }
12042      if (PyModule_AddObjectRef(m, "IfExp", state->IfExp_type) < 0) {
12043          return -1;
12044      }
12045      if (PyModule_AddObjectRef(m, "Dict", state->Dict_type) < 0) {
12046          return -1;
12047      }
12048      if (PyModule_AddObjectRef(m, "Set", state->Set_type) < 0) {
12049          return -1;
12050      }
12051      if (PyModule_AddObjectRef(m, "ListComp", state->ListComp_type) < 0) {
12052          return -1;
12053      }
12054      if (PyModule_AddObjectRef(m, "SetComp", state->SetComp_type) < 0) {
12055          return -1;
12056      }
12057      if (PyModule_AddObjectRef(m, "DictComp", state->DictComp_type) < 0) {
12058          return -1;
12059      }
12060      if (PyModule_AddObjectRef(m, "GeneratorExp", state->GeneratorExp_type) < 0)
12061          {
12062          return -1;
12063      }
12064      if (PyModule_AddObjectRef(m, "Await", state->Await_type) < 0) {
12065          return -1;
12066      }
12067      if (PyModule_AddObjectRef(m, "Yield", state->Yield_type) < 0) {
12068          return -1;
12069      }
12070      if (PyModule_AddObjectRef(m, "YieldFrom", state->YieldFrom_type) < 0) {
12071          return -1;
12072      }
12073      if (PyModule_AddObjectRef(m, "Compare", state->Compare_type) < 0) {
12074          return -1;
12075      }
12076      if (PyModule_AddObjectRef(m, "Call", state->Call_type) < 0) {
12077          return -1;
12078      }
12079      if (PyModule_AddObjectRef(m, "FormattedValue", state->FormattedValue_type)
12080          < 0) {
12081          return -1;
12082      }
12083      if (PyModule_AddObjectRef(m, "JoinedStr", state->JoinedStr_type) < 0) {
12084          return -1;
12085      }
12086      if (PyModule_AddObjectRef(m, "Constant", state->Constant_type) < 0) {
12087          return -1;
12088      }
12089      if (PyModule_AddObjectRef(m, "Attribute", state->Attribute_type) < 0) {
12090          return -1;
12091      }
12092      if (PyModule_AddObjectRef(m, "Subscript", state->Subscript_type) < 0) {
12093          return -1;
12094      }
12095      if (PyModule_AddObjectRef(m, "Starred", state->Starred_type) < 0) {
12096          return -1;
12097      }
12098      if (PyModule_AddObjectRef(m, "Name", state->Name_type) < 0) {
12099          return -1;
12100      }
12101      if (PyModule_AddObjectRef(m, "List", state->List_type) < 0) {
12102          return -1;
12103      }
12104      if (PyModule_AddObjectRef(m, "Tuple", state->Tuple_type) < 0) {
12105          return -1;
12106      }
12107      if (PyModule_AddObjectRef(m, "Slice", state->Slice_type) < 0) {
12108          return -1;
12109      }
12110      if (PyModule_AddObjectRef(m, "expr_context", state->expr_context_type) < 0)
12111          {
12112          return -1;
12113      }
12114      if (PyModule_AddObjectRef(m, "Load", state->Load_type) < 0) {
12115          return -1;
12116      }
12117      if (PyModule_AddObjectRef(m, "Store", state->Store_type) < 0) {
12118          return -1;
12119      }
12120      if (PyModule_AddObjectRef(m, "Del", state->Del_type) < 0) {
12121          return -1;
12122      }
12123      if (PyModule_AddObjectRef(m, "boolop", state->boolop_type) < 0) {
12124          return -1;
12125      }
12126      if (PyModule_AddObjectRef(m, "And", state->And_type) < 0) {
12127          return -1;
12128      }
12129      if (PyModule_AddObjectRef(m, "Or", state->Or_type) < 0) {
12130          return -1;
12131      }
12132      if (PyModule_AddObjectRef(m, "operator", state->operator_type) < 0) {
12133          return -1;
12134      }
12135      if (PyModule_AddObjectRef(m, "Add", state->Add_type) < 0) {
12136          return -1;
12137      }
12138      if (PyModule_AddObjectRef(m, "Sub", state->Sub_type) < 0) {
12139          return -1;
12140      }
12141      if (PyModule_AddObjectRef(m, "Mult", state->Mult_type) < 0) {
12142          return -1;
12143      }
12144      if (PyModule_AddObjectRef(m, "MatMult", state->MatMult_type) < 0) {
12145          return -1;
12146      }
12147      if (PyModule_AddObjectRef(m, "Div", state->Div_type) < 0) {
12148          return -1;
12149      }
12150      if (PyModule_AddObjectRef(m, "Mod", state->Mod_type) < 0) {
12151          return -1;
12152      }
12153      if (PyModule_AddObjectRef(m, "Pow", state->Pow_type) < 0) {
12154          return -1;
12155      }
12156      if (PyModule_AddObjectRef(m, "LShift", state->LShift_type) < 0) {
12157          return -1;
12158      }
12159      if (PyModule_AddObjectRef(m, "RShift", state->RShift_type) < 0) {
12160          return -1;
12161      }
12162      if (PyModule_AddObjectRef(m, "BitOr", state->BitOr_type) < 0) {
12163          return -1;
12164      }
12165      if (PyModule_AddObjectRef(m, "BitXor", state->BitXor_type) < 0) {
12166          return -1;
12167      }
12168      if (PyModule_AddObjectRef(m, "BitAnd", state->BitAnd_type) < 0) {
12169          return -1;
12170      }
12171      if (PyModule_AddObjectRef(m, "FloorDiv", state->FloorDiv_type) < 0) {
12172          return -1;
12173      }
12174      if (PyModule_AddObjectRef(m, "unaryop", state->unaryop_type) < 0) {
12175          return -1;
12176      }
12177      if (PyModule_AddObjectRef(m, "Invert", state->Invert_type) < 0) {
12178          return -1;
12179      }
12180      if (PyModule_AddObjectRef(m, "Not", state->Not_type) < 0) {
12181          return -1;
12182      }
12183      if (PyModule_AddObjectRef(m, "UAdd", state->UAdd_type) < 0) {
12184          return -1;
12185      }
12186      if (PyModule_AddObjectRef(m, "USub", state->USub_type) < 0) {
12187          return -1;
12188      }
12189      if (PyModule_AddObjectRef(m, "cmpop", state->cmpop_type) < 0) {
12190          return -1;
12191      }
12192      if (PyModule_AddObjectRef(m, "Eq", state->Eq_type) < 0) {
12193          return -1;
12194      }
12195      if (PyModule_AddObjectRef(m, "NotEq", state->NotEq_type) < 0) {
12196          return -1;
12197      }
12198      if (PyModule_AddObjectRef(m, "Lt", state->Lt_type) < 0) {
12199          return -1;
12200      }
12201      if (PyModule_AddObjectRef(m, "LtE", state->LtE_type) < 0) {
12202          return -1;
12203      }
12204      if (PyModule_AddObjectRef(m, "Gt", state->Gt_type) < 0) {
12205          return -1;
12206      }
12207      if (PyModule_AddObjectRef(m, "GtE", state->GtE_type) < 0) {
12208          return -1;
12209      }
12210      if (PyModule_AddObjectRef(m, "Is", state->Is_type) < 0) {
12211          return -1;
12212      }
12213      if (PyModule_AddObjectRef(m, "IsNot", state->IsNot_type) < 0) {
12214          return -1;
12215      }
12216      if (PyModule_AddObjectRef(m, "In", state->In_type) < 0) {
12217          return -1;
12218      }
12219      if (PyModule_AddObjectRef(m, "NotIn", state->NotIn_type) < 0) {
12220          return -1;
12221      }
12222      if (PyModule_AddObjectRef(m, "comprehension", state->comprehension_type) <
12223          0) {
12224          return -1;
12225      }
12226      if (PyModule_AddObjectRef(m, "excepthandler", state->excepthandler_type) <
12227          0) {
12228          return -1;
12229      }
12230      if (PyModule_AddObjectRef(m, "ExceptHandler", state->ExceptHandler_type) <
12231          0) {
12232          return -1;
12233      }
12234      if (PyModule_AddObjectRef(m, "arguments", state->arguments_type) < 0) {
12235          return -1;
12236      }
12237      if (PyModule_AddObjectRef(m, "arg", state->arg_type) < 0) {
12238          return -1;
12239      }
12240      if (PyModule_AddObjectRef(m, "keyword", state->keyword_type) < 0) {
12241          return -1;
12242      }
12243      if (PyModule_AddObjectRef(m, "alias", state->alias_type) < 0) {
12244          return -1;
12245      }
12246      if (PyModule_AddObjectRef(m, "withitem", state->withitem_type) < 0) {
12247          return -1;
12248      }
12249      if (PyModule_AddObjectRef(m, "match_case", state->match_case_type) < 0) {
12250          return -1;
12251      }
12252      if (PyModule_AddObjectRef(m, "pattern", state->pattern_type) < 0) {
12253          return -1;
12254      }
12255      if (PyModule_AddObjectRef(m, "MatchValue", state->MatchValue_type) < 0) {
12256          return -1;
12257      }
12258      if (PyModule_AddObjectRef(m, "MatchSingleton", state->MatchSingleton_type)
12259          < 0) {
12260          return -1;
12261      }
12262      if (PyModule_AddObjectRef(m, "MatchSequence", state->MatchSequence_type) <
12263          0) {
12264          return -1;
12265      }
12266      if (PyModule_AddObjectRef(m, "MatchMapping", state->MatchMapping_type) < 0)
12267          {
12268          return -1;
12269      }
12270      if (PyModule_AddObjectRef(m, "MatchClass", state->MatchClass_type) < 0) {
12271          return -1;
12272      }
12273      if (PyModule_AddObjectRef(m, "MatchStar", state->MatchStar_type) < 0) {
12274          return -1;
12275      }
12276      if (PyModule_AddObjectRef(m, "MatchAs", state->MatchAs_type) < 0) {
12277          return -1;
12278      }
12279      if (PyModule_AddObjectRef(m, "MatchOr", state->MatchOr_type) < 0) {
12280          return -1;
12281      }
12282      if (PyModule_AddObjectRef(m, "type_ignore", state->type_ignore_type) < 0) {
12283          return -1;
12284      }
12285      if (PyModule_AddObjectRef(m, "TypeIgnore", state->TypeIgnore_type) < 0) {
12286          return -1;
12287      }
12288      return 0;
12289  }
12290  
12291  static PyModuleDef_Slot astmodule_slots[] = {
12292      {Py_mod_exec, astmodule_exec},
12293      {0, NULL}
12294  };
12295  
12296  static struct PyModuleDef _astmodule = {
12297      PyModuleDef_HEAD_INIT,
12298      .m_name = "_ast",
12299      // The _ast module uses a per-interpreter state (PyInterpreterState.ast)
12300      .m_size = 0,
12301      .m_slots = astmodule_slots,
12302  };
12303  
12304  PyMODINIT_FUNC
PyInit__ast(void)12305  PyInit__ast(void)
12306  {
12307      return PyModuleDef_Init(&_astmodule);
12308  }
12309  
12310  
PyAST_mod2obj(mod_ty t)12311  PyObject* PyAST_mod2obj(mod_ty t)
12312  {
12313      struct ast_state *state = get_ast_state();
12314      if (state == NULL) {
12315          return NULL;
12316      }
12317  
12318      int recursion_limit = Py_GetRecursionLimit();
12319      int starting_recursion_depth;
12320      /* Be careful here to prevent overflow. */
12321      int COMPILER_STACK_FRAME_SCALE = 3;
12322      PyThreadState *tstate = _PyThreadState_GET();
12323      if (!tstate) {
12324          return 0;
12325      }
12326      state->recursion_limit = (recursion_limit < INT_MAX / COMPILER_STACK_FRAME_SCALE) ?
12327          recursion_limit * COMPILER_STACK_FRAME_SCALE : recursion_limit;
12328      int recursion_depth = tstate->recursion_limit - tstate->recursion_remaining;
12329      starting_recursion_depth = (recursion_depth < INT_MAX / COMPILER_STACK_FRAME_SCALE) ?
12330          recursion_depth * COMPILER_STACK_FRAME_SCALE : recursion_depth;
12331      state->recursion_depth = starting_recursion_depth;
12332  
12333      PyObject *result = ast2obj_mod(state, t);
12334  
12335      /* Check that the recursion depth counting balanced correctly */
12336      if (result && state->recursion_depth != starting_recursion_depth) {
12337          PyErr_Format(PyExc_SystemError,
12338              "AST constructor recursion depth mismatch (before=%d, after=%d)",
12339              starting_recursion_depth, state->recursion_depth);
12340          return 0;
12341      }
12342      return result;
12343  }
12344  
12345  /* mode is 0 for "exec", 1 for "eval" and 2 for "single" input */
PyAST_obj2mod(PyObject * ast,PyArena * arena,int mode)12346  mod_ty PyAST_obj2mod(PyObject* ast, PyArena* arena, int mode)
12347  {
12348      const char * const req_name[] = {"Module", "Expression", "Interactive"};
12349      int isinstance;
12350  
12351      if (PySys_Audit("compile", "OO", ast, Py_None) < 0) {
12352          return NULL;
12353      }
12354  
12355      struct ast_state *state = get_ast_state();
12356      if (state == NULL) {
12357          return NULL;
12358      }
12359  
12360      PyObject *req_type[3];
12361      req_type[0] = state->Module_type;
12362      req_type[1] = state->Expression_type;
12363      req_type[2] = state->Interactive_type;
12364  
12365      assert(0 <= mode && mode <= 2);
12366  
12367      isinstance = PyObject_IsInstance(ast, req_type[mode]);
12368      if (isinstance == -1)
12369          return NULL;
12370      if (!isinstance) {
12371          PyErr_Format(PyExc_TypeError, "expected %s node, got %.400s",
12372                       req_name[mode], _PyType_Name(Py_TYPE(ast)));
12373          return NULL;
12374      }
12375  
12376      mod_ty res = NULL;
12377      if (obj2ast_mod(state, ast, &res, arena) != 0)
12378          return NULL;
12379      else
12380          return res;
12381  }
12382  
PyAST_Check(PyObject * obj)12383  int PyAST_Check(PyObject* obj)
12384  {
12385      struct ast_state *state = get_ast_state();
12386      if (state == NULL) {
12387          return -1;
12388      }
12389      return PyObject_IsInstance(obj, state->AST_type);
12390  }
12391  
12392  
12393