cpython/Python/Python-ast.c

10294 lines
346 KiB
C

/* File automatically generated by Parser/asdl_c.py. */
#include <stddef.h>
#include "Python.h"
#include "Python-ast.h"
#include "structmember.h"
typedef struct {
int initialized;
PyObject *AST_type;
PyObject *Add_singleton;
PyObject *Add_type;
PyObject *And_singleton;
PyObject *And_type;
PyObject *AnnAssign_type;
PyObject *Assert_type;
PyObject *Assign_type;
PyObject *AsyncFor_type;
PyObject *AsyncFunctionDef_type;
PyObject *AsyncWith_type;
PyObject *Attribute_type;
PyObject *AugAssign_type;
PyObject *AugLoad_singleton;
PyObject *AugLoad_type;
PyObject *AugStore_singleton;
PyObject *AugStore_type;
PyObject *Await_type;
PyObject *BinOp_type;
PyObject *BitAnd_singleton;
PyObject *BitAnd_type;
PyObject *BitOr_singleton;
PyObject *BitOr_type;
PyObject *BitXor_singleton;
PyObject *BitXor_type;
PyObject *BoolOp_type;
PyObject *Break_type;
PyObject *Call_type;
PyObject *ClassDef_type;
PyObject *Compare_type;
PyObject *Constant_type;
PyObject *Continue_type;
PyObject *Del_singleton;
PyObject *Del_type;
PyObject *Delete_type;
PyObject *DictComp_type;
PyObject *Dict_type;
PyObject *Div_singleton;
PyObject *Div_type;
PyObject *Eq_singleton;
PyObject *Eq_type;
PyObject *ExceptHandler_type;
PyObject *Expr_type;
PyObject *Expression_type;
PyObject *ExtSlice_type;
PyObject *FloorDiv_singleton;
PyObject *FloorDiv_type;
PyObject *For_type;
PyObject *FormattedValue_type;
PyObject *FunctionDef_type;
PyObject *FunctionType_type;
PyObject *GeneratorExp_type;
PyObject *Global_type;
PyObject *GtE_singleton;
PyObject *GtE_type;
PyObject *Gt_singleton;
PyObject *Gt_type;
PyObject *IfExp_type;
PyObject *If_type;
PyObject *ImportFrom_type;
PyObject *Import_type;
PyObject *In_singleton;
PyObject *In_type;
PyObject *Index_type;
PyObject *Interactive_type;
PyObject *Invert_singleton;
PyObject *Invert_type;
PyObject *IsNot_singleton;
PyObject *IsNot_type;
PyObject *Is_singleton;
PyObject *Is_type;
PyObject *JoinedStr_type;
PyObject *LShift_singleton;
PyObject *LShift_type;
PyObject *Lambda_type;
PyObject *ListComp_type;
PyObject *List_type;
PyObject *Load_singleton;
PyObject *Load_type;
PyObject *LtE_singleton;
PyObject *LtE_type;
PyObject *Lt_singleton;
PyObject *Lt_type;
PyObject *MatMult_singleton;
PyObject *MatMult_type;
PyObject *Mod_singleton;
PyObject *Mod_type;
PyObject *Module_type;
PyObject *Mult_singleton;
PyObject *Mult_type;
PyObject *Name_type;
PyObject *NamedExpr_type;
PyObject *Nonlocal_type;
PyObject *NotEq_singleton;
PyObject *NotEq_type;
PyObject *NotIn_singleton;
PyObject *NotIn_type;
PyObject *Not_singleton;
PyObject *Not_type;
PyObject *Or_singleton;
PyObject *Or_type;
PyObject *Param_singleton;
PyObject *Param_type;
PyObject *Pass_type;
PyObject *Pow_singleton;
PyObject *Pow_type;
PyObject *RShift_singleton;
PyObject *RShift_type;
PyObject *Raise_type;
PyObject *Return_type;
PyObject *SetComp_type;
PyObject *Set_type;
PyObject *Slice_type;
PyObject *Starred_type;
PyObject *Store_singleton;
PyObject *Store_type;
PyObject *Sub_singleton;
PyObject *Sub_type;
PyObject *Subscript_type;
PyObject *Suite_type;
PyObject *Try_type;
PyObject *Tuple_type;
PyObject *TypeIgnore_type;
PyObject *UAdd_singleton;
PyObject *UAdd_type;
PyObject *USub_singleton;
PyObject *USub_type;
PyObject *UnaryOp_type;
PyObject *While_type;
PyObject *With_type;
PyObject *YieldFrom_type;
PyObject *Yield_type;
PyObject *__dict__;
PyObject *__module__;
PyObject *_ast;
PyObject *_attributes;
PyObject *_fields;
PyObject *alias_type;
PyObject *annotation;
PyObject *arg;
PyObject *arg_type;
PyObject *args;
PyObject *argtypes;
PyObject *arguments_type;
PyObject *asname;
PyObject *attr;
PyObject *bases;
PyObject *body;
PyObject *boolop_type;
PyObject *cause;
PyObject *cmpop_type;
PyObject *col_offset;
PyObject *comparators;
PyObject *comprehension_type;
PyObject *context_expr;
PyObject *conversion;
PyObject *ctx;
PyObject *decorator_list;
PyObject *defaults;
PyObject *dims;
PyObject *elt;
PyObject *elts;
PyObject *end_col_offset;
PyObject *end_lineno;
PyObject *exc;
PyObject *excepthandler_type;
PyObject *expr_context_type;
PyObject *expr_type;
PyObject *finalbody;
PyObject *format_spec;
PyObject *func;
PyObject *generators;
PyObject *handlers;
PyObject *id;
PyObject *ifs;
PyObject *is_async;
PyObject *items;
PyObject *iter;
PyObject *key;
PyObject *keys;
PyObject *keyword_type;
PyObject *keywords;
PyObject *kind;
PyObject *kw_defaults;
PyObject *kwarg;
PyObject *kwonlyargs;
PyObject *left;
PyObject *level;
PyObject *lineno;
PyObject *lower;
PyObject *mod_type;
PyObject *module;
PyObject *msg;
PyObject *name;
PyObject *names;
PyObject *op;
PyObject *operand;
PyObject *operator_type;
PyObject *ops;
PyObject *optional_vars;
PyObject *orelse;
PyObject *posonlyargs;
PyObject *returns;
PyObject *right;
PyObject *simple;
PyObject *slice;
PyObject *slice_type;
PyObject *step;
PyObject *stmt_type;
PyObject *tag;
PyObject *target;
PyObject *targets;
PyObject *test;
PyObject *type;
PyObject *type_comment;
PyObject *type_ignore_type;
PyObject *type_ignores;
PyObject *unaryop_type;
PyObject *upper;
PyObject *value;
PyObject *values;
PyObject *vararg;
PyObject *withitem_type;
} astmodulestate;
#define astmodulestate(o) ((astmodulestate *)PyModule_GetState(o))
static int astmodule_clear(PyObject *module)
{
Py_CLEAR(astmodulestate(module)->AST_type);
Py_CLEAR(astmodulestate(module)->Add_singleton);
Py_CLEAR(astmodulestate(module)->Add_type);
Py_CLEAR(astmodulestate(module)->And_singleton);
Py_CLEAR(astmodulestate(module)->And_type);
Py_CLEAR(astmodulestate(module)->AnnAssign_type);
Py_CLEAR(astmodulestate(module)->Assert_type);
Py_CLEAR(astmodulestate(module)->Assign_type);
Py_CLEAR(astmodulestate(module)->AsyncFor_type);
Py_CLEAR(astmodulestate(module)->AsyncFunctionDef_type);
Py_CLEAR(astmodulestate(module)->AsyncWith_type);
Py_CLEAR(astmodulestate(module)->Attribute_type);
Py_CLEAR(astmodulestate(module)->AugAssign_type);
Py_CLEAR(astmodulestate(module)->AugLoad_singleton);
Py_CLEAR(astmodulestate(module)->AugLoad_type);
Py_CLEAR(astmodulestate(module)->AugStore_singleton);
Py_CLEAR(astmodulestate(module)->AugStore_type);
Py_CLEAR(astmodulestate(module)->Await_type);
Py_CLEAR(astmodulestate(module)->BinOp_type);
Py_CLEAR(astmodulestate(module)->BitAnd_singleton);
Py_CLEAR(astmodulestate(module)->BitAnd_type);
Py_CLEAR(astmodulestate(module)->BitOr_singleton);
Py_CLEAR(astmodulestate(module)->BitOr_type);
Py_CLEAR(astmodulestate(module)->BitXor_singleton);
Py_CLEAR(astmodulestate(module)->BitXor_type);
Py_CLEAR(astmodulestate(module)->BoolOp_type);
Py_CLEAR(astmodulestate(module)->Break_type);
Py_CLEAR(astmodulestate(module)->Call_type);
Py_CLEAR(astmodulestate(module)->ClassDef_type);
Py_CLEAR(astmodulestate(module)->Compare_type);
Py_CLEAR(astmodulestate(module)->Constant_type);
Py_CLEAR(astmodulestate(module)->Continue_type);
Py_CLEAR(astmodulestate(module)->Del_singleton);
Py_CLEAR(astmodulestate(module)->Del_type);
Py_CLEAR(astmodulestate(module)->Delete_type);
Py_CLEAR(astmodulestate(module)->DictComp_type);
Py_CLEAR(astmodulestate(module)->Dict_type);
Py_CLEAR(astmodulestate(module)->Div_singleton);
Py_CLEAR(astmodulestate(module)->Div_type);
Py_CLEAR(astmodulestate(module)->Eq_singleton);
Py_CLEAR(astmodulestate(module)->Eq_type);
Py_CLEAR(astmodulestate(module)->ExceptHandler_type);
Py_CLEAR(astmodulestate(module)->Expr_type);
Py_CLEAR(astmodulestate(module)->Expression_type);
Py_CLEAR(astmodulestate(module)->ExtSlice_type);
Py_CLEAR(astmodulestate(module)->FloorDiv_singleton);
Py_CLEAR(astmodulestate(module)->FloorDiv_type);
Py_CLEAR(astmodulestate(module)->For_type);
Py_CLEAR(astmodulestate(module)->FormattedValue_type);
Py_CLEAR(astmodulestate(module)->FunctionDef_type);
Py_CLEAR(astmodulestate(module)->FunctionType_type);
Py_CLEAR(astmodulestate(module)->GeneratorExp_type);
Py_CLEAR(astmodulestate(module)->Global_type);
Py_CLEAR(astmodulestate(module)->GtE_singleton);
Py_CLEAR(astmodulestate(module)->GtE_type);
Py_CLEAR(astmodulestate(module)->Gt_singleton);
Py_CLEAR(astmodulestate(module)->Gt_type);
Py_CLEAR(astmodulestate(module)->IfExp_type);
Py_CLEAR(astmodulestate(module)->If_type);
Py_CLEAR(astmodulestate(module)->ImportFrom_type);
Py_CLEAR(astmodulestate(module)->Import_type);
Py_CLEAR(astmodulestate(module)->In_singleton);
Py_CLEAR(astmodulestate(module)->In_type);
Py_CLEAR(astmodulestate(module)->Index_type);
Py_CLEAR(astmodulestate(module)->Interactive_type);
Py_CLEAR(astmodulestate(module)->Invert_singleton);
Py_CLEAR(astmodulestate(module)->Invert_type);
Py_CLEAR(astmodulestate(module)->IsNot_singleton);
Py_CLEAR(astmodulestate(module)->IsNot_type);
Py_CLEAR(astmodulestate(module)->Is_singleton);
Py_CLEAR(astmodulestate(module)->Is_type);
Py_CLEAR(astmodulestate(module)->JoinedStr_type);
Py_CLEAR(astmodulestate(module)->LShift_singleton);
Py_CLEAR(astmodulestate(module)->LShift_type);
Py_CLEAR(astmodulestate(module)->Lambda_type);
Py_CLEAR(astmodulestate(module)->ListComp_type);
Py_CLEAR(astmodulestate(module)->List_type);
Py_CLEAR(astmodulestate(module)->Load_singleton);
Py_CLEAR(astmodulestate(module)->Load_type);
Py_CLEAR(astmodulestate(module)->LtE_singleton);
Py_CLEAR(astmodulestate(module)->LtE_type);
Py_CLEAR(astmodulestate(module)->Lt_singleton);
Py_CLEAR(astmodulestate(module)->Lt_type);
Py_CLEAR(astmodulestate(module)->MatMult_singleton);
Py_CLEAR(astmodulestate(module)->MatMult_type);
Py_CLEAR(astmodulestate(module)->Mod_singleton);
Py_CLEAR(astmodulestate(module)->Mod_type);
Py_CLEAR(astmodulestate(module)->Module_type);
Py_CLEAR(astmodulestate(module)->Mult_singleton);
Py_CLEAR(astmodulestate(module)->Mult_type);
Py_CLEAR(astmodulestate(module)->Name_type);
Py_CLEAR(astmodulestate(module)->NamedExpr_type);
Py_CLEAR(astmodulestate(module)->Nonlocal_type);
Py_CLEAR(astmodulestate(module)->NotEq_singleton);
Py_CLEAR(astmodulestate(module)->NotEq_type);
Py_CLEAR(astmodulestate(module)->NotIn_singleton);
Py_CLEAR(astmodulestate(module)->NotIn_type);
Py_CLEAR(astmodulestate(module)->Not_singleton);
Py_CLEAR(astmodulestate(module)->Not_type);
Py_CLEAR(astmodulestate(module)->Or_singleton);
Py_CLEAR(astmodulestate(module)->Or_type);
Py_CLEAR(astmodulestate(module)->Param_singleton);
Py_CLEAR(astmodulestate(module)->Param_type);
Py_CLEAR(astmodulestate(module)->Pass_type);
Py_CLEAR(astmodulestate(module)->Pow_singleton);
Py_CLEAR(astmodulestate(module)->Pow_type);
Py_CLEAR(astmodulestate(module)->RShift_singleton);
Py_CLEAR(astmodulestate(module)->RShift_type);
Py_CLEAR(astmodulestate(module)->Raise_type);
Py_CLEAR(astmodulestate(module)->Return_type);
Py_CLEAR(astmodulestate(module)->SetComp_type);
Py_CLEAR(astmodulestate(module)->Set_type);
Py_CLEAR(astmodulestate(module)->Slice_type);
Py_CLEAR(astmodulestate(module)->Starred_type);
Py_CLEAR(astmodulestate(module)->Store_singleton);
Py_CLEAR(astmodulestate(module)->Store_type);
Py_CLEAR(astmodulestate(module)->Sub_singleton);
Py_CLEAR(astmodulestate(module)->Sub_type);
Py_CLEAR(astmodulestate(module)->Subscript_type);
Py_CLEAR(astmodulestate(module)->Suite_type);
Py_CLEAR(astmodulestate(module)->Try_type);
Py_CLEAR(astmodulestate(module)->Tuple_type);
Py_CLEAR(astmodulestate(module)->TypeIgnore_type);
Py_CLEAR(astmodulestate(module)->UAdd_singleton);
Py_CLEAR(astmodulestate(module)->UAdd_type);
Py_CLEAR(astmodulestate(module)->USub_singleton);
Py_CLEAR(astmodulestate(module)->USub_type);
Py_CLEAR(astmodulestate(module)->UnaryOp_type);
Py_CLEAR(astmodulestate(module)->While_type);
Py_CLEAR(astmodulestate(module)->With_type);
Py_CLEAR(astmodulestate(module)->YieldFrom_type);
Py_CLEAR(astmodulestate(module)->Yield_type);
Py_CLEAR(astmodulestate(module)->__dict__);
Py_CLEAR(astmodulestate(module)->__module__);
Py_CLEAR(astmodulestate(module)->_ast);
Py_CLEAR(astmodulestate(module)->_attributes);
Py_CLEAR(astmodulestate(module)->_fields);
Py_CLEAR(astmodulestate(module)->alias_type);
Py_CLEAR(astmodulestate(module)->annotation);
Py_CLEAR(astmodulestate(module)->arg);
Py_CLEAR(astmodulestate(module)->arg_type);
Py_CLEAR(astmodulestate(module)->args);
Py_CLEAR(astmodulestate(module)->argtypes);
Py_CLEAR(astmodulestate(module)->arguments_type);
Py_CLEAR(astmodulestate(module)->asname);
Py_CLEAR(astmodulestate(module)->attr);
Py_CLEAR(astmodulestate(module)->bases);
Py_CLEAR(astmodulestate(module)->body);
Py_CLEAR(astmodulestate(module)->boolop_type);
Py_CLEAR(astmodulestate(module)->cause);
Py_CLEAR(astmodulestate(module)->cmpop_type);
Py_CLEAR(astmodulestate(module)->col_offset);
Py_CLEAR(astmodulestate(module)->comparators);
Py_CLEAR(astmodulestate(module)->comprehension_type);
Py_CLEAR(astmodulestate(module)->context_expr);
Py_CLEAR(astmodulestate(module)->conversion);
Py_CLEAR(astmodulestate(module)->ctx);
Py_CLEAR(astmodulestate(module)->decorator_list);
Py_CLEAR(astmodulestate(module)->defaults);
Py_CLEAR(astmodulestate(module)->dims);
Py_CLEAR(astmodulestate(module)->elt);
Py_CLEAR(astmodulestate(module)->elts);
Py_CLEAR(astmodulestate(module)->end_col_offset);
Py_CLEAR(astmodulestate(module)->end_lineno);
Py_CLEAR(astmodulestate(module)->exc);
Py_CLEAR(astmodulestate(module)->excepthandler_type);
Py_CLEAR(astmodulestate(module)->expr_context_type);
Py_CLEAR(astmodulestate(module)->expr_type);
Py_CLEAR(astmodulestate(module)->finalbody);
Py_CLEAR(astmodulestate(module)->format_spec);
Py_CLEAR(astmodulestate(module)->func);
Py_CLEAR(astmodulestate(module)->generators);
Py_CLEAR(astmodulestate(module)->handlers);
Py_CLEAR(astmodulestate(module)->id);
Py_CLEAR(astmodulestate(module)->ifs);
Py_CLEAR(astmodulestate(module)->is_async);
Py_CLEAR(astmodulestate(module)->items);
Py_CLEAR(astmodulestate(module)->iter);
Py_CLEAR(astmodulestate(module)->key);
Py_CLEAR(astmodulestate(module)->keys);
Py_CLEAR(astmodulestate(module)->keyword_type);
Py_CLEAR(astmodulestate(module)->keywords);
Py_CLEAR(astmodulestate(module)->kind);
Py_CLEAR(astmodulestate(module)->kw_defaults);
Py_CLEAR(astmodulestate(module)->kwarg);
Py_CLEAR(astmodulestate(module)->kwonlyargs);
Py_CLEAR(astmodulestate(module)->left);
Py_CLEAR(astmodulestate(module)->level);
Py_CLEAR(astmodulestate(module)->lineno);
Py_CLEAR(astmodulestate(module)->lower);
Py_CLEAR(astmodulestate(module)->mod_type);
Py_CLEAR(astmodulestate(module)->module);
Py_CLEAR(astmodulestate(module)->msg);
Py_CLEAR(astmodulestate(module)->name);
Py_CLEAR(astmodulestate(module)->names);
Py_CLEAR(astmodulestate(module)->op);
Py_CLEAR(astmodulestate(module)->operand);
Py_CLEAR(astmodulestate(module)->operator_type);
Py_CLEAR(astmodulestate(module)->ops);
Py_CLEAR(astmodulestate(module)->optional_vars);
Py_CLEAR(astmodulestate(module)->orelse);
Py_CLEAR(astmodulestate(module)->posonlyargs);
Py_CLEAR(astmodulestate(module)->returns);
Py_CLEAR(astmodulestate(module)->right);
Py_CLEAR(astmodulestate(module)->simple);
Py_CLEAR(astmodulestate(module)->slice);
Py_CLEAR(astmodulestate(module)->slice_type);
Py_CLEAR(astmodulestate(module)->step);
Py_CLEAR(astmodulestate(module)->stmt_type);
Py_CLEAR(astmodulestate(module)->tag);
Py_CLEAR(astmodulestate(module)->target);
Py_CLEAR(astmodulestate(module)->targets);
Py_CLEAR(astmodulestate(module)->test);
Py_CLEAR(astmodulestate(module)->type);
Py_CLEAR(astmodulestate(module)->type_comment);
Py_CLEAR(astmodulestate(module)->type_ignore_type);
Py_CLEAR(astmodulestate(module)->type_ignores);
Py_CLEAR(astmodulestate(module)->unaryop_type);
Py_CLEAR(astmodulestate(module)->upper);
Py_CLEAR(astmodulestate(module)->value);
Py_CLEAR(astmodulestate(module)->values);
Py_CLEAR(astmodulestate(module)->vararg);
Py_CLEAR(astmodulestate(module)->withitem_type);
return 0;
}
static int astmodule_traverse(PyObject *module, visitproc visit, void* arg)
{
Py_VISIT(astmodulestate(module)->AST_type);
Py_VISIT(astmodulestate(module)->Add_singleton);
Py_VISIT(astmodulestate(module)->Add_type);
Py_VISIT(astmodulestate(module)->And_singleton);
Py_VISIT(astmodulestate(module)->And_type);
Py_VISIT(astmodulestate(module)->AnnAssign_type);
Py_VISIT(astmodulestate(module)->Assert_type);
Py_VISIT(astmodulestate(module)->Assign_type);
Py_VISIT(astmodulestate(module)->AsyncFor_type);
Py_VISIT(astmodulestate(module)->AsyncFunctionDef_type);
Py_VISIT(astmodulestate(module)->AsyncWith_type);
Py_VISIT(astmodulestate(module)->Attribute_type);
Py_VISIT(astmodulestate(module)->AugAssign_type);
Py_VISIT(astmodulestate(module)->AugLoad_singleton);
Py_VISIT(astmodulestate(module)->AugLoad_type);
Py_VISIT(astmodulestate(module)->AugStore_singleton);
Py_VISIT(astmodulestate(module)->AugStore_type);
Py_VISIT(astmodulestate(module)->Await_type);
Py_VISIT(astmodulestate(module)->BinOp_type);
Py_VISIT(astmodulestate(module)->BitAnd_singleton);
Py_VISIT(astmodulestate(module)->BitAnd_type);
Py_VISIT(astmodulestate(module)->BitOr_singleton);
Py_VISIT(astmodulestate(module)->BitOr_type);
Py_VISIT(astmodulestate(module)->BitXor_singleton);
Py_VISIT(astmodulestate(module)->BitXor_type);
Py_VISIT(astmodulestate(module)->BoolOp_type);
Py_VISIT(astmodulestate(module)->Break_type);
Py_VISIT(astmodulestate(module)->Call_type);
Py_VISIT(astmodulestate(module)->ClassDef_type);
Py_VISIT(astmodulestate(module)->Compare_type);
Py_VISIT(astmodulestate(module)->Constant_type);
Py_VISIT(astmodulestate(module)->Continue_type);
Py_VISIT(astmodulestate(module)->Del_singleton);
Py_VISIT(astmodulestate(module)->Del_type);
Py_VISIT(astmodulestate(module)->Delete_type);
Py_VISIT(astmodulestate(module)->DictComp_type);
Py_VISIT(astmodulestate(module)->Dict_type);
Py_VISIT(astmodulestate(module)->Div_singleton);
Py_VISIT(astmodulestate(module)->Div_type);
Py_VISIT(astmodulestate(module)->Eq_singleton);
Py_VISIT(astmodulestate(module)->Eq_type);
Py_VISIT(astmodulestate(module)->ExceptHandler_type);
Py_VISIT(astmodulestate(module)->Expr_type);
Py_VISIT(astmodulestate(module)->Expression_type);
Py_VISIT(astmodulestate(module)->ExtSlice_type);
Py_VISIT(astmodulestate(module)->FloorDiv_singleton);
Py_VISIT(astmodulestate(module)->FloorDiv_type);
Py_VISIT(astmodulestate(module)->For_type);
Py_VISIT(astmodulestate(module)->FormattedValue_type);
Py_VISIT(astmodulestate(module)->FunctionDef_type);
Py_VISIT(astmodulestate(module)->FunctionType_type);
Py_VISIT(astmodulestate(module)->GeneratorExp_type);
Py_VISIT(astmodulestate(module)->Global_type);
Py_VISIT(astmodulestate(module)->GtE_singleton);
Py_VISIT(astmodulestate(module)->GtE_type);
Py_VISIT(astmodulestate(module)->Gt_singleton);
Py_VISIT(astmodulestate(module)->Gt_type);
Py_VISIT(astmodulestate(module)->IfExp_type);
Py_VISIT(astmodulestate(module)->If_type);
Py_VISIT(astmodulestate(module)->ImportFrom_type);
Py_VISIT(astmodulestate(module)->Import_type);
Py_VISIT(astmodulestate(module)->In_singleton);
Py_VISIT(astmodulestate(module)->In_type);
Py_VISIT(astmodulestate(module)->Index_type);
Py_VISIT(astmodulestate(module)->Interactive_type);
Py_VISIT(astmodulestate(module)->Invert_singleton);
Py_VISIT(astmodulestate(module)->Invert_type);
Py_VISIT(astmodulestate(module)->IsNot_singleton);
Py_VISIT(astmodulestate(module)->IsNot_type);
Py_VISIT(astmodulestate(module)->Is_singleton);
Py_VISIT(astmodulestate(module)->Is_type);
Py_VISIT(astmodulestate(module)->JoinedStr_type);
Py_VISIT(astmodulestate(module)->LShift_singleton);
Py_VISIT(astmodulestate(module)->LShift_type);
Py_VISIT(astmodulestate(module)->Lambda_type);
Py_VISIT(astmodulestate(module)->ListComp_type);
Py_VISIT(astmodulestate(module)->List_type);
Py_VISIT(astmodulestate(module)->Load_singleton);
Py_VISIT(astmodulestate(module)->Load_type);
Py_VISIT(astmodulestate(module)->LtE_singleton);
Py_VISIT(astmodulestate(module)->LtE_type);
Py_VISIT(astmodulestate(module)->Lt_singleton);
Py_VISIT(astmodulestate(module)->Lt_type);
Py_VISIT(astmodulestate(module)->MatMult_singleton);
Py_VISIT(astmodulestate(module)->MatMult_type);
Py_VISIT(astmodulestate(module)->Mod_singleton);
Py_VISIT(astmodulestate(module)->Mod_type);
Py_VISIT(astmodulestate(module)->Module_type);
Py_VISIT(astmodulestate(module)->Mult_singleton);
Py_VISIT(astmodulestate(module)->Mult_type);
Py_VISIT(astmodulestate(module)->Name_type);
Py_VISIT(astmodulestate(module)->NamedExpr_type);
Py_VISIT(astmodulestate(module)->Nonlocal_type);
Py_VISIT(astmodulestate(module)->NotEq_singleton);
Py_VISIT(astmodulestate(module)->NotEq_type);
Py_VISIT(astmodulestate(module)->NotIn_singleton);
Py_VISIT(astmodulestate(module)->NotIn_type);
Py_VISIT(astmodulestate(module)->Not_singleton);
Py_VISIT(astmodulestate(module)->Not_type);
Py_VISIT(astmodulestate(module)->Or_singleton);
Py_VISIT(astmodulestate(module)->Or_type);
Py_VISIT(astmodulestate(module)->Param_singleton);
Py_VISIT(astmodulestate(module)->Param_type);
Py_VISIT(astmodulestate(module)->Pass_type);
Py_VISIT(astmodulestate(module)->Pow_singleton);
Py_VISIT(astmodulestate(module)->Pow_type);
Py_VISIT(astmodulestate(module)->RShift_singleton);
Py_VISIT(astmodulestate(module)->RShift_type);
Py_VISIT(astmodulestate(module)->Raise_type);
Py_VISIT(astmodulestate(module)->Return_type);
Py_VISIT(astmodulestate(module)->SetComp_type);
Py_VISIT(astmodulestate(module)->Set_type);
Py_VISIT(astmodulestate(module)->Slice_type);
Py_VISIT(astmodulestate(module)->Starred_type);
Py_VISIT(astmodulestate(module)->Store_singleton);
Py_VISIT(astmodulestate(module)->Store_type);
Py_VISIT(astmodulestate(module)->Sub_singleton);
Py_VISIT(astmodulestate(module)->Sub_type);
Py_VISIT(astmodulestate(module)->Subscript_type);
Py_VISIT(astmodulestate(module)->Suite_type);
Py_VISIT(astmodulestate(module)->Try_type);
Py_VISIT(astmodulestate(module)->Tuple_type);
Py_VISIT(astmodulestate(module)->TypeIgnore_type);
Py_VISIT(astmodulestate(module)->UAdd_singleton);
Py_VISIT(astmodulestate(module)->UAdd_type);
Py_VISIT(astmodulestate(module)->USub_singleton);
Py_VISIT(astmodulestate(module)->USub_type);
Py_VISIT(astmodulestate(module)->UnaryOp_type);
Py_VISIT(astmodulestate(module)->While_type);
Py_VISIT(astmodulestate(module)->With_type);
Py_VISIT(astmodulestate(module)->YieldFrom_type);
Py_VISIT(astmodulestate(module)->Yield_type);
Py_VISIT(astmodulestate(module)->__dict__);
Py_VISIT(astmodulestate(module)->__module__);
Py_VISIT(astmodulestate(module)->_ast);
Py_VISIT(astmodulestate(module)->_attributes);
Py_VISIT(astmodulestate(module)->_fields);
Py_VISIT(astmodulestate(module)->alias_type);
Py_VISIT(astmodulestate(module)->annotation);
Py_VISIT(astmodulestate(module)->arg);
Py_VISIT(astmodulestate(module)->arg_type);
Py_VISIT(astmodulestate(module)->args);
Py_VISIT(astmodulestate(module)->argtypes);
Py_VISIT(astmodulestate(module)->arguments_type);
Py_VISIT(astmodulestate(module)->asname);
Py_VISIT(astmodulestate(module)->attr);
Py_VISIT(astmodulestate(module)->bases);
Py_VISIT(astmodulestate(module)->body);
Py_VISIT(astmodulestate(module)->boolop_type);
Py_VISIT(astmodulestate(module)->cause);
Py_VISIT(astmodulestate(module)->cmpop_type);
Py_VISIT(astmodulestate(module)->col_offset);
Py_VISIT(astmodulestate(module)->comparators);
Py_VISIT(astmodulestate(module)->comprehension_type);
Py_VISIT(astmodulestate(module)->context_expr);
Py_VISIT(astmodulestate(module)->conversion);
Py_VISIT(astmodulestate(module)->ctx);
Py_VISIT(astmodulestate(module)->decorator_list);
Py_VISIT(astmodulestate(module)->defaults);
Py_VISIT(astmodulestate(module)->dims);
Py_VISIT(astmodulestate(module)->elt);
Py_VISIT(astmodulestate(module)->elts);
Py_VISIT(astmodulestate(module)->end_col_offset);
Py_VISIT(astmodulestate(module)->end_lineno);
Py_VISIT(astmodulestate(module)->exc);
Py_VISIT(astmodulestate(module)->excepthandler_type);
Py_VISIT(astmodulestate(module)->expr_context_type);
Py_VISIT(astmodulestate(module)->expr_type);
Py_VISIT(astmodulestate(module)->finalbody);
Py_VISIT(astmodulestate(module)->format_spec);
Py_VISIT(astmodulestate(module)->func);
Py_VISIT(astmodulestate(module)->generators);
Py_VISIT(astmodulestate(module)->handlers);
Py_VISIT(astmodulestate(module)->id);
Py_VISIT(astmodulestate(module)->ifs);
Py_VISIT(astmodulestate(module)->is_async);
Py_VISIT(astmodulestate(module)->items);
Py_VISIT(astmodulestate(module)->iter);
Py_VISIT(astmodulestate(module)->key);
Py_VISIT(astmodulestate(module)->keys);
Py_VISIT(astmodulestate(module)->keyword_type);
Py_VISIT(astmodulestate(module)->keywords);
Py_VISIT(astmodulestate(module)->kind);
Py_VISIT(astmodulestate(module)->kw_defaults);
Py_VISIT(astmodulestate(module)->kwarg);
Py_VISIT(astmodulestate(module)->kwonlyargs);
Py_VISIT(astmodulestate(module)->left);
Py_VISIT(astmodulestate(module)->level);
Py_VISIT(astmodulestate(module)->lineno);
Py_VISIT(astmodulestate(module)->lower);
Py_VISIT(astmodulestate(module)->mod_type);
Py_VISIT(astmodulestate(module)->module);
Py_VISIT(astmodulestate(module)->msg);
Py_VISIT(astmodulestate(module)->name);
Py_VISIT(astmodulestate(module)->names);
Py_VISIT(astmodulestate(module)->op);
Py_VISIT(astmodulestate(module)->operand);
Py_VISIT(astmodulestate(module)->operator_type);
Py_VISIT(astmodulestate(module)->ops);
Py_VISIT(astmodulestate(module)->optional_vars);
Py_VISIT(astmodulestate(module)->orelse);
Py_VISIT(astmodulestate(module)->posonlyargs);
Py_VISIT(astmodulestate(module)->returns);
Py_VISIT(astmodulestate(module)->right);
Py_VISIT(astmodulestate(module)->simple);
Py_VISIT(astmodulestate(module)->slice);
Py_VISIT(astmodulestate(module)->slice_type);
Py_VISIT(astmodulestate(module)->step);
Py_VISIT(astmodulestate(module)->stmt_type);
Py_VISIT(astmodulestate(module)->tag);
Py_VISIT(astmodulestate(module)->target);
Py_VISIT(astmodulestate(module)->targets);
Py_VISIT(astmodulestate(module)->test);
Py_VISIT(astmodulestate(module)->type);
Py_VISIT(astmodulestate(module)->type_comment);
Py_VISIT(astmodulestate(module)->type_ignore_type);
Py_VISIT(astmodulestate(module)->type_ignores);
Py_VISIT(astmodulestate(module)->unaryop_type);
Py_VISIT(astmodulestate(module)->upper);
Py_VISIT(astmodulestate(module)->value);
Py_VISIT(astmodulestate(module)->values);
Py_VISIT(astmodulestate(module)->vararg);
Py_VISIT(astmodulestate(module)->withitem_type);
return 0;
}
static void astmodule_free(void* module) {
astmodule_clear((PyObject*)module);
}
static struct PyModuleDef _astmodule = {
PyModuleDef_HEAD_INIT,
"_ast",
NULL,
sizeof(astmodulestate),
NULL,
NULL,
astmodule_traverse,
astmodule_clear,
astmodule_free,
};
#define astmodulestate_global ((astmodulestate *)PyModule_GetState(PyState_FindModule(&_astmodule)))
static int init_identifiers(void)
{
astmodulestate *state = astmodulestate_global;
if ((state->__dict__ = PyUnicode_InternFromString("__dict__")) == NULL) return 0;
if ((state->__module__ = PyUnicode_InternFromString("__module__")) == NULL) return 0;
if ((state->_ast = PyUnicode_InternFromString("_ast")) == NULL) return 0;
if ((state->_attributes = PyUnicode_InternFromString("_attributes")) == NULL) return 0;
if ((state->_fields = PyUnicode_InternFromString("_fields")) == NULL) return 0;
if ((state->annotation = PyUnicode_InternFromString("annotation")) == NULL) return 0;
if ((state->arg = PyUnicode_InternFromString("arg")) == NULL) return 0;
if ((state->args = PyUnicode_InternFromString("args")) == NULL) return 0;
if ((state->argtypes = PyUnicode_InternFromString("argtypes")) == NULL) return 0;
if ((state->asname = PyUnicode_InternFromString("asname")) == NULL) return 0;
if ((state->attr = PyUnicode_InternFromString("attr")) == NULL) return 0;
if ((state->bases = PyUnicode_InternFromString("bases")) == NULL) return 0;
if ((state->body = PyUnicode_InternFromString("body")) == NULL) return 0;
if ((state->cause = PyUnicode_InternFromString("cause")) == NULL) return 0;
if ((state->col_offset = PyUnicode_InternFromString("col_offset")) == NULL) return 0;
if ((state->comparators = PyUnicode_InternFromString("comparators")) == NULL) return 0;
if ((state->context_expr = PyUnicode_InternFromString("context_expr")) == NULL) return 0;
if ((state->conversion = PyUnicode_InternFromString("conversion")) == NULL) return 0;
if ((state->ctx = PyUnicode_InternFromString("ctx")) == NULL) return 0;
if ((state->decorator_list = PyUnicode_InternFromString("decorator_list")) == NULL) return 0;
if ((state->defaults = PyUnicode_InternFromString("defaults")) == NULL) return 0;
if ((state->dims = PyUnicode_InternFromString("dims")) == NULL) return 0;
if ((state->elt = PyUnicode_InternFromString("elt")) == NULL) return 0;
if ((state->elts = PyUnicode_InternFromString("elts")) == NULL) return 0;
if ((state->end_col_offset = PyUnicode_InternFromString("end_col_offset")) == NULL) return 0;
if ((state->end_lineno = PyUnicode_InternFromString("end_lineno")) == NULL) return 0;
if ((state->exc = PyUnicode_InternFromString("exc")) == NULL) return 0;
if ((state->finalbody = PyUnicode_InternFromString("finalbody")) == NULL) return 0;
if ((state->format_spec = PyUnicode_InternFromString("format_spec")) == NULL) return 0;
if ((state->func = PyUnicode_InternFromString("func")) == NULL) return 0;
if ((state->generators = PyUnicode_InternFromString("generators")) == NULL) return 0;
if ((state->handlers = PyUnicode_InternFromString("handlers")) == NULL) return 0;
if ((state->id = PyUnicode_InternFromString("id")) == NULL) return 0;
if ((state->ifs = PyUnicode_InternFromString("ifs")) == NULL) return 0;
if ((state->is_async = PyUnicode_InternFromString("is_async")) == NULL) return 0;
if ((state->items = PyUnicode_InternFromString("items")) == NULL) return 0;
if ((state->iter = PyUnicode_InternFromString("iter")) == NULL) return 0;
if ((state->key = PyUnicode_InternFromString("key")) == NULL) return 0;
if ((state->keys = PyUnicode_InternFromString("keys")) == NULL) return 0;
if ((state->keywords = PyUnicode_InternFromString("keywords")) == NULL) return 0;
if ((state->kind = PyUnicode_InternFromString("kind")) == NULL) return 0;
if ((state->kw_defaults = PyUnicode_InternFromString("kw_defaults")) == NULL) return 0;
if ((state->kwarg = PyUnicode_InternFromString("kwarg")) == NULL) return 0;
if ((state->kwonlyargs = PyUnicode_InternFromString("kwonlyargs")) == NULL) return 0;
if ((state->left = PyUnicode_InternFromString("left")) == NULL) return 0;
if ((state->level = PyUnicode_InternFromString("level")) == NULL) return 0;
if ((state->lineno = PyUnicode_InternFromString("lineno")) == NULL) return 0;
if ((state->lower = PyUnicode_InternFromString("lower")) == NULL) return 0;
if ((state->module = PyUnicode_InternFromString("module")) == NULL) return 0;
if ((state->msg = PyUnicode_InternFromString("msg")) == NULL) return 0;
if ((state->name = PyUnicode_InternFromString("name")) == NULL) return 0;
if ((state->names = PyUnicode_InternFromString("names")) == NULL) return 0;
if ((state->op = PyUnicode_InternFromString("op")) == NULL) return 0;
if ((state->operand = PyUnicode_InternFromString("operand")) == NULL) return 0;
if ((state->ops = PyUnicode_InternFromString("ops")) == NULL) return 0;
if ((state->optional_vars = PyUnicode_InternFromString("optional_vars")) == NULL) return 0;
if ((state->orelse = PyUnicode_InternFromString("orelse")) == NULL) return 0;
if ((state->posonlyargs = PyUnicode_InternFromString("posonlyargs")) == NULL) return 0;
if ((state->returns = PyUnicode_InternFromString("returns")) == NULL) return 0;
if ((state->right = PyUnicode_InternFromString("right")) == NULL) return 0;
if ((state->simple = PyUnicode_InternFromString("simple")) == NULL) return 0;
if ((state->slice = PyUnicode_InternFromString("slice")) == NULL) return 0;
if ((state->step = PyUnicode_InternFromString("step")) == NULL) return 0;
if ((state->tag = PyUnicode_InternFromString("tag")) == NULL) return 0;
if ((state->target = PyUnicode_InternFromString("target")) == NULL) return 0;
if ((state->targets = PyUnicode_InternFromString("targets")) == NULL) return 0;
if ((state->test = PyUnicode_InternFromString("test")) == NULL) return 0;
if ((state->type = PyUnicode_InternFromString("type")) == NULL) return 0;
if ((state->type_comment = PyUnicode_InternFromString("type_comment")) == NULL) return 0;
if ((state->type_ignores = PyUnicode_InternFromString("type_ignores")) == NULL) return 0;
if ((state->upper = PyUnicode_InternFromString("upper")) == NULL) return 0;
if ((state->value = PyUnicode_InternFromString("value")) == NULL) return 0;
if ((state->values = PyUnicode_InternFromString("values")) == NULL) return 0;
if ((state->vararg = PyUnicode_InternFromString("vararg")) == NULL) return 0;
return 1;
};
static PyObject* ast2obj_mod(void*);
static const char * const Module_fields[]={
"body",
"type_ignores",
};
static const char * const Interactive_fields[]={
"body",
};
static const char * const Expression_fields[]={
"body",
};
static const char * const FunctionType_fields[]={
"argtypes",
"returns",
};
static const char * const Suite_fields[]={
"body",
};
static const char * const stmt_attributes[] = {
"lineno",
"col_offset",
"end_lineno",
"end_col_offset",
};
static PyObject* ast2obj_stmt(void*);
static const char * const FunctionDef_fields[]={
"name",
"args",
"body",
"decorator_list",
"returns",
"type_comment",
};
static const char * const AsyncFunctionDef_fields[]={
"name",
"args",
"body",
"decorator_list",
"returns",
"type_comment",
};
static const char * const ClassDef_fields[]={
"name",
"bases",
"keywords",
"body",
"decorator_list",
};
static const char * const Return_fields[]={
"value",
};
static const char * const Delete_fields[]={
"targets",
};
static const char * const Assign_fields[]={
"targets",
"value",
"type_comment",
};
static const char * const AugAssign_fields[]={
"target",
"op",
"value",
};
static const char * const AnnAssign_fields[]={
"target",
"annotation",
"value",
"simple",
};
static const char * const For_fields[]={
"target",
"iter",
"body",
"orelse",
"type_comment",
};
static const char * const AsyncFor_fields[]={
"target",
"iter",
"body",
"orelse",
"type_comment",
};
static const char * const While_fields[]={
"test",
"body",
"orelse",
};
static const char * const If_fields[]={
"test",
"body",
"orelse",
};
static const char * const With_fields[]={
"items",
"body",
"type_comment",
};
static const char * const AsyncWith_fields[]={
"items",
"body",
"type_comment",
};
static const char * const Raise_fields[]={
"exc",
"cause",
};
static const char * const Try_fields[]={
"body",
"handlers",
"orelse",
"finalbody",
};
static const char * const Assert_fields[]={
"test",
"msg",
};
static const char * const Import_fields[]={
"names",
};
static const char * const ImportFrom_fields[]={
"module",
"names",
"level",
};
static const char * const Global_fields[]={
"names",
};
static const char * const Nonlocal_fields[]={
"names",
};
static const char * const Expr_fields[]={
"value",
};
static const char * const expr_attributes[] = {
"lineno",
"col_offset",
"end_lineno",
"end_col_offset",
};
static PyObject* ast2obj_expr(void*);
static const char * const BoolOp_fields[]={
"op",
"values",
};
static const char * const NamedExpr_fields[]={
"target",
"value",
};
static const char * const BinOp_fields[]={
"left",
"op",
"right",
};
static const char * const UnaryOp_fields[]={
"op",
"operand",
};
static const char * const Lambda_fields[]={
"args",
"body",
};
static const char * const IfExp_fields[]={
"test",
"body",
"orelse",
};
static const char * const Dict_fields[]={
"keys",
"values",
};
static const char * const Set_fields[]={
"elts",
};
static const char * const ListComp_fields[]={
"elt",
"generators",
};
static const char * const SetComp_fields[]={
"elt",
"generators",
};
static const char * const DictComp_fields[]={
"key",
"value",
"generators",
};
static const char * const GeneratorExp_fields[]={
"elt",
"generators",
};
static const char * const Await_fields[]={
"value",
};
static const char * const Yield_fields[]={
"value",
};
static const char * const YieldFrom_fields[]={
"value",
};
static const char * const Compare_fields[]={
"left",
"ops",
"comparators",
};
static const char * const Call_fields[]={
"func",
"args",
"keywords",
};
static const char * const FormattedValue_fields[]={
"value",
"conversion",
"format_spec",
};
static const char * const JoinedStr_fields[]={
"values",
};
static const char * const Constant_fields[]={
"value",
"kind",
};
static const char * const Attribute_fields[]={
"value",
"attr",
"ctx",
};
static const char * const Subscript_fields[]={
"value",
"slice",
"ctx",
};
static const char * const Starred_fields[]={
"value",
"ctx",
};
static const char * const Name_fields[]={
"id",
"ctx",
};
static const char * const List_fields[]={
"elts",
"ctx",
};
static const char * const Tuple_fields[]={
"elts",
"ctx",
};
static PyObject* ast2obj_expr_context(expr_context_ty);
static PyObject* ast2obj_slice(void*);
static const char * const Slice_fields[]={
"lower",
"upper",
"step",
};
static const char * const ExtSlice_fields[]={
"dims",
};
static const char * const Index_fields[]={
"value",
};
static PyObject* ast2obj_boolop(boolop_ty);
static PyObject* ast2obj_operator(operator_ty);
static PyObject* ast2obj_unaryop(unaryop_ty);
static PyObject* ast2obj_cmpop(cmpop_ty);
static PyObject* ast2obj_comprehension(void*);
static const char * const comprehension_fields[]={
"target",
"iter",
"ifs",
"is_async",
};
static const char * const excepthandler_attributes[] = {
"lineno",
"col_offset",
"end_lineno",
"end_col_offset",
};
static PyObject* ast2obj_excepthandler(void*);
static const char * const ExceptHandler_fields[]={
"type",
"name",
"body",
};
static PyObject* ast2obj_arguments(void*);
static const char * const arguments_fields[]={
"posonlyargs",
"args",
"vararg",
"kwonlyargs",
"kw_defaults",
"kwarg",
"defaults",
};
static PyObject* ast2obj_arg(void*);
static const char * const arg_attributes[] = {
"lineno",
"col_offset",
"end_lineno",
"end_col_offset",
};
static const char * const arg_fields[]={
"arg",
"annotation",
"type_comment",
};
static PyObject* ast2obj_keyword(void*);
static const char * const keyword_fields[]={
"arg",
"value",
};
static PyObject* ast2obj_alias(void*);
static const char * const alias_fields[]={
"name",
"asname",
};
static PyObject* ast2obj_withitem(void*);
static const char * const withitem_fields[]={
"context_expr",
"optional_vars",
};
static PyObject* ast2obj_type_ignore(void*);
static const char * const TypeIgnore_fields[]={
"lineno",
"tag",
};
typedef struct {
PyObject_HEAD
PyObject *dict;
} AST_object;
static void
ast_dealloc(AST_object *self)
{
/* bpo-31095: UnTrack is needed before calling any callbacks */
PyTypeObject *tp = Py_TYPE(self);
PyObject_GC_UnTrack(self);
Py_CLEAR(self->dict);
freefunc free_func = PyType_GetSlot(tp, Py_tp_free);
assert(free_func != NULL);
free_func(self);
Py_DECREF(tp);
}
static int
ast_traverse(AST_object *self, visitproc visit, void *arg)
{
Py_VISIT(self->dict);
return 0;
}
static int
ast_clear(AST_object *self)
{
Py_CLEAR(self->dict);
return 0;
}
static int
ast_type_init(PyObject *self, PyObject *args, PyObject *kw)
{
Py_ssize_t i, numfields = 0;
int res = -1;
PyObject *key, *value, *fields;
if (_PyObject_LookupAttr((PyObject*)Py_TYPE(self), astmodulestate_global->_fields, &fields) < 0) {
goto cleanup;
}
if (fields) {
numfields = PySequence_Size(fields);
if (numfields == -1)
goto cleanup;
}
res = 0; /* if no error occurs, this stays 0 to the end */
if (numfields < PyTuple_GET_SIZE(args)) {
PyErr_Format(PyExc_TypeError, "%.400s constructor takes at most "
"%zd positional argument%s",
_PyType_Name(Py_TYPE(self)),
numfields, numfields == 1 ? "" : "s");
res = -1;
goto cleanup;
}
for (i = 0; i < PyTuple_GET_SIZE(args); i++) {
/* cannot be reached when fields is NULL */
PyObject *name = PySequence_GetItem(fields, i);
if (!name) {
res = -1;
goto cleanup;
}
res = PyObject_SetAttr(self, name, PyTuple_GET_ITEM(args, i));
Py_DECREF(name);
if (res < 0)
goto cleanup;
}
if (kw) {
i = 0; /* needed by PyDict_Next */
while (PyDict_Next(kw, &i, &key, &value)) {
res = PyObject_SetAttr(self, key, value);
if (res < 0)
goto cleanup;
}
}
cleanup:
Py_XDECREF(fields);
return res;
}
/* Pickling support */
static PyObject *
ast_type_reduce(PyObject *self, PyObject *unused)
{
PyObject *dict;
if (_PyObject_LookupAttr(self, astmodulestate_global->__dict__, &dict) < 0) {
return NULL;
}
if (dict) {
return Py_BuildValue("O()N", Py_TYPE(self), dict);
}
return Py_BuildValue("O()", Py_TYPE(self));
}
static PyMemberDef ast_type_members[] = {
{"__dictoffset__", T_PYSSIZET, offsetof(AST_object, dict), READONLY},
{NULL} /* Sentinel */
};
static PyMethodDef ast_type_methods[] = {
{"__reduce__", ast_type_reduce, METH_NOARGS, NULL},
{NULL}
};
static PyGetSetDef ast_type_getsets[] = {
{"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict},
{NULL}
};
static PyType_Slot AST_type_slots[] = {
{Py_tp_dealloc, ast_dealloc},
{Py_tp_getattro, PyObject_GenericGetAttr},
{Py_tp_setattro, PyObject_GenericSetAttr},
{Py_tp_traverse, ast_traverse},
{Py_tp_clear, ast_clear},
{Py_tp_members, ast_type_members},
{Py_tp_methods, ast_type_methods},
{Py_tp_getset, ast_type_getsets},
{Py_tp_init, ast_type_init},
{Py_tp_alloc, PyType_GenericAlloc},
{Py_tp_new, PyType_GenericNew},
{Py_tp_free, PyType_GenericNew},
{Py_tp_free, PyObject_GC_Del},
{0, 0},
};
static PyType_Spec AST_type_spec = {
"_ast.AST",
sizeof(AST_object),
0,
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
AST_type_slots
};
static PyObject *
make_type(const char *type, PyObject* base, const char* const* fields, int num_fields)
{
PyObject *fnames, *result;
int i;
fnames = PyTuple_New(num_fields);
if (!fnames) return NULL;
for (i = 0; i < num_fields; i++) {
PyObject *field = PyUnicode_InternFromString(fields[i]);
if (!field) {
Py_DECREF(fnames);
return NULL;
}
PyTuple_SET_ITEM(fnames, i, field);
}
result = PyObject_CallFunction((PyObject*)&PyType_Type, "s(O){OOOO}",
type, base,
astmodulestate_global->_fields, fnames,
astmodulestate_global->__module__,
astmodulestate_global->_ast);
Py_DECREF(fnames);
return result;
}
static int
add_attributes(PyObject *type, const char * const *attrs, int num_fields)
{
int i, result;
PyObject *s, *l = PyTuple_New(num_fields);
if (!l)
return 0;
for (i = 0; i < num_fields; i++) {
s = PyUnicode_InternFromString(attrs[i]);
if (!s) {
Py_DECREF(l);
return 0;
}
PyTuple_SET_ITEM(l, i, s);
}
result = PyObject_SetAttr(type, astmodulestate_global->_attributes, l) >= 0;
Py_DECREF(l);
return result;
}
/* Conversion AST -> Python */
static PyObject* ast2obj_list(asdl_seq *seq, PyObject* (*func)(void*))
{
Py_ssize_t i, n = asdl_seq_LEN(seq);
PyObject *result = PyList_New(n);
PyObject *value;
if (!result)
return NULL;
for (i = 0; i < n; i++) {
value = func(asdl_seq_GET(seq, i));
if (!value) {
Py_DECREF(result);
return NULL;
}
PyList_SET_ITEM(result, i, value);
}
return result;
}
static PyObject* ast2obj_object(void *o)
{
if (!o)
o = Py_None;
Py_INCREF((PyObject*)o);
return (PyObject*)o;
}
#define ast2obj_singleton ast2obj_object
#define ast2obj_constant ast2obj_object
#define ast2obj_identifier ast2obj_object
#define ast2obj_string ast2obj_object
#define ast2obj_bytes ast2obj_object
static PyObject* ast2obj_int(long b)
{
return PyLong_FromLong(b);
}
/* Conversion Python -> AST */
static int obj2ast_object(PyObject* obj, PyObject** out, PyArena* arena)
{
if (obj == Py_None)
obj = NULL;
if (obj) {
if (PyArena_AddPyObject(arena, obj) < 0) {
*out = NULL;
return -1;
}
Py_INCREF(obj);
}
*out = obj;
return 0;
}
static int obj2ast_constant(PyObject* obj, PyObject** out, PyArena* arena)
{
if (PyArena_AddPyObject(arena, obj) < 0) {
*out = NULL;
return -1;
}
Py_INCREF(obj);
*out = obj;
return 0;
}
static int obj2ast_identifier(PyObject* obj, PyObject** out, PyArena* arena)
{
if (!PyUnicode_CheckExact(obj) && obj != Py_None) {
PyErr_SetString(PyExc_TypeError, "AST identifier must be of type str");
return 1;
}
return obj2ast_object(obj, out, arena);
}
static int obj2ast_string(PyObject* obj, PyObject** out, PyArena* arena)
{
if (!PyUnicode_CheckExact(obj) && !PyBytes_CheckExact(obj)) {
PyErr_SetString(PyExc_TypeError, "AST string must be of type str");
return 1;
}
return obj2ast_object(obj, out, arena);
}
static int obj2ast_int(PyObject* obj, int* out, PyArena* arena)
{
int i;
if (!PyLong_Check(obj)) {
PyErr_Format(PyExc_ValueError, "invalid integer value: %R", obj);
return 1;
}
i = _PyLong_AsInt(obj);
if (i == -1 && PyErr_Occurred())
return 1;
*out = i;
return 0;
}
static int add_ast_fields(void)
{
PyObject *empty_tuple;
empty_tuple = PyTuple_New(0);
if (!empty_tuple ||
PyObject_SetAttrString(astmodulestate_global->AST_type, "_fields", empty_tuple) < 0 ||
PyObject_SetAttrString(astmodulestate_global->AST_type, "_attributes", empty_tuple) < 0) {
Py_XDECREF(empty_tuple);
return -1;
}
Py_DECREF(empty_tuple);
return 0;
}
static int init_types(void)
{
PyObject *m;
if (PyState_FindModule(&_astmodule) == NULL) {
m = PyModule_Create(&_astmodule);
if (!m) return 0;
PyState_AddModule(m, &_astmodule);
}
astmodulestate *state = astmodulestate_global;
if (state->initialized) return 1;
if (init_identifiers() < 0) return 0;
state->AST_type = PyType_FromSpec(&AST_type_spec);
if (!state->AST_type) return 0;
if (add_ast_fields() < 0) return 0;
state->mod_type = make_type("mod", state->AST_type, NULL, 0);
if (!state->mod_type) return 0;
if (!add_attributes(state->mod_type, NULL, 0)) return 0;
state->Module_type = make_type("Module", state->mod_type, Module_fields, 2);
if (!state->Module_type) return 0;
state->Interactive_type = make_type("Interactive", state->mod_type,
Interactive_fields, 1);
if (!state->Interactive_type) return 0;
state->Expression_type = make_type("Expression", state->mod_type,
Expression_fields, 1);
if (!state->Expression_type) return 0;
state->FunctionType_type = make_type("FunctionType", state->mod_type,
FunctionType_fields, 2);
if (!state->FunctionType_type) return 0;
state->Suite_type = make_type("Suite", state->mod_type, Suite_fields, 1);
if (!state->Suite_type) return 0;
state->stmt_type = make_type("stmt", state->AST_type, NULL, 0);
if (!state->stmt_type) return 0;
if (!add_attributes(state->stmt_type, stmt_attributes, 4)) return 0;
state->FunctionDef_type = make_type("FunctionDef", state->stmt_type,
FunctionDef_fields, 6);
if (!state->FunctionDef_type) return 0;
state->AsyncFunctionDef_type = make_type("AsyncFunctionDef",
state->stmt_type,
AsyncFunctionDef_fields, 6);
if (!state->AsyncFunctionDef_type) return 0;
state->ClassDef_type = make_type("ClassDef", state->stmt_type,
ClassDef_fields, 5);
if (!state->ClassDef_type) return 0;
state->Return_type = make_type("Return", state->stmt_type, Return_fields,
1);
if (!state->Return_type) return 0;
state->Delete_type = make_type("Delete", state->stmt_type, Delete_fields,
1);
if (!state->Delete_type) return 0;
state->Assign_type = make_type("Assign", state->stmt_type, Assign_fields,
3);
if (!state->Assign_type) return 0;
state->AugAssign_type = make_type("AugAssign", state->stmt_type,
AugAssign_fields, 3);
if (!state->AugAssign_type) return 0;
state->AnnAssign_type = make_type("AnnAssign", state->stmt_type,
AnnAssign_fields, 4);
if (!state->AnnAssign_type) return 0;
state->For_type = make_type("For", state->stmt_type, For_fields, 5);
if (!state->For_type) return 0;
state->AsyncFor_type = make_type("AsyncFor", state->stmt_type,
AsyncFor_fields, 5);
if (!state->AsyncFor_type) return 0;
state->While_type = make_type("While", state->stmt_type, While_fields, 3);
if (!state->While_type) return 0;
state->If_type = make_type("If", state->stmt_type, If_fields, 3);
if (!state->If_type) return 0;
state->With_type = make_type("With", state->stmt_type, With_fields, 3);
if (!state->With_type) return 0;
state->AsyncWith_type = make_type("AsyncWith", state->stmt_type,
AsyncWith_fields, 3);
if (!state->AsyncWith_type) return 0;
state->Raise_type = make_type("Raise", state->stmt_type, Raise_fields, 2);
if (!state->Raise_type) return 0;
state->Try_type = make_type("Try", state->stmt_type, Try_fields, 4);
if (!state->Try_type) return 0;
state->Assert_type = make_type("Assert", state->stmt_type, Assert_fields,
2);
if (!state->Assert_type) return 0;
state->Import_type = make_type("Import", state->stmt_type, Import_fields,
1);
if (!state->Import_type) return 0;
state->ImportFrom_type = make_type("ImportFrom", state->stmt_type,
ImportFrom_fields, 3);
if (!state->ImportFrom_type) return 0;
state->Global_type = make_type("Global", state->stmt_type, Global_fields,
1);
if (!state->Global_type) return 0;
state->Nonlocal_type = make_type("Nonlocal", state->stmt_type,
Nonlocal_fields, 1);
if (!state->Nonlocal_type) return 0;
state->Expr_type = make_type("Expr", state->stmt_type, Expr_fields, 1);
if (!state->Expr_type) return 0;
state->Pass_type = make_type("Pass", state->stmt_type, NULL, 0);
if (!state->Pass_type) return 0;
state->Break_type = make_type("Break", state->stmt_type, NULL, 0);
if (!state->Break_type) return 0;
state->Continue_type = make_type("Continue", state->stmt_type, NULL, 0);
if (!state->Continue_type) return 0;
state->expr_type = make_type("expr", state->AST_type, NULL, 0);
if (!state->expr_type) return 0;
if (!add_attributes(state->expr_type, expr_attributes, 4)) return 0;
state->BoolOp_type = make_type("BoolOp", state->expr_type, BoolOp_fields,
2);
if (!state->BoolOp_type) return 0;
state->NamedExpr_type = make_type("NamedExpr", state->expr_type,
NamedExpr_fields, 2);
if (!state->NamedExpr_type) return 0;
state->BinOp_type = make_type("BinOp", state->expr_type, BinOp_fields, 3);
if (!state->BinOp_type) return 0;
state->UnaryOp_type = make_type("UnaryOp", state->expr_type,
UnaryOp_fields, 2);
if (!state->UnaryOp_type) return 0;
state->Lambda_type = make_type("Lambda", state->expr_type, Lambda_fields,
2);
if (!state->Lambda_type) return 0;
state->IfExp_type = make_type("IfExp", state->expr_type, IfExp_fields, 3);
if (!state->IfExp_type) return 0;
state->Dict_type = make_type("Dict", state->expr_type, Dict_fields, 2);
if (!state->Dict_type) return 0;
state->Set_type = make_type("Set", state->expr_type, Set_fields, 1);
if (!state->Set_type) return 0;
state->ListComp_type = make_type("ListComp", state->expr_type,
ListComp_fields, 2);
if (!state->ListComp_type) return 0;
state->SetComp_type = make_type("SetComp", state->expr_type,
SetComp_fields, 2);
if (!state->SetComp_type) return 0;
state->DictComp_type = make_type("DictComp", state->expr_type,
DictComp_fields, 3);
if (!state->DictComp_type) return 0;
state->GeneratorExp_type = make_type("GeneratorExp", state->expr_type,
GeneratorExp_fields, 2);
if (!state->GeneratorExp_type) return 0;
state->Await_type = make_type("Await", state->expr_type, Await_fields, 1);
if (!state->Await_type) return 0;
state->Yield_type = make_type("Yield", state->expr_type, Yield_fields, 1);
if (!state->Yield_type) return 0;
state->YieldFrom_type = make_type("YieldFrom", state->expr_type,
YieldFrom_fields, 1);
if (!state->YieldFrom_type) return 0;
state->Compare_type = make_type("Compare", state->expr_type,
Compare_fields, 3);
if (!state->Compare_type) return 0;
state->Call_type = make_type("Call", state->expr_type, Call_fields, 3);
if (!state->Call_type) return 0;
state->FormattedValue_type = make_type("FormattedValue", state->expr_type,
FormattedValue_fields, 3);
if (!state->FormattedValue_type) return 0;
state->JoinedStr_type = make_type("JoinedStr", state->expr_type,
JoinedStr_fields, 1);
if (!state->JoinedStr_type) return 0;
state->Constant_type = make_type("Constant", state->expr_type,
Constant_fields, 2);
if (!state->Constant_type) return 0;
state->Attribute_type = make_type("Attribute", state->expr_type,
Attribute_fields, 3);
if (!state->Attribute_type) return 0;
state->Subscript_type = make_type("Subscript", state->expr_type,
Subscript_fields, 3);
if (!state->Subscript_type) return 0;
state->Starred_type = make_type("Starred", state->expr_type,
Starred_fields, 2);
if (!state->Starred_type) return 0;
state->Name_type = make_type("Name", state->expr_type, Name_fields, 2);
if (!state->Name_type) return 0;
state->List_type = make_type("List", state->expr_type, List_fields, 2);
if (!state->List_type) return 0;
state->Tuple_type = make_type("Tuple", state->expr_type, Tuple_fields, 2);
if (!state->Tuple_type) return 0;
state->expr_context_type = make_type("expr_context", state->AST_type, NULL,
0);
if (!state->expr_context_type) return 0;
if (!add_attributes(state->expr_context_type, NULL, 0)) return 0;
state->Load_type = make_type("Load", state->expr_context_type, NULL, 0);
if (!state->Load_type) return 0;
state->Load_singleton = PyType_GenericNew((PyTypeObject *)state->Load_type,
NULL, NULL);
if (!state->Load_singleton) return 0;
state->Store_type = make_type("Store", state->expr_context_type, NULL, 0);
if (!state->Store_type) return 0;
state->Store_singleton = PyType_GenericNew((PyTypeObject
*)state->Store_type, NULL, NULL);
if (!state->Store_singleton) return 0;
state->Del_type = make_type("Del", state->expr_context_type, NULL, 0);
if (!state->Del_type) return 0;
state->Del_singleton = PyType_GenericNew((PyTypeObject *)state->Del_type,
NULL, NULL);
if (!state->Del_singleton) return 0;
state->AugLoad_type = make_type("AugLoad", state->expr_context_type, NULL,
0);
if (!state->AugLoad_type) return 0;
state->AugLoad_singleton = PyType_GenericNew((PyTypeObject
*)state->AugLoad_type, NULL,
NULL);
if (!state->AugLoad_singleton) return 0;
state->AugStore_type = make_type("AugStore", state->expr_context_type,
NULL, 0);
if (!state->AugStore_type) return 0;
state->AugStore_singleton = PyType_GenericNew((PyTypeObject
*)state->AugStore_type, NULL,
NULL);
if (!state->AugStore_singleton) return 0;
state->Param_type = make_type("Param", state->expr_context_type, NULL, 0);
if (!state->Param_type) return 0;
state->Param_singleton = PyType_GenericNew((PyTypeObject
*)state->Param_type, NULL, NULL);
if (!state->Param_singleton) return 0;
state->slice_type = make_type("slice", state->AST_type, NULL, 0);
if (!state->slice_type) return 0;
if (!add_attributes(state->slice_type, NULL, 0)) return 0;
state->Slice_type = make_type("Slice", state->slice_type, Slice_fields, 3);
if (!state->Slice_type) return 0;
state->ExtSlice_type = make_type("ExtSlice", state->slice_type,
ExtSlice_fields, 1);
if (!state->ExtSlice_type) return 0;
state->Index_type = make_type("Index", state->slice_type, Index_fields, 1);
if (!state->Index_type) return 0;
state->boolop_type = make_type("boolop", state->AST_type, NULL, 0);
if (!state->boolop_type) return 0;
if (!add_attributes(state->boolop_type, NULL, 0)) return 0;
state->And_type = make_type("And", state->boolop_type, NULL, 0);
if (!state->And_type) return 0;
state->And_singleton = PyType_GenericNew((PyTypeObject *)state->And_type,
NULL, NULL);
if (!state->And_singleton) return 0;
state->Or_type = make_type("Or", state->boolop_type, NULL, 0);
if (!state->Or_type) return 0;
state->Or_singleton = PyType_GenericNew((PyTypeObject *)state->Or_type,
NULL, NULL);
if (!state->Or_singleton) return 0;
state->operator_type = make_type("operator", state->AST_type, NULL, 0);
if (!state->operator_type) return 0;
if (!add_attributes(state->operator_type, NULL, 0)) return 0;
state->Add_type = make_type("Add", state->operator_type, NULL, 0);
if (!state->Add_type) return 0;
state->Add_singleton = PyType_GenericNew((PyTypeObject *)state->Add_type,
NULL, NULL);
if (!state->Add_singleton) return 0;
state->Sub_type = make_type("Sub", state->operator_type, NULL, 0);
if (!state->Sub_type) return 0;
state->Sub_singleton = PyType_GenericNew((PyTypeObject *)state->Sub_type,
NULL, NULL);
if (!state->Sub_singleton) return 0;
state->Mult_type = make_type("Mult", state->operator_type, NULL, 0);
if (!state->Mult_type) return 0;
state->Mult_singleton = PyType_GenericNew((PyTypeObject *)state->Mult_type,
NULL, NULL);
if (!state->Mult_singleton) return 0;
state->MatMult_type = make_type("MatMult", state->operator_type, NULL, 0);
if (!state->MatMult_type) return 0;
state->MatMult_singleton = PyType_GenericNew((PyTypeObject
*)state->MatMult_type, NULL,
NULL);
if (!state->MatMult_singleton) return 0;
state->Div_type = make_type("Div", state->operator_type, NULL, 0);
if (!state->Div_type) return 0;
state->Div_singleton = PyType_GenericNew((PyTypeObject *)state->Div_type,
NULL, NULL);
if (!state->Div_singleton) return 0;
state->Mod_type = make_type("Mod", state->operator_type, NULL, 0);
if (!state->Mod_type) return 0;
state->Mod_singleton = PyType_GenericNew((PyTypeObject *)state->Mod_type,
NULL, NULL);
if (!state->Mod_singleton) return 0;
state->Pow_type = make_type("Pow", state->operator_type, NULL, 0);
if (!state->Pow_type) return 0;
state->Pow_singleton = PyType_GenericNew((PyTypeObject *)state->Pow_type,
NULL, NULL);
if (!state->Pow_singleton) return 0;
state->LShift_type = make_type("LShift", state->operator_type, NULL, 0);
if (!state->LShift_type) return 0;
state->LShift_singleton = PyType_GenericNew((PyTypeObject
*)state->LShift_type, NULL,
NULL);
if (!state->LShift_singleton) return 0;
state->RShift_type = make_type("RShift", state->operator_type, NULL, 0);
if (!state->RShift_type) return 0;
state->RShift_singleton = PyType_GenericNew((PyTypeObject
*)state->RShift_type, NULL,
NULL);
if (!state->RShift_singleton) return 0;
state->BitOr_type = make_type("BitOr", state->operator_type, NULL, 0);
if (!state->BitOr_type) return 0;
state->BitOr_singleton = PyType_GenericNew((PyTypeObject
*)state->BitOr_type, NULL, NULL);
if (!state->BitOr_singleton) return 0;
state->BitXor_type = make_type("BitXor", state->operator_type, NULL, 0);
if (!state->BitXor_type) return 0;
state->BitXor_singleton = PyType_GenericNew((PyTypeObject
*)state->BitXor_type, NULL,
NULL);
if (!state->BitXor_singleton) return 0;
state->BitAnd_type = make_type("BitAnd", state->operator_type, NULL, 0);
if (!state->BitAnd_type) return 0;
state->BitAnd_singleton = PyType_GenericNew((PyTypeObject
*)state->BitAnd_type, NULL,
NULL);
if (!state->BitAnd_singleton) return 0;
state->FloorDiv_type = make_type("FloorDiv", state->operator_type, NULL, 0);
if (!state->FloorDiv_type) return 0;
state->FloorDiv_singleton = PyType_GenericNew((PyTypeObject
*)state->FloorDiv_type, NULL,
NULL);
if (!state->FloorDiv_singleton) return 0;
state->unaryop_type = make_type("unaryop", state->AST_type, NULL, 0);
if (!state->unaryop_type) return 0;
if (!add_attributes(state->unaryop_type, NULL, 0)) return 0;
state->Invert_type = make_type("Invert", state->unaryop_type, NULL, 0);
if (!state->Invert_type) return 0;
state->Invert_singleton = PyType_GenericNew((PyTypeObject
*)state->Invert_type, NULL,
NULL);
if (!state->Invert_singleton) return 0;
state->Not_type = make_type("Not", state->unaryop_type, NULL, 0);
if (!state->Not_type) return 0;
state->Not_singleton = PyType_GenericNew((PyTypeObject *)state->Not_type,
NULL, NULL);
if (!state->Not_singleton) return 0;
state->UAdd_type = make_type("UAdd", state->unaryop_type, NULL, 0);
if (!state->UAdd_type) return 0;
state->UAdd_singleton = PyType_GenericNew((PyTypeObject *)state->UAdd_type,
NULL, NULL);
if (!state->UAdd_singleton) return 0;
state->USub_type = make_type("USub", state->unaryop_type, NULL, 0);
if (!state->USub_type) return 0;
state->USub_singleton = PyType_GenericNew((PyTypeObject *)state->USub_type,
NULL, NULL);
if (!state->USub_singleton) return 0;
state->cmpop_type = make_type("cmpop", state->AST_type, NULL, 0);
if (!state->cmpop_type) return 0;
if (!add_attributes(state->cmpop_type, NULL, 0)) return 0;
state->Eq_type = make_type("Eq", state->cmpop_type, NULL, 0);
if (!state->Eq_type) return 0;
state->Eq_singleton = PyType_GenericNew((PyTypeObject *)state->Eq_type,
NULL, NULL);
if (!state->Eq_singleton) return 0;
state->NotEq_type = make_type("NotEq", state->cmpop_type, NULL, 0);
if (!state->NotEq_type) return 0;
state->NotEq_singleton = PyType_GenericNew((PyTypeObject
*)state->NotEq_type, NULL, NULL);
if (!state->NotEq_singleton) return 0;
state->Lt_type = make_type("Lt", state->cmpop_type, NULL, 0);
if (!state->Lt_type) return 0;
state->Lt_singleton = PyType_GenericNew((PyTypeObject *)state->Lt_type,
NULL, NULL);
if (!state->Lt_singleton) return 0;
state->LtE_type = make_type("LtE", state->cmpop_type, NULL, 0);
if (!state->LtE_type) return 0;
state->LtE_singleton = PyType_GenericNew((PyTypeObject *)state->LtE_type,
NULL, NULL);
if (!state->LtE_singleton) return 0;
state->Gt_type = make_type("Gt", state->cmpop_type, NULL, 0);
if (!state->Gt_type) return 0;
state->Gt_singleton = PyType_GenericNew((PyTypeObject *)state->Gt_type,
NULL, NULL);
if (!state->Gt_singleton) return 0;
state->GtE_type = make_type("GtE", state->cmpop_type, NULL, 0);
if (!state->GtE_type) return 0;
state->GtE_singleton = PyType_GenericNew((PyTypeObject *)state->GtE_type,
NULL, NULL);
if (!state->GtE_singleton) return 0;
state->Is_type = make_type("Is", state->cmpop_type, NULL, 0);
if (!state->Is_type) return 0;
state->Is_singleton = PyType_GenericNew((PyTypeObject *)state->Is_type,
NULL, NULL);
if (!state->Is_singleton) return 0;
state->IsNot_type = make_type("IsNot", state->cmpop_type, NULL, 0);
if (!state->IsNot_type) return 0;
state->IsNot_singleton = PyType_GenericNew((PyTypeObject
*)state->IsNot_type, NULL, NULL);
if (!state->IsNot_singleton) return 0;
state->In_type = make_type("In", state->cmpop_type, NULL, 0);
if (!state->In_type) return 0;
state->In_singleton = PyType_GenericNew((PyTypeObject *)state->In_type,
NULL, NULL);
if (!state->In_singleton) return 0;
state->NotIn_type = make_type("NotIn", state->cmpop_type, NULL, 0);
if (!state->NotIn_type) return 0;
state->NotIn_singleton = PyType_GenericNew((PyTypeObject
*)state->NotIn_type, NULL, NULL);
if (!state->NotIn_singleton) return 0;
state->comprehension_type = make_type("comprehension", state->AST_type,
comprehension_fields, 4);
if (!state->comprehension_type) return 0;
if (!add_attributes(state->comprehension_type, NULL, 0)) return 0;
state->excepthandler_type = make_type("excepthandler", state->AST_type,
NULL, 0);
if (!state->excepthandler_type) return 0;
if (!add_attributes(state->excepthandler_type, excepthandler_attributes,
4)) return 0;
state->ExceptHandler_type = make_type("ExceptHandler",
state->excepthandler_type,
ExceptHandler_fields, 3);
if (!state->ExceptHandler_type) return 0;
state->arguments_type = make_type("arguments", state->AST_type,
arguments_fields, 7);
if (!state->arguments_type) return 0;
if (!add_attributes(state->arguments_type, NULL, 0)) return 0;
state->arg_type = make_type("arg", state->AST_type, arg_fields, 3);
if (!state->arg_type) return 0;
if (!add_attributes(state->arg_type, arg_attributes, 4)) return 0;
state->keyword_type = make_type("keyword", state->AST_type, keyword_fields,
2);
if (!state->keyword_type) return 0;
if (!add_attributes(state->keyword_type, NULL, 0)) return 0;
state->alias_type = make_type("alias", state->AST_type, alias_fields, 2);
if (!state->alias_type) return 0;
if (!add_attributes(state->alias_type, NULL, 0)) return 0;
state->withitem_type = make_type("withitem", state->AST_type,
withitem_fields, 2);
if (!state->withitem_type) return 0;
if (!add_attributes(state->withitem_type, NULL, 0)) return 0;
state->type_ignore_type = make_type("type_ignore", state->AST_type, NULL,
0);
if (!state->type_ignore_type) return 0;
if (!add_attributes(state->type_ignore_type, NULL, 0)) return 0;
state->TypeIgnore_type = make_type("TypeIgnore", state->type_ignore_type,
TypeIgnore_fields, 2);
if (!state->TypeIgnore_type) return 0;
state->initialized = 1;
return 1;
}
static int obj2ast_mod(PyObject* obj, mod_ty* out, PyArena* arena);
static int obj2ast_stmt(PyObject* obj, stmt_ty* out, PyArena* arena);
static int obj2ast_expr(PyObject* obj, expr_ty* out, PyArena* arena);
static int obj2ast_expr_context(PyObject* obj, expr_context_ty* out, PyArena*
arena);
static int obj2ast_slice(PyObject* obj, slice_ty* out, PyArena* arena);
static int obj2ast_boolop(PyObject* obj, boolop_ty* out, PyArena* arena);
static int obj2ast_operator(PyObject* obj, operator_ty* out, PyArena* arena);
static int obj2ast_unaryop(PyObject* obj, unaryop_ty* out, PyArena* arena);
static int obj2ast_cmpop(PyObject* obj, cmpop_ty* out, PyArena* arena);
static int obj2ast_comprehension(PyObject* obj, comprehension_ty* out, PyArena*
arena);
static int obj2ast_excepthandler(PyObject* obj, excepthandler_ty* out, PyArena*
arena);
static int obj2ast_arguments(PyObject* obj, arguments_ty* out, PyArena* arena);
static int obj2ast_arg(PyObject* obj, arg_ty* out, PyArena* arena);
static int obj2ast_keyword(PyObject* obj, keyword_ty* out, PyArena* arena);
static int obj2ast_alias(PyObject* obj, alias_ty* out, PyArena* arena);
static int obj2ast_withitem(PyObject* obj, withitem_ty* out, PyArena* arena);
static int obj2ast_type_ignore(PyObject* obj, type_ignore_ty* out, PyArena*
arena);
mod_ty
Module(asdl_seq * body, asdl_seq * type_ignores, PyArena *arena)
{
mod_ty p;
p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Module_kind;
p->v.Module.body = body;
p->v.Module.type_ignores = type_ignores;
return p;
}
mod_ty
Interactive(asdl_seq * body, PyArena *arena)
{
mod_ty p;
p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Interactive_kind;
p->v.Interactive.body = body;
return p;
}
mod_ty
Expression(expr_ty body, PyArena *arena)
{
mod_ty p;
if (!body) {
PyErr_SetString(PyExc_ValueError,
"field body is required for Expression");
return NULL;
}
p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Expression_kind;
p->v.Expression.body = body;
return p;
}
mod_ty
FunctionType(asdl_seq * argtypes, expr_ty returns, PyArena *arena)
{
mod_ty p;
if (!returns) {
PyErr_SetString(PyExc_ValueError,
"field returns is required for FunctionType");
return NULL;
}
p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = FunctionType_kind;
p->v.FunctionType.argtypes = argtypes;
p->v.FunctionType.returns = returns;
return p;
}
mod_ty
Suite(asdl_seq * body, PyArena *arena)
{
mod_ty p;
p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Suite_kind;
p->v.Suite.body = body;
return p;
}
stmt_ty
FunctionDef(identifier name, arguments_ty args, asdl_seq * body, asdl_seq *
decorator_list, expr_ty returns, string type_comment, int lineno,
int col_offset, int end_lineno, int end_col_offset, PyArena *arena)
{
stmt_ty p;
if (!name) {
PyErr_SetString(PyExc_ValueError,
"field name is required for FunctionDef");
return NULL;
}
if (!args) {
PyErr_SetString(PyExc_ValueError,
"field args is required for FunctionDef");
return NULL;
}
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = FunctionDef_kind;
p->v.FunctionDef.name = name;
p->v.FunctionDef.args = args;
p->v.FunctionDef.body = body;
p->v.FunctionDef.decorator_list = decorator_list;
p->v.FunctionDef.returns = returns;
p->v.FunctionDef.type_comment = type_comment;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
stmt_ty
AsyncFunctionDef(identifier name, arguments_ty args, asdl_seq * body, asdl_seq
* decorator_list, expr_ty returns, string type_comment, int
lineno, int col_offset, int end_lineno, int end_col_offset,
PyArena *arena)
{
stmt_ty p;
if (!name) {
PyErr_SetString(PyExc_ValueError,
"field name is required for AsyncFunctionDef");
return NULL;
}
if (!args) {
PyErr_SetString(PyExc_ValueError,
"field args is required for AsyncFunctionDef");
return NULL;
}
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = AsyncFunctionDef_kind;
p->v.AsyncFunctionDef.name = name;
p->v.AsyncFunctionDef.args = args;
p->v.AsyncFunctionDef.body = body;
p->v.AsyncFunctionDef.decorator_list = decorator_list;
p->v.AsyncFunctionDef.returns = returns;
p->v.AsyncFunctionDef.type_comment = type_comment;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
stmt_ty
ClassDef(identifier name, asdl_seq * bases, asdl_seq * keywords, asdl_seq *
body, asdl_seq * decorator_list, int lineno, int col_offset, int
end_lineno, int end_col_offset, PyArena *arena)
{
stmt_ty p;
if (!name) {
PyErr_SetString(PyExc_ValueError,
"field name is required for ClassDef");
return NULL;
}
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = ClassDef_kind;
p->v.ClassDef.name = name;
p->v.ClassDef.bases = bases;
p->v.ClassDef.keywords = keywords;
p->v.ClassDef.body = body;
p->v.ClassDef.decorator_list = decorator_list;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
stmt_ty
Return(expr_ty value, int lineno, int col_offset, int end_lineno, int
end_col_offset, PyArena *arena)
{
stmt_ty p;
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Return_kind;
p->v.Return.value = value;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
stmt_ty
Delete(asdl_seq * targets, int lineno, int col_offset, int end_lineno, int
end_col_offset, PyArena *arena)
{
stmt_ty p;
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Delete_kind;
p->v.Delete.targets = targets;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
stmt_ty
Assign(asdl_seq * targets, expr_ty value, string type_comment, int lineno, int
col_offset, int end_lineno, int end_col_offset, PyArena *arena)
{
stmt_ty p;
if (!value) {
PyErr_SetString(PyExc_ValueError,
"field value is required for Assign");
return NULL;
}
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Assign_kind;
p->v.Assign.targets = targets;
p->v.Assign.value = value;
p->v.Assign.type_comment = type_comment;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
stmt_ty
AugAssign(expr_ty target, operator_ty op, expr_ty value, int lineno, int
col_offset, int end_lineno, int end_col_offset, PyArena *arena)
{
stmt_ty p;
if (!target) {
PyErr_SetString(PyExc_ValueError,
"field target is required for AugAssign");
return NULL;
}
if (!op) {
PyErr_SetString(PyExc_ValueError,
"field op is required for AugAssign");
return NULL;
}
if (!value) {
PyErr_SetString(PyExc_ValueError,
"field value is required for AugAssign");
return NULL;
}
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = AugAssign_kind;
p->v.AugAssign.target = target;
p->v.AugAssign.op = op;
p->v.AugAssign.value = value;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
stmt_ty
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)
{
stmt_ty p;
if (!target) {
PyErr_SetString(PyExc_ValueError,
"field target is required for AnnAssign");
return NULL;
}
if (!annotation) {
PyErr_SetString(PyExc_ValueError,
"field annotation is required for AnnAssign");
return NULL;
}
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = AnnAssign_kind;
p->v.AnnAssign.target = target;
p->v.AnnAssign.annotation = annotation;
p->v.AnnAssign.value = value;
p->v.AnnAssign.simple = simple;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
stmt_ty
For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * orelse, string
type_comment, int lineno, int col_offset, int end_lineno, int
end_col_offset, PyArena *arena)
{
stmt_ty p;
if (!target) {
PyErr_SetString(PyExc_ValueError,
"field target is required for For");
return NULL;
}
if (!iter) {
PyErr_SetString(PyExc_ValueError,
"field iter is required for For");
return NULL;
}
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = For_kind;
p->v.For.target = target;
p->v.For.iter = iter;
p->v.For.body = body;
p->v.For.orelse = orelse;
p->v.For.type_comment = type_comment;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
stmt_ty
AsyncFor(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * orelse,
string type_comment, int lineno, int col_offset, int end_lineno, int
end_col_offset, PyArena *arena)
{
stmt_ty p;
if (!target) {
PyErr_SetString(PyExc_ValueError,
"field target is required for AsyncFor");
return NULL;
}
if (!iter) {
PyErr_SetString(PyExc_ValueError,
"field iter is required for AsyncFor");
return NULL;
}
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = AsyncFor_kind;
p->v.AsyncFor.target = target;
p->v.AsyncFor.iter = iter;
p->v.AsyncFor.body = body;
p->v.AsyncFor.orelse = orelse;
p->v.AsyncFor.type_comment = type_comment;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
stmt_ty
While(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, int
col_offset, int end_lineno, int end_col_offset, PyArena *arena)
{
stmt_ty p;
if (!test) {
PyErr_SetString(PyExc_ValueError,
"field test is required for While");
return NULL;
}
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = While_kind;
p->v.While.test = test;
p->v.While.body = body;
p->v.While.orelse = orelse;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
stmt_ty
If(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, int
col_offset, int end_lineno, int end_col_offset, PyArena *arena)
{
stmt_ty p;
if (!test) {
PyErr_SetString(PyExc_ValueError,
"field test is required for If");
return NULL;
}
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = If_kind;
p->v.If.test = test;
p->v.If.body = body;
p->v.If.orelse = orelse;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
stmt_ty
With(asdl_seq * items, asdl_seq * body, string type_comment, int lineno, int
col_offset, int end_lineno, int end_col_offset, PyArena *arena)
{
stmt_ty p;
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = With_kind;
p->v.With.items = items;
p->v.With.body = body;
p->v.With.type_comment = type_comment;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
stmt_ty
AsyncWith(asdl_seq * items, asdl_seq * body, string type_comment, int lineno,
int col_offset, int end_lineno, int end_col_offset, PyArena *arena)
{
stmt_ty p;
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = AsyncWith_kind;
p->v.AsyncWith.items = items;
p->v.AsyncWith.body = body;
p->v.AsyncWith.type_comment = type_comment;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
stmt_ty
Raise(expr_ty exc, expr_ty cause, int lineno, int col_offset, int end_lineno,
int end_col_offset, PyArena *arena)
{
stmt_ty p;
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Raise_kind;
p->v.Raise.exc = exc;
p->v.Raise.cause = cause;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
stmt_ty
Try(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse, asdl_seq *
finalbody, int lineno, int col_offset, int end_lineno, int end_col_offset,
PyArena *arena)
{
stmt_ty p;
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Try_kind;
p->v.Try.body = body;
p->v.Try.handlers = handlers;
p->v.Try.orelse = orelse;
p->v.Try.finalbody = finalbody;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
stmt_ty
Assert(expr_ty test, expr_ty msg, int lineno, int col_offset, int end_lineno,
int end_col_offset, PyArena *arena)
{
stmt_ty p;
if (!test) {
PyErr_SetString(PyExc_ValueError,
"field test is required for Assert");
return NULL;
}
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Assert_kind;
p->v.Assert.test = test;
p->v.Assert.msg = msg;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
stmt_ty
Import(asdl_seq * names, int lineno, int col_offset, int end_lineno, int
end_col_offset, PyArena *arena)
{
stmt_ty p;
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Import_kind;
p->v.Import.names = names;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
stmt_ty
ImportFrom(identifier module, asdl_seq * names, int level, int lineno, int
col_offset, int end_lineno, int end_col_offset, PyArena *arena)
{
stmt_ty p;
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = ImportFrom_kind;
p->v.ImportFrom.module = module;
p->v.ImportFrom.names = names;
p->v.ImportFrom.level = level;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
stmt_ty
Global(asdl_seq * names, int lineno, int col_offset, int end_lineno, int
end_col_offset, PyArena *arena)
{
stmt_ty p;
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Global_kind;
p->v.Global.names = names;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
stmt_ty
Nonlocal(asdl_seq * names, int lineno, int col_offset, int end_lineno, int
end_col_offset, PyArena *arena)
{
stmt_ty p;
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Nonlocal_kind;
p->v.Nonlocal.names = names;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
stmt_ty
Expr(expr_ty value, int lineno, int col_offset, int end_lineno, int
end_col_offset, PyArena *arena)
{
stmt_ty p;
if (!value) {
PyErr_SetString(PyExc_ValueError,
"field value is required for Expr");
return NULL;
}
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Expr_kind;
p->v.Expr.value = value;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
stmt_ty
Pass(int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena
*arena)
{
stmt_ty p;
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Pass_kind;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
stmt_ty
Break(int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena
*arena)
{
stmt_ty p;
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Break_kind;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
stmt_ty
Continue(int lineno, int col_offset, int end_lineno, int end_col_offset,
PyArena *arena)
{
stmt_ty p;
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Continue_kind;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
expr_ty
BoolOp(boolop_ty op, asdl_seq * values, int lineno, int col_offset, int
end_lineno, int end_col_offset, PyArena *arena)
{
expr_ty p;
if (!op) {
PyErr_SetString(PyExc_ValueError,
"field op is required for BoolOp");
return NULL;
}
p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = BoolOp_kind;
p->v.BoolOp.op = op;
p->v.BoolOp.values = values;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
expr_ty
NamedExpr(expr_ty target, expr_ty value, int lineno, int col_offset, int
end_lineno, int end_col_offset, PyArena *arena)
{
expr_ty p;
if (!target) {
PyErr_SetString(PyExc_ValueError,
"field target is required for NamedExpr");
return NULL;
}
if (!value) {
PyErr_SetString(PyExc_ValueError,
"field value is required for NamedExpr");
return NULL;
}
p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = NamedExpr_kind;
p->v.NamedExpr.target = target;
p->v.NamedExpr.value = value;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
expr_ty
BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno, int col_offset,
int end_lineno, int end_col_offset, PyArena *arena)
{
expr_ty p;
if (!left) {
PyErr_SetString(PyExc_ValueError,
"field left is required for BinOp");
return NULL;
}
if (!op) {
PyErr_SetString(PyExc_ValueError,
"field op is required for BinOp");
return NULL;
}
if (!right) {
PyErr_SetString(PyExc_ValueError,
"field right is required for BinOp");
return NULL;
}
p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = BinOp_kind;
p->v.BinOp.left = left;
p->v.BinOp.op = op;
p->v.BinOp.right = right;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
expr_ty
UnaryOp(unaryop_ty op, expr_ty operand, int lineno, int col_offset, int
end_lineno, int end_col_offset, PyArena *arena)
{
expr_ty p;
if (!op) {
PyErr_SetString(PyExc_ValueError,
"field op is required for UnaryOp");
return NULL;
}
if (!operand) {
PyErr_SetString(PyExc_ValueError,
"field operand is required for UnaryOp");
return NULL;
}
p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = UnaryOp_kind;
p->v.UnaryOp.op = op;
p->v.UnaryOp.operand = operand;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
expr_ty
Lambda(arguments_ty args, expr_ty body, int lineno, int col_offset, int
end_lineno, int end_col_offset, PyArena *arena)
{
expr_ty p;
if (!args) {
PyErr_SetString(PyExc_ValueError,
"field args is required for Lambda");
return NULL;
}
if (!body) {
PyErr_SetString(PyExc_ValueError,
"field body is required for Lambda");
return NULL;
}
p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Lambda_kind;
p->v.Lambda.args = args;
p->v.Lambda.body = body;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
expr_ty
IfExp(expr_ty test, expr_ty body, expr_ty orelse, int lineno, int col_offset,
int end_lineno, int end_col_offset, PyArena *arena)
{
expr_ty p;
if (!test) {
PyErr_SetString(PyExc_ValueError,
"field test is required for IfExp");
return NULL;
}
if (!body) {
PyErr_SetString(PyExc_ValueError,
"field body is required for IfExp");
return NULL;
}
if (!orelse) {
PyErr_SetString(PyExc_ValueError,
"field orelse is required for IfExp");
return NULL;
}
p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = IfExp_kind;
p->v.IfExp.test = test;
p->v.IfExp.body = body;
p->v.IfExp.orelse = orelse;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
expr_ty
Dict(asdl_seq * keys, asdl_seq * values, int lineno, int col_offset, int
end_lineno, int end_col_offset, PyArena *arena)
{
expr_ty p;
p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Dict_kind;
p->v.Dict.keys = keys;
p->v.Dict.values = values;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
expr_ty
Set(asdl_seq * elts, int lineno, int col_offset, int end_lineno, int
end_col_offset, PyArena *arena)
{
expr_ty p;
p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Set_kind;
p->v.Set.elts = elts;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
expr_ty
ListComp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset, int
end_lineno, int end_col_offset, PyArena *arena)
{
expr_ty p;
if (!elt) {
PyErr_SetString(PyExc_ValueError,
"field elt is required for ListComp");
return NULL;
}
p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = ListComp_kind;
p->v.ListComp.elt = elt;
p->v.ListComp.generators = generators;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
expr_ty
SetComp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset, int
end_lineno, int end_col_offset, PyArena *arena)
{
expr_ty p;
if (!elt) {
PyErr_SetString(PyExc_ValueError,
"field elt is required for SetComp");
return NULL;
}
p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = SetComp_kind;
p->v.SetComp.elt = elt;
p->v.SetComp.generators = generators;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
expr_ty
DictComp(expr_ty key, expr_ty value, asdl_seq * generators, int lineno, int
col_offset, int end_lineno, int end_col_offset, PyArena *arena)
{
expr_ty p;
if (!key) {
PyErr_SetString(PyExc_ValueError,
"field key is required for DictComp");
return NULL;
}
if (!value) {
PyErr_SetString(PyExc_ValueError,
"field value is required for DictComp");
return NULL;
}
p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = DictComp_kind;
p->v.DictComp.key = key;
p->v.DictComp.value = value;
p->v.DictComp.generators = generators;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
expr_ty
GeneratorExp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset,
int end_lineno, int end_col_offset, PyArena *arena)
{
expr_ty p;
if (!elt) {
PyErr_SetString(PyExc_ValueError,
"field elt is required for GeneratorExp");
return NULL;
}
p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = GeneratorExp_kind;
p->v.GeneratorExp.elt = elt;
p->v.GeneratorExp.generators = generators;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
expr_ty
Await(expr_ty value, int lineno, int col_offset, int end_lineno, int
end_col_offset, PyArena *arena)
{
expr_ty p;
if (!value) {
PyErr_SetString(PyExc_ValueError,
"field value is required for Await");
return NULL;
}
p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Await_kind;
p->v.Await.value = value;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
expr_ty
Yield(expr_ty value, int lineno, int col_offset, int end_lineno, int
end_col_offset, PyArena *arena)
{
expr_ty p;
p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Yield_kind;
p->v.Yield.value = value;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
expr_ty
YieldFrom(expr_ty value, int lineno, int col_offset, int end_lineno, int
end_col_offset, PyArena *arena)
{
expr_ty p;
if (!value) {
PyErr_SetString(PyExc_ValueError,
"field value is required for YieldFrom");
return NULL;
}
p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = YieldFrom_kind;
p->v.YieldFrom.value = value;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
expr_ty
Compare(expr_ty left, asdl_int_seq * ops, asdl_seq * comparators, int lineno,
int col_offset, int end_lineno, int end_col_offset, PyArena *arena)
{
expr_ty p;
if (!left) {
PyErr_SetString(PyExc_ValueError,
"field left is required for Compare");
return NULL;
}
p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Compare_kind;
p->v.Compare.left = left;
p->v.Compare.ops = ops;
p->v.Compare.comparators = comparators;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
expr_ty
Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, int lineno, int
col_offset, int end_lineno, int end_col_offset, PyArena *arena)
{
expr_ty p;
if (!func) {
PyErr_SetString(PyExc_ValueError,
"field func is required for Call");
return NULL;
}
p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Call_kind;
p->v.Call.func = func;
p->v.Call.args = args;
p->v.Call.keywords = keywords;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
expr_ty
FormattedValue(expr_ty value, int conversion, expr_ty format_spec, int lineno,
int col_offset, int end_lineno, int end_col_offset, PyArena
*arena)
{
expr_ty p;
if (!value) {
PyErr_SetString(PyExc_ValueError,
"field value is required for FormattedValue");
return NULL;
}
p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = FormattedValue_kind;
p->v.FormattedValue.value = value;
p->v.FormattedValue.conversion = conversion;
p->v.FormattedValue.format_spec = format_spec;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
expr_ty
JoinedStr(asdl_seq * values, int lineno, int col_offset, int end_lineno, int
end_col_offset, PyArena *arena)
{
expr_ty p;
p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = JoinedStr_kind;
p->v.JoinedStr.values = values;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
expr_ty
Constant(constant value, string kind, int lineno, int col_offset, int
end_lineno, int end_col_offset, PyArena *arena)
{
expr_ty p;
if (!value) {
PyErr_SetString(PyExc_ValueError,
"field value is required for Constant");
return NULL;
}
p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Constant_kind;
p->v.Constant.value = value;
p->v.Constant.kind = kind;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
expr_ty
Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int lineno, int
col_offset, int end_lineno, int end_col_offset, PyArena *arena)
{
expr_ty p;
if (!value) {
PyErr_SetString(PyExc_ValueError,
"field value is required for Attribute");
return NULL;
}
if (!attr) {
PyErr_SetString(PyExc_ValueError,
"field attr is required for Attribute");
return NULL;
}
if (!ctx) {
PyErr_SetString(PyExc_ValueError,
"field ctx is required for Attribute");
return NULL;
}
p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Attribute_kind;
p->v.Attribute.value = value;
p->v.Attribute.attr = attr;
p->v.Attribute.ctx = ctx;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
expr_ty
Subscript(expr_ty value, slice_ty slice, expr_context_ty ctx, int lineno, int
col_offset, int end_lineno, int end_col_offset, PyArena *arena)
{
expr_ty p;
if (!value) {
PyErr_SetString(PyExc_ValueError,
"field value is required for Subscript");
return NULL;
}
if (!slice) {
PyErr_SetString(PyExc_ValueError,
"field slice is required for Subscript");
return NULL;
}
if (!ctx) {
PyErr_SetString(PyExc_ValueError,
"field ctx is required for Subscript");
return NULL;
}
p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Subscript_kind;
p->v.Subscript.value = value;
p->v.Subscript.slice = slice;
p->v.Subscript.ctx = ctx;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
expr_ty
Starred(expr_ty value, expr_context_ty ctx, int lineno, int col_offset, int
end_lineno, int end_col_offset, PyArena *arena)
{
expr_ty p;
if (!value) {
PyErr_SetString(PyExc_ValueError,
"field value is required for Starred");
return NULL;
}
if (!ctx) {
PyErr_SetString(PyExc_ValueError,
"field ctx is required for Starred");
return NULL;
}
p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Starred_kind;
p->v.Starred.value = value;
p->v.Starred.ctx = ctx;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
expr_ty
Name(identifier id, expr_context_ty ctx, int lineno, int col_offset, int
end_lineno, int end_col_offset, PyArena *arena)
{
expr_ty p;
if (!id) {
PyErr_SetString(PyExc_ValueError,
"field id is required for Name");
return NULL;
}
if (!ctx) {
PyErr_SetString(PyExc_ValueError,
"field ctx is required for Name");
return NULL;
}
p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Name_kind;
p->v.Name.id = id;
p->v.Name.ctx = ctx;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
expr_ty
List(asdl_seq * elts, expr_context_ty ctx, int lineno, int col_offset, int
end_lineno, int end_col_offset, PyArena *arena)
{
expr_ty p;
if (!ctx) {
PyErr_SetString(PyExc_ValueError,
"field ctx is required for List");
return NULL;
}
p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = List_kind;
p->v.List.elts = elts;
p->v.List.ctx = ctx;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
expr_ty
Tuple(asdl_seq * elts, expr_context_ty ctx, int lineno, int col_offset, int
end_lineno, int end_col_offset, PyArena *arena)
{
expr_ty p;
if (!ctx) {
PyErr_SetString(PyExc_ValueError,
"field ctx is required for Tuple");
return NULL;
}
p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Tuple_kind;
p->v.Tuple.elts = elts;
p->v.Tuple.ctx = ctx;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
slice_ty
Slice(expr_ty lower, expr_ty upper, expr_ty step, PyArena *arena)
{
slice_ty p;
p = (slice_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Slice_kind;
p->v.Slice.lower = lower;
p->v.Slice.upper = upper;
p->v.Slice.step = step;
return p;
}
slice_ty
ExtSlice(asdl_seq * dims, PyArena *arena)
{
slice_ty p;
p = (slice_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = ExtSlice_kind;
p->v.ExtSlice.dims = dims;
return p;
}
slice_ty
Index(expr_ty value, PyArena *arena)
{
slice_ty p;
if (!value) {
PyErr_SetString(PyExc_ValueError,
"field value is required for Index");
return NULL;
}
p = (slice_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Index_kind;
p->v.Index.value = value;
return p;
}
comprehension_ty
comprehension(expr_ty target, expr_ty iter, asdl_seq * ifs, int is_async,
PyArena *arena)
{
comprehension_ty p;
if (!target) {
PyErr_SetString(PyExc_ValueError,
"field target is required for comprehension");
return NULL;
}
if (!iter) {
PyErr_SetString(PyExc_ValueError,
"field iter is required for comprehension");
return NULL;
}
p = (comprehension_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->target = target;
p->iter = iter;
p->ifs = ifs;
p->is_async = is_async;
return p;
}
excepthandler_ty
ExceptHandler(expr_ty type, identifier name, asdl_seq * body, int lineno, int
col_offset, int end_lineno, int end_col_offset, PyArena *arena)
{
excepthandler_ty p;
p = (excepthandler_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = ExceptHandler_kind;
p->v.ExceptHandler.type = type;
p->v.ExceptHandler.name = name;
p->v.ExceptHandler.body = body;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
arguments_ty
arguments(asdl_seq * posonlyargs, asdl_seq * args, arg_ty vararg, asdl_seq *
kwonlyargs, asdl_seq * kw_defaults, arg_ty kwarg, asdl_seq *
defaults, PyArena *arena)
{
arguments_ty p;
p = (arguments_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->posonlyargs = posonlyargs;
p->args = args;
p->vararg = vararg;
p->kwonlyargs = kwonlyargs;
p->kw_defaults = kw_defaults;
p->kwarg = kwarg;
p->defaults = defaults;
return p;
}
arg_ty
arg(identifier arg, expr_ty annotation, string type_comment, int lineno, int
col_offset, int end_lineno, int end_col_offset, PyArena *arena)
{
arg_ty p;
if (!arg) {
PyErr_SetString(PyExc_ValueError,
"field arg is required for arg");
return NULL;
}
p = (arg_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->arg = arg;
p->annotation = annotation;
p->type_comment = type_comment;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
keyword_ty
keyword(identifier arg, expr_ty value, PyArena *arena)
{
keyword_ty p;
if (!value) {
PyErr_SetString(PyExc_ValueError,
"field value is required for keyword");
return NULL;
}
p = (keyword_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->arg = arg;
p->value = value;
return p;
}
alias_ty
alias(identifier name, identifier asname, PyArena *arena)
{
alias_ty p;
if (!name) {
PyErr_SetString(PyExc_ValueError,
"field name is required for alias");
return NULL;
}
p = (alias_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->name = name;
p->asname = asname;
return p;
}
withitem_ty
withitem(expr_ty context_expr, expr_ty optional_vars, PyArena *arena)
{
withitem_ty p;
if (!context_expr) {
PyErr_SetString(PyExc_ValueError,
"field context_expr is required for withitem");
return NULL;
}
p = (withitem_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->context_expr = context_expr;
p->optional_vars = optional_vars;
return p;
}
type_ignore_ty
TypeIgnore(int lineno, string tag, PyArena *arena)
{
type_ignore_ty p;
if (!tag) {
PyErr_SetString(PyExc_ValueError,
"field tag is required for TypeIgnore");
return NULL;
}
p = (type_ignore_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = TypeIgnore_kind;
p->v.TypeIgnore.lineno = lineno;
p->v.TypeIgnore.tag = tag;
return p;
}
PyObject*
ast2obj_mod(void* _o)
{
mod_ty o = (mod_ty)_o;
PyObject *result = NULL, *value = NULL;
PyTypeObject *tp;
if (!o) {
Py_RETURN_NONE;
}
switch (o->kind) {
case Module_kind:
tp = (PyTypeObject *)astmodulestate_global->Module_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_list(o->v.Module.body, ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->body, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.Module.type_ignores, ast2obj_type_ignore);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->type_ignores,
value) == -1)
goto failed;
Py_DECREF(value);
break;
case Interactive_kind:
tp = (PyTypeObject *)astmodulestate_global->Interactive_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_list(o->v.Interactive.body, ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->body, value) == -1)
goto failed;
Py_DECREF(value);
break;
case Expression_kind:
tp = (PyTypeObject *)astmodulestate_global->Expression_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.Expression.body);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->body, value) == -1)
goto failed;
Py_DECREF(value);
break;
case FunctionType_kind:
tp = (PyTypeObject *)astmodulestate_global->FunctionType_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_list(o->v.FunctionType.argtypes, ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->argtypes, value) ==
-1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr(o->v.FunctionType.returns);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->returns, value) ==
-1)
goto failed;
Py_DECREF(value);
break;
case Suite_kind:
tp = (PyTypeObject *)astmodulestate_global->Suite_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_list(o->v.Suite.body, ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->body, value) == -1)
goto failed;
Py_DECREF(value);
break;
}
return result;
failed:
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
}
PyObject*
ast2obj_stmt(void* _o)
{
stmt_ty o = (stmt_ty)_o;
PyObject *result = NULL, *value = NULL;
PyTypeObject *tp;
if (!o) {
Py_RETURN_NONE;
}
switch (o->kind) {
case FunctionDef_kind:
tp = (PyTypeObject *)astmodulestate_global->FunctionDef_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_identifier(o->v.FunctionDef.name);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->name, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_arguments(o->v.FunctionDef.args);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->args, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.FunctionDef.body, ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->body, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.FunctionDef.decorator_list, ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->decorator_list,
value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr(o->v.FunctionDef.returns);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->returns, value) ==
-1)
goto failed;
Py_DECREF(value);
value = ast2obj_string(o->v.FunctionDef.type_comment);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->type_comment,
value) == -1)
goto failed;
Py_DECREF(value);
break;
case AsyncFunctionDef_kind:
tp = (PyTypeObject *)astmodulestate_global->AsyncFunctionDef_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_identifier(o->v.AsyncFunctionDef.name);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->name, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_arguments(o->v.AsyncFunctionDef.args);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->args, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.AsyncFunctionDef.body, ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->body, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.AsyncFunctionDef.decorator_list,
ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->decorator_list,
value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr(o->v.AsyncFunctionDef.returns);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->returns, value) ==
-1)
goto failed;
Py_DECREF(value);
value = ast2obj_string(o->v.AsyncFunctionDef.type_comment);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->type_comment,
value) == -1)
goto failed;
Py_DECREF(value);
break;
case ClassDef_kind:
tp = (PyTypeObject *)astmodulestate_global->ClassDef_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_identifier(o->v.ClassDef.name);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->name, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.ClassDef.bases, ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->bases, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.ClassDef.keywords, ast2obj_keyword);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->keywords, value) ==
-1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.ClassDef.body, ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->body, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.ClassDef.decorator_list, ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->decorator_list,
value) == -1)
goto failed;
Py_DECREF(value);
break;
case Return_kind:
tp = (PyTypeObject *)astmodulestate_global->Return_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.Return.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->value, value) == -1)
goto failed;
Py_DECREF(value);
break;
case Delete_kind:
tp = (PyTypeObject *)astmodulestate_global->Delete_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_list(o->v.Delete.targets, ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->targets, value) ==
-1)
goto failed;
Py_DECREF(value);
break;
case Assign_kind:
tp = (PyTypeObject *)astmodulestate_global->Assign_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_list(o->v.Assign.targets, ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->targets, value) ==
-1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr(o->v.Assign.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->value, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_string(o->v.Assign.type_comment);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->type_comment,
value) == -1)
goto failed;
Py_DECREF(value);
break;
case AugAssign_kind:
tp = (PyTypeObject *)astmodulestate_global->AugAssign_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.AugAssign.target);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->target, value) ==
-1)
goto failed;
Py_DECREF(value);
value = ast2obj_operator(o->v.AugAssign.op);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->op, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr(o->v.AugAssign.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->value, value) == -1)
goto failed;
Py_DECREF(value);
break;
case AnnAssign_kind:
tp = (PyTypeObject *)astmodulestate_global->AnnAssign_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.AnnAssign.target);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->target, value) ==
-1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr(o->v.AnnAssign.annotation);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->annotation, value)
== -1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr(o->v.AnnAssign.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->value, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_int(o->v.AnnAssign.simple);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->simple, value) ==
-1)
goto failed;
Py_DECREF(value);
break;
case For_kind:
tp = (PyTypeObject *)astmodulestate_global->For_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.For.target);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->target, value) ==
-1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr(o->v.For.iter);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->iter, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.For.body, ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->body, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.For.orelse, ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->orelse, value) ==
-1)
goto failed;
Py_DECREF(value);
value = ast2obj_string(o->v.For.type_comment);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->type_comment,
value) == -1)
goto failed;
Py_DECREF(value);
break;
case AsyncFor_kind:
tp = (PyTypeObject *)astmodulestate_global->AsyncFor_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.AsyncFor.target);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->target, value) ==
-1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr(o->v.AsyncFor.iter);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->iter, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.AsyncFor.body, ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->body, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.AsyncFor.orelse, ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->orelse, value) ==
-1)
goto failed;
Py_DECREF(value);
value = ast2obj_string(o->v.AsyncFor.type_comment);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->type_comment,
value) == -1)
goto failed;
Py_DECREF(value);
break;
case While_kind:
tp = (PyTypeObject *)astmodulestate_global->While_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.While.test);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->test, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.While.body, ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->body, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.While.orelse, ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->orelse, value) ==
-1)
goto failed;
Py_DECREF(value);
break;
case If_kind:
tp = (PyTypeObject *)astmodulestate_global->If_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.If.test);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->test, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.If.body, ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->body, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.If.orelse, ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->orelse, value) ==
-1)
goto failed;
Py_DECREF(value);
break;
case With_kind:
tp = (PyTypeObject *)astmodulestate_global->With_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_list(o->v.With.items, ast2obj_withitem);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->items, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.With.body, ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->body, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_string(o->v.With.type_comment);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->type_comment,
value) == -1)
goto failed;
Py_DECREF(value);
break;
case AsyncWith_kind:
tp = (PyTypeObject *)astmodulestate_global->AsyncWith_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_list(o->v.AsyncWith.items, ast2obj_withitem);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->items, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.AsyncWith.body, ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->body, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_string(o->v.AsyncWith.type_comment);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->type_comment,
value) == -1)
goto failed;
Py_DECREF(value);
break;
case Raise_kind:
tp = (PyTypeObject *)astmodulestate_global->Raise_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.Raise.exc);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->exc, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr(o->v.Raise.cause);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->cause, value) == -1)
goto failed;
Py_DECREF(value);
break;
case Try_kind:
tp = (PyTypeObject *)astmodulestate_global->Try_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_list(o->v.Try.body, ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->body, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.Try.handlers, ast2obj_excepthandler);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->handlers, value) ==
-1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.Try.orelse, ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->orelse, value) ==
-1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.Try.finalbody, ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->finalbody, value)
== -1)
goto failed;
Py_DECREF(value);
break;
case Assert_kind:
tp = (PyTypeObject *)astmodulestate_global->Assert_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.Assert.test);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->test, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr(o->v.Assert.msg);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->msg, value) == -1)
goto failed;
Py_DECREF(value);
break;
case Import_kind:
tp = (PyTypeObject *)astmodulestate_global->Import_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_list(o->v.Import.names, ast2obj_alias);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->names, value) == -1)
goto failed;
Py_DECREF(value);
break;
case ImportFrom_kind:
tp = (PyTypeObject *)astmodulestate_global->ImportFrom_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_identifier(o->v.ImportFrom.module);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->module, value) ==
-1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.ImportFrom.names, ast2obj_alias);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->names, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_int(o->v.ImportFrom.level);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->level, value) == -1)
goto failed;
Py_DECREF(value);
break;
case Global_kind:
tp = (PyTypeObject *)astmodulestate_global->Global_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_list(o->v.Global.names, ast2obj_identifier);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->names, value) == -1)
goto failed;
Py_DECREF(value);
break;
case Nonlocal_kind:
tp = (PyTypeObject *)astmodulestate_global->Nonlocal_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_list(o->v.Nonlocal.names, ast2obj_identifier);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->names, value) == -1)
goto failed;
Py_DECREF(value);
break;
case Expr_kind:
tp = (PyTypeObject *)astmodulestate_global->Expr_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.Expr.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->value, value) == -1)
goto failed;
Py_DECREF(value);
break;
case Pass_kind:
tp = (PyTypeObject *)astmodulestate_global->Pass_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
break;
case Break_kind:
tp = (PyTypeObject *)astmodulestate_global->Break_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
break;
case Continue_kind:
tp = (PyTypeObject *)astmodulestate_global->Continue_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
break;
}
value = ast2obj_int(o->lineno);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->lineno, value) < 0)
goto failed;
Py_DECREF(value);
value = ast2obj_int(o->col_offset);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->col_offset, value) < 0)
goto failed;
Py_DECREF(value);
value = ast2obj_int(o->end_lineno);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->end_lineno, value) < 0)
goto failed;
Py_DECREF(value);
value = ast2obj_int(o->end_col_offset);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->end_col_offset, value)
< 0)
goto failed;
Py_DECREF(value);
return result;
failed:
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
}
PyObject*
ast2obj_expr(void* _o)
{
expr_ty o = (expr_ty)_o;
PyObject *result = NULL, *value = NULL;
PyTypeObject *tp;
if (!o) {
Py_RETURN_NONE;
}
switch (o->kind) {
case BoolOp_kind:
tp = (PyTypeObject *)astmodulestate_global->BoolOp_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_boolop(o->v.BoolOp.op);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->op, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.BoolOp.values, ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->values, value) ==
-1)
goto failed;
Py_DECREF(value);
break;
case NamedExpr_kind:
tp = (PyTypeObject *)astmodulestate_global->NamedExpr_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.NamedExpr.target);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->target, value) ==
-1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr(o->v.NamedExpr.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->value, value) == -1)
goto failed;
Py_DECREF(value);
break;
case BinOp_kind:
tp = (PyTypeObject *)astmodulestate_global->BinOp_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.BinOp.left);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->left, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_operator(o->v.BinOp.op);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->op, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr(o->v.BinOp.right);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->right, value) == -1)
goto failed;
Py_DECREF(value);
break;
case UnaryOp_kind:
tp = (PyTypeObject *)astmodulestate_global->UnaryOp_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_unaryop(o->v.UnaryOp.op);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->op, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr(o->v.UnaryOp.operand);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->operand, value) ==
-1)
goto failed;
Py_DECREF(value);
break;
case Lambda_kind:
tp = (PyTypeObject *)astmodulestate_global->Lambda_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_arguments(o->v.Lambda.args);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->args, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr(o->v.Lambda.body);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->body, value) == -1)
goto failed;
Py_DECREF(value);
break;
case IfExp_kind:
tp = (PyTypeObject *)astmodulestate_global->IfExp_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.IfExp.test);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->test, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr(o->v.IfExp.body);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->body, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr(o->v.IfExp.orelse);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->orelse, value) ==
-1)
goto failed;
Py_DECREF(value);
break;
case Dict_kind:
tp = (PyTypeObject *)astmodulestate_global->Dict_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_list(o->v.Dict.keys, ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->keys, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.Dict.values, ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->values, value) ==
-1)
goto failed;
Py_DECREF(value);
break;
case Set_kind:
tp = (PyTypeObject *)astmodulestate_global->Set_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_list(o->v.Set.elts, ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->elts, value) == -1)
goto failed;
Py_DECREF(value);
break;
case ListComp_kind:
tp = (PyTypeObject *)astmodulestate_global->ListComp_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.ListComp.elt);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->elt, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.ListComp.generators, ast2obj_comprehension);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->generators, value)
== -1)
goto failed;
Py_DECREF(value);
break;
case SetComp_kind:
tp = (PyTypeObject *)astmodulestate_global->SetComp_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.SetComp.elt);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->elt, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.SetComp.generators, ast2obj_comprehension);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->generators, value)
== -1)
goto failed;
Py_DECREF(value);
break;
case DictComp_kind:
tp = (PyTypeObject *)astmodulestate_global->DictComp_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.DictComp.key);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->key, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr(o->v.DictComp.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->value, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.DictComp.generators, ast2obj_comprehension);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->generators, value)
== -1)
goto failed;
Py_DECREF(value);
break;
case GeneratorExp_kind:
tp = (PyTypeObject *)astmodulestate_global->GeneratorExp_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.GeneratorExp.elt);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->elt, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.GeneratorExp.generators,
ast2obj_comprehension);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->generators, value)
== -1)
goto failed;
Py_DECREF(value);
break;
case Await_kind:
tp = (PyTypeObject *)astmodulestate_global->Await_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.Await.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->value, value) == -1)
goto failed;
Py_DECREF(value);
break;
case Yield_kind:
tp = (PyTypeObject *)astmodulestate_global->Yield_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.Yield.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->value, value) == -1)
goto failed;
Py_DECREF(value);
break;
case YieldFrom_kind:
tp = (PyTypeObject *)astmodulestate_global->YieldFrom_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.YieldFrom.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->value, value) == -1)
goto failed;
Py_DECREF(value);
break;
case Compare_kind:
tp = (PyTypeObject *)astmodulestate_global->Compare_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.Compare.left);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->left, value) == -1)
goto failed;
Py_DECREF(value);
{
Py_ssize_t i, n = asdl_seq_LEN(o->v.Compare.ops);
value = PyList_New(n);
if (!value) goto failed;
for(i = 0; i < n; i++)
PyList_SET_ITEM(value, i, ast2obj_cmpop((cmpop_ty)asdl_seq_GET(o->v.Compare.ops, i)));
}
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->ops, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.Compare.comparators, ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->comparators, value)
== -1)
goto failed;
Py_DECREF(value);
break;
case Call_kind:
tp = (PyTypeObject *)astmodulestate_global->Call_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.Call.func);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->func, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.Call.args, ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->args, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.Call.keywords, ast2obj_keyword);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->keywords, value) ==
-1)
goto failed;
Py_DECREF(value);
break;
case FormattedValue_kind:
tp = (PyTypeObject *)astmodulestate_global->FormattedValue_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.FormattedValue.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->value, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_int(o->v.FormattedValue.conversion);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->conversion, value)
== -1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr(o->v.FormattedValue.format_spec);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->format_spec, value)
== -1)
goto failed;
Py_DECREF(value);
break;
case JoinedStr_kind:
tp = (PyTypeObject *)astmodulestate_global->JoinedStr_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_list(o->v.JoinedStr.values, ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->values, value) ==
-1)
goto failed;
Py_DECREF(value);
break;
case Constant_kind:
tp = (PyTypeObject *)astmodulestate_global->Constant_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_constant(o->v.Constant.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->value, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_string(o->v.Constant.kind);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->kind, value) == -1)
goto failed;
Py_DECREF(value);
break;
case Attribute_kind:
tp = (PyTypeObject *)astmodulestate_global->Attribute_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.Attribute.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->value, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_identifier(o->v.Attribute.attr);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->attr, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr_context(o->v.Attribute.ctx);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->ctx, value) == -1)
goto failed;
Py_DECREF(value);
break;
case Subscript_kind:
tp = (PyTypeObject *)astmodulestate_global->Subscript_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.Subscript.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->value, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_slice(o->v.Subscript.slice);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->slice, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr_context(o->v.Subscript.ctx);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->ctx, value) == -1)
goto failed;
Py_DECREF(value);
break;
case Starred_kind:
tp = (PyTypeObject *)astmodulestate_global->Starred_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.Starred.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->value, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr_context(o->v.Starred.ctx);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->ctx, value) == -1)
goto failed;
Py_DECREF(value);
break;
case Name_kind:
tp = (PyTypeObject *)astmodulestate_global->Name_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_identifier(o->v.Name.id);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->id, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr_context(o->v.Name.ctx);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->ctx, value) == -1)
goto failed;
Py_DECREF(value);
break;
case List_kind:
tp = (PyTypeObject *)astmodulestate_global->List_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_list(o->v.List.elts, ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->elts, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr_context(o->v.List.ctx);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->ctx, value) == -1)
goto failed;
Py_DECREF(value);
break;
case Tuple_kind:
tp = (PyTypeObject *)astmodulestate_global->Tuple_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_list(o->v.Tuple.elts, ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->elts, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr_context(o->v.Tuple.ctx);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->ctx, value) == -1)
goto failed;
Py_DECREF(value);
break;
}
value = ast2obj_int(o->lineno);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->lineno, value) < 0)
goto failed;
Py_DECREF(value);
value = ast2obj_int(o->col_offset);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->col_offset, value) < 0)
goto failed;
Py_DECREF(value);
value = ast2obj_int(o->end_lineno);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->end_lineno, value) < 0)
goto failed;
Py_DECREF(value);
value = ast2obj_int(o->end_col_offset);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->end_col_offset, value)
< 0)
goto failed;
Py_DECREF(value);
return result;
failed:
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
}
PyObject* ast2obj_expr_context(expr_context_ty o)
{
switch(o) {
case Load:
Py_INCREF(astmodulestate_global->Load_singleton);
return astmodulestate_global->Load_singleton;
case Store:
Py_INCREF(astmodulestate_global->Store_singleton);
return astmodulestate_global->Store_singleton;
case Del:
Py_INCREF(astmodulestate_global->Del_singleton);
return astmodulestate_global->Del_singleton;
case AugLoad:
Py_INCREF(astmodulestate_global->AugLoad_singleton);
return astmodulestate_global->AugLoad_singleton;
case AugStore:
Py_INCREF(astmodulestate_global->AugStore_singleton);
return astmodulestate_global->AugStore_singleton;
case Param:
Py_INCREF(astmodulestate_global->Param_singleton);
return astmodulestate_global->Param_singleton;
default:
/* should never happen, but just in case ... */
PyErr_Format(PyExc_SystemError, "unknown expr_context found");
return NULL;
}
}
PyObject*
ast2obj_slice(void* _o)
{
slice_ty o = (slice_ty)_o;
PyObject *result = NULL, *value = NULL;
PyTypeObject *tp;
if (!o) {
Py_RETURN_NONE;
}
switch (o->kind) {
case Slice_kind:
tp = (PyTypeObject *)astmodulestate_global->Slice_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.Slice.lower);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->lower, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr(o->v.Slice.upper);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->upper, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr(o->v.Slice.step);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->step, value) == -1)
goto failed;
Py_DECREF(value);
break;
case ExtSlice_kind:
tp = (PyTypeObject *)astmodulestate_global->ExtSlice_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_list(o->v.ExtSlice.dims, ast2obj_slice);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->dims, value) == -1)
goto failed;
Py_DECREF(value);
break;
case Index_kind:
tp = (PyTypeObject *)astmodulestate_global->Index_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.Index.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->value, value) == -1)
goto failed;
Py_DECREF(value);
break;
}
return result;
failed:
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
}
PyObject* ast2obj_boolop(boolop_ty o)
{
switch(o) {
case And:
Py_INCREF(astmodulestate_global->And_singleton);
return astmodulestate_global->And_singleton;
case Or:
Py_INCREF(astmodulestate_global->Or_singleton);
return astmodulestate_global->Or_singleton;
default:
/* should never happen, but just in case ... */
PyErr_Format(PyExc_SystemError, "unknown boolop found");
return NULL;
}
}
PyObject* ast2obj_operator(operator_ty o)
{
switch(o) {
case Add:
Py_INCREF(astmodulestate_global->Add_singleton);
return astmodulestate_global->Add_singleton;
case Sub:
Py_INCREF(astmodulestate_global->Sub_singleton);
return astmodulestate_global->Sub_singleton;
case Mult:
Py_INCREF(astmodulestate_global->Mult_singleton);
return astmodulestate_global->Mult_singleton;
case MatMult:
Py_INCREF(astmodulestate_global->MatMult_singleton);
return astmodulestate_global->MatMult_singleton;
case Div:
Py_INCREF(astmodulestate_global->Div_singleton);
return astmodulestate_global->Div_singleton;
case Mod:
Py_INCREF(astmodulestate_global->Mod_singleton);
return astmodulestate_global->Mod_singleton;
case Pow:
Py_INCREF(astmodulestate_global->Pow_singleton);
return astmodulestate_global->Pow_singleton;
case LShift:
Py_INCREF(astmodulestate_global->LShift_singleton);
return astmodulestate_global->LShift_singleton;
case RShift:
Py_INCREF(astmodulestate_global->RShift_singleton);
return astmodulestate_global->RShift_singleton;
case BitOr:
Py_INCREF(astmodulestate_global->BitOr_singleton);
return astmodulestate_global->BitOr_singleton;
case BitXor:
Py_INCREF(astmodulestate_global->BitXor_singleton);
return astmodulestate_global->BitXor_singleton;
case BitAnd:
Py_INCREF(astmodulestate_global->BitAnd_singleton);
return astmodulestate_global->BitAnd_singleton;
case FloorDiv:
Py_INCREF(astmodulestate_global->FloorDiv_singleton);
return astmodulestate_global->FloorDiv_singleton;
default:
/* should never happen, but just in case ... */
PyErr_Format(PyExc_SystemError, "unknown operator found");
return NULL;
}
}
PyObject* ast2obj_unaryop(unaryop_ty o)
{
switch(o) {
case Invert:
Py_INCREF(astmodulestate_global->Invert_singleton);
return astmodulestate_global->Invert_singleton;
case Not:
Py_INCREF(astmodulestate_global->Not_singleton);
return astmodulestate_global->Not_singleton;
case UAdd:
Py_INCREF(astmodulestate_global->UAdd_singleton);
return astmodulestate_global->UAdd_singleton;
case USub:
Py_INCREF(astmodulestate_global->USub_singleton);
return astmodulestate_global->USub_singleton;
default:
/* should never happen, but just in case ... */
PyErr_Format(PyExc_SystemError, "unknown unaryop found");
return NULL;
}
}
PyObject* ast2obj_cmpop(cmpop_ty o)
{
switch(o) {
case Eq:
Py_INCREF(astmodulestate_global->Eq_singleton);
return astmodulestate_global->Eq_singleton;
case NotEq:
Py_INCREF(astmodulestate_global->NotEq_singleton);
return astmodulestate_global->NotEq_singleton;
case Lt:
Py_INCREF(astmodulestate_global->Lt_singleton);
return astmodulestate_global->Lt_singleton;
case LtE:
Py_INCREF(astmodulestate_global->LtE_singleton);
return astmodulestate_global->LtE_singleton;
case Gt:
Py_INCREF(astmodulestate_global->Gt_singleton);
return astmodulestate_global->Gt_singleton;
case GtE:
Py_INCREF(astmodulestate_global->GtE_singleton);
return astmodulestate_global->GtE_singleton;
case Is:
Py_INCREF(astmodulestate_global->Is_singleton);
return astmodulestate_global->Is_singleton;
case IsNot:
Py_INCREF(astmodulestate_global->IsNot_singleton);
return astmodulestate_global->IsNot_singleton;
case In:
Py_INCREF(astmodulestate_global->In_singleton);
return astmodulestate_global->In_singleton;
case NotIn:
Py_INCREF(astmodulestate_global->NotIn_singleton);
return astmodulestate_global->NotIn_singleton;
default:
/* should never happen, but just in case ... */
PyErr_Format(PyExc_SystemError, "unknown cmpop found");
return NULL;
}
}
PyObject*
ast2obj_comprehension(void* _o)
{
comprehension_ty o = (comprehension_ty)_o;
PyObject *result = NULL, *value = NULL;
PyTypeObject *tp;
if (!o) {
Py_RETURN_NONE;
}
tp = (PyTypeObject *)astmodulestate_global->comprehension_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) return NULL;
value = ast2obj_expr(o->target);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->target, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr(o->iter);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->iter, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->ifs, ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->ifs, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_int(o->is_async);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->is_async, value) == -1)
goto failed;
Py_DECREF(value);
return result;
failed:
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
}
PyObject*
ast2obj_excepthandler(void* _o)
{
excepthandler_ty o = (excepthandler_ty)_o;
PyObject *result = NULL, *value = NULL;
PyTypeObject *tp;
if (!o) {
Py_RETURN_NONE;
}
switch (o->kind) {
case ExceptHandler_kind:
tp = (PyTypeObject *)astmodulestate_global->ExceptHandler_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.ExceptHandler.type);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->type, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_identifier(o->v.ExceptHandler.name);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->name, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.ExceptHandler.body, ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->body, value) == -1)
goto failed;
Py_DECREF(value);
break;
}
value = ast2obj_int(o->lineno);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->lineno, value) < 0)
goto failed;
Py_DECREF(value);
value = ast2obj_int(o->col_offset);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->col_offset, value) < 0)
goto failed;
Py_DECREF(value);
value = ast2obj_int(o->end_lineno);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->end_lineno, value) < 0)
goto failed;
Py_DECREF(value);
value = ast2obj_int(o->end_col_offset);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->end_col_offset, value)
< 0)
goto failed;
Py_DECREF(value);
return result;
failed:
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
}
PyObject*
ast2obj_arguments(void* _o)
{
arguments_ty o = (arguments_ty)_o;
PyObject *result = NULL, *value = NULL;
PyTypeObject *tp;
if (!o) {
Py_RETURN_NONE;
}
tp = (PyTypeObject *)astmodulestate_global->arguments_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) return NULL;
value = ast2obj_list(o->posonlyargs, ast2obj_arg);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->posonlyargs, value) ==
-1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->args, ast2obj_arg);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->args, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_arg(o->vararg);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->vararg, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->kwonlyargs, ast2obj_arg);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->kwonlyargs, value) ==
-1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->kw_defaults, ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->kw_defaults, value) ==
-1)
goto failed;
Py_DECREF(value);
value = ast2obj_arg(o->kwarg);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->kwarg, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->defaults, ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->defaults, value) == -1)
goto failed;
Py_DECREF(value);
return result;
failed:
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
}
PyObject*
ast2obj_arg(void* _o)
{
arg_ty o = (arg_ty)_o;
PyObject *result = NULL, *value = NULL;
PyTypeObject *tp;
if (!o) {
Py_RETURN_NONE;
}
tp = (PyTypeObject *)astmodulestate_global->arg_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) return NULL;
value = ast2obj_identifier(o->arg);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->arg, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr(o->annotation);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->annotation, value) ==
-1)
goto failed;
Py_DECREF(value);
value = ast2obj_string(o->type_comment);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->type_comment, value) ==
-1)
goto failed;
Py_DECREF(value);
value = ast2obj_int(o->lineno);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->lineno, value) < 0)
goto failed;
Py_DECREF(value);
value = ast2obj_int(o->col_offset);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->col_offset, value) < 0)
goto failed;
Py_DECREF(value);
value = ast2obj_int(o->end_lineno);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->end_lineno, value) < 0)
goto failed;
Py_DECREF(value);
value = ast2obj_int(o->end_col_offset);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->end_col_offset, value)
< 0)
goto failed;
Py_DECREF(value);
return result;
failed:
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
}
PyObject*
ast2obj_keyword(void* _o)
{
keyword_ty o = (keyword_ty)_o;
PyObject *result = NULL, *value = NULL;
PyTypeObject *tp;
if (!o) {
Py_RETURN_NONE;
}
tp = (PyTypeObject *)astmodulestate_global->keyword_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) return NULL;
value = ast2obj_identifier(o->arg);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->arg, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr(o->value);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->value, value) == -1)
goto failed;
Py_DECREF(value);
return result;
failed:
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
}
PyObject*
ast2obj_alias(void* _o)
{
alias_ty o = (alias_ty)_o;
PyObject *result = NULL, *value = NULL;
PyTypeObject *tp;
if (!o) {
Py_RETURN_NONE;
}
tp = (PyTypeObject *)astmodulestate_global->alias_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) return NULL;
value = ast2obj_identifier(o->name);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->name, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_identifier(o->asname);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->asname, value) == -1)
goto failed;
Py_DECREF(value);
return result;
failed:
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
}
PyObject*
ast2obj_withitem(void* _o)
{
withitem_ty o = (withitem_ty)_o;
PyObject *result = NULL, *value = NULL;
PyTypeObject *tp;
if (!o) {
Py_RETURN_NONE;
}
tp = (PyTypeObject *)astmodulestate_global->withitem_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) return NULL;
value = ast2obj_expr(o->context_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->context_expr, value) ==
-1)
goto failed;
Py_DECREF(value);
value = ast2obj_expr(o->optional_vars);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->optional_vars, value)
== -1)
goto failed;
Py_DECREF(value);
return result;
failed:
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
}
PyObject*
ast2obj_type_ignore(void* _o)
{
type_ignore_ty o = (type_ignore_ty)_o;
PyObject *result = NULL, *value = NULL;
PyTypeObject *tp;
if (!o) {
Py_RETURN_NONE;
}
switch (o->kind) {
case TypeIgnore_kind:
tp = (PyTypeObject *)astmodulestate_global->TypeIgnore_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
value = ast2obj_int(o->v.TypeIgnore.lineno);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->lineno, value) ==
-1)
goto failed;
Py_DECREF(value);
value = ast2obj_string(o->v.TypeIgnore.tag);
if (!value) goto failed;
if (PyObject_SetAttr(result, astmodulestate_global->tag, value) == -1)
goto failed;
Py_DECREF(value);
break;
}
return result;
failed:
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
}
int
obj2ast_mod(PyObject* obj, mod_ty* out, PyArena* arena)
{
int isinstance;
PyObject *tmp = NULL;
PyObject *tp;
if (obj == Py_None) {
*out = NULL;
return 0;
}
tp = astmodulestate_global->Module_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
asdl_seq* body;
asdl_seq* type_ignores;
if (_PyObject_LookupAttr(obj, astmodulestate_global->body, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Module");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "Module field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
body = _Py_asdl_seq_new(len, arena);
if (body == NULL) goto failed;
for (i = 0; i < len; i++) {
stmt_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_stmt(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Module field \"body\" changed size during iteration");
goto failed;
}
asdl_seq_SET(body, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->type_ignores,
&tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"type_ignores\" missing from Module");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "Module field \"type_ignores\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
type_ignores = _Py_asdl_seq_new(len, arena);
if (type_ignores == NULL) goto failed;
for (i = 0; i < len; i++) {
type_ignore_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_type_ignore(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Module field \"type_ignores\" changed size during iteration");
goto failed;
}
asdl_seq_SET(type_ignores, i, val);
}
Py_CLEAR(tmp);
}
*out = Module(body, type_ignores, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Interactive_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
asdl_seq* body;
if (_PyObject_LookupAttr(obj, astmodulestate_global->body, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Interactive");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "Interactive field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
body = _Py_asdl_seq_new(len, arena);
if (body == NULL) goto failed;
for (i = 0; i < len; i++) {
stmt_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_stmt(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Interactive field \"body\" changed size during iteration");
goto failed;
}
asdl_seq_SET(body, i, val);
}
Py_CLEAR(tmp);
}
*out = Interactive(body, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Expression_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty body;
if (_PyObject_LookupAttr(obj, astmodulestate_global->body, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Expression");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &body, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = Expression(body, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->FunctionType_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
asdl_seq* argtypes;
expr_ty returns;
if (_PyObject_LookupAttr(obj, astmodulestate_global->argtypes, &tmp) <
0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"argtypes\" missing from FunctionType");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "FunctionType field \"argtypes\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
argtypes = _Py_asdl_seq_new(len, arena);
if (argtypes == NULL) goto failed;
for (i = 0; i < len; i++) {
expr_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_expr(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "FunctionType field \"argtypes\" changed size during iteration");
goto failed;
}
asdl_seq_SET(argtypes, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->returns, &tmp) <
0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"returns\" missing from FunctionType");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &returns, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = FunctionType(argtypes, returns, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Suite_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
asdl_seq* body;
if (_PyObject_LookupAttr(obj, astmodulestate_global->body, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Suite");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "Suite field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
body = _Py_asdl_seq_new(len, arena);
if (body == NULL) goto failed;
for (i = 0; i < len; i++) {
stmt_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_stmt(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Suite field \"body\" changed size during iteration");
goto failed;
}
asdl_seq_SET(body, i, val);
}
Py_CLEAR(tmp);
}
*out = Suite(body, arena);
if (*out == NULL) goto failed;
return 0;
}
PyErr_Format(PyExc_TypeError, "expected some sort of mod, but got %R", obj);
failed:
Py_XDECREF(tmp);
return 1;
}
int
obj2ast_stmt(PyObject* obj, stmt_ty* out, PyArena* arena)
{
int isinstance;
PyObject *tmp = NULL;
PyObject *tp;
int lineno;
int col_offset;
int end_lineno;
int end_col_offset;
if (obj == Py_None) {
*out = NULL;
return 0;
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->lineno, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from stmt");
return 1;
}
else {
int res;
res = obj2ast_int(tmp, &lineno, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->col_offset, &tmp) < 0)
{
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from stmt");
return 1;
}
else {
int res;
res = obj2ast_int(tmp, &col_offset, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->end_lineno, &tmp) < 0)
{
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
end_lineno = 0;
}
else {
int res;
res = obj2ast_int(tmp, &end_lineno, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->end_col_offset, &tmp)
< 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
end_col_offset = 0;
}
else {
int res;
res = obj2ast_int(tmp, &end_col_offset, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
tp = astmodulestate_global->FunctionDef_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
identifier name;
arguments_ty args;
asdl_seq* body;
asdl_seq* decorator_list;
expr_ty returns;
string type_comment;
if (_PyObject_LookupAttr(obj, astmodulestate_global->name, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from FunctionDef");
return 1;
}
else {
int res;
res = obj2ast_identifier(tmp, &name, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->args, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from FunctionDef");
return 1;
}
else {
int res;
res = obj2ast_arguments(tmp, &args, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->body, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from FunctionDef");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "FunctionDef field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
body = _Py_asdl_seq_new(len, arena);
if (body == NULL) goto failed;
for (i = 0; i < len; i++) {
stmt_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_stmt(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "FunctionDef field \"body\" changed size during iteration");
goto failed;
}
asdl_seq_SET(body, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->decorator_list,
&tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"decorator_list\" missing from FunctionDef");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "FunctionDef field \"decorator_list\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
decorator_list = _Py_asdl_seq_new(len, arena);
if (decorator_list == NULL) goto failed;
for (i = 0; i < len; i++) {
expr_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_expr(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "FunctionDef field \"decorator_list\" changed size during iteration");
goto failed;
}
asdl_seq_SET(decorator_list, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->returns, &tmp) <
0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
returns = NULL;
}
else {
int res;
res = obj2ast_expr(tmp, &returns, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->type_comment,
&tmp) < 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
type_comment = NULL;
}
else {
int res;
res = obj2ast_string(tmp, &type_comment, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = FunctionDef(name, args, body, decorator_list, returns,
type_comment, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->AsyncFunctionDef_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
identifier name;
arguments_ty args;
asdl_seq* body;
asdl_seq* decorator_list;
expr_ty returns;
string type_comment;
if (_PyObject_LookupAttr(obj, astmodulestate_global->name, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from AsyncFunctionDef");
return 1;
}
else {
int res;
res = obj2ast_identifier(tmp, &name, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->args, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from AsyncFunctionDef");
return 1;
}
else {
int res;
res = obj2ast_arguments(tmp, &args, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->body, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from AsyncFunctionDef");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "AsyncFunctionDef field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
body = _Py_asdl_seq_new(len, arena);
if (body == NULL) goto failed;
for (i = 0; i < len; i++) {
stmt_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_stmt(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "AsyncFunctionDef field \"body\" changed size during iteration");
goto failed;
}
asdl_seq_SET(body, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->decorator_list,
&tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"decorator_list\" missing from AsyncFunctionDef");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "AsyncFunctionDef field \"decorator_list\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
decorator_list = _Py_asdl_seq_new(len, arena);
if (decorator_list == NULL) goto failed;
for (i = 0; i < len; i++) {
expr_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_expr(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "AsyncFunctionDef field \"decorator_list\" changed size during iteration");
goto failed;
}
asdl_seq_SET(decorator_list, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->returns, &tmp) <
0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
returns = NULL;
}
else {
int res;
res = obj2ast_expr(tmp, &returns, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->type_comment,
&tmp) < 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
type_comment = NULL;
}
else {
int res;
res = obj2ast_string(tmp, &type_comment, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = AsyncFunctionDef(name, args, body, decorator_list, returns,
type_comment, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->ClassDef_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
identifier name;
asdl_seq* bases;
asdl_seq* keywords;
asdl_seq* body;
asdl_seq* decorator_list;
if (_PyObject_LookupAttr(obj, astmodulestate_global->name, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from ClassDef");
return 1;
}
else {
int res;
res = obj2ast_identifier(tmp, &name, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->bases, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"bases\" missing from ClassDef");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "ClassDef field \"bases\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
bases = _Py_asdl_seq_new(len, arena);
if (bases == NULL) goto failed;
for (i = 0; i < len; i++) {
expr_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_expr(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"bases\" changed size during iteration");
goto failed;
}
asdl_seq_SET(bases, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->keywords, &tmp) <
0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"keywords\" missing from ClassDef");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "ClassDef field \"keywords\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
keywords = _Py_asdl_seq_new(len, arena);
if (keywords == NULL) goto failed;
for (i = 0; i < len; i++) {
keyword_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_keyword(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"keywords\" changed size during iteration");
goto failed;
}
asdl_seq_SET(keywords, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->body, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from ClassDef");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "ClassDef field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
body = _Py_asdl_seq_new(len, arena);
if (body == NULL) goto failed;
for (i = 0; i < len; i++) {
stmt_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_stmt(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"body\" changed size during iteration");
goto failed;
}
asdl_seq_SET(body, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->decorator_list,
&tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"decorator_list\" missing from ClassDef");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "ClassDef field \"decorator_list\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
decorator_list = _Py_asdl_seq_new(len, arena);
if (decorator_list == NULL) goto failed;
for (i = 0; i < len; i++) {
expr_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_expr(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"decorator_list\" changed size during iteration");
goto failed;
}
asdl_seq_SET(decorator_list, i, val);
}
Py_CLEAR(tmp);
}
*out = ClassDef(name, bases, keywords, body, decorator_list, lineno,
col_offset, end_lineno, end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Return_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty value;
if (_PyObject_LookupAttr(obj, astmodulestate_global->value, &tmp) < 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
value = NULL;
}
else {
int res;
res = obj2ast_expr(tmp, &value, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = Return(value, lineno, col_offset, end_lineno, end_col_offset,
arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Delete_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
asdl_seq* targets;
if (_PyObject_LookupAttr(obj, astmodulestate_global->targets, &tmp) <
0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"targets\" missing from Delete");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "Delete field \"targets\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
targets = _Py_asdl_seq_new(len, arena);
if (targets == NULL) goto failed;
for (i = 0; i < len; i++) {
expr_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_expr(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Delete field \"targets\" changed size during iteration");
goto failed;
}
asdl_seq_SET(targets, i, val);
}
Py_CLEAR(tmp);
}
*out = Delete(targets, lineno, col_offset, end_lineno, end_col_offset,
arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Assign_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
asdl_seq* targets;
expr_ty value;
string type_comment;
if (_PyObject_LookupAttr(obj, astmodulestate_global->targets, &tmp) <
0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"targets\" missing from Assign");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "Assign field \"targets\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
targets = _Py_asdl_seq_new(len, arena);
if (targets == NULL) goto failed;
for (i = 0; i < len; i++) {
expr_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_expr(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Assign field \"targets\" changed size during iteration");
goto failed;
}
asdl_seq_SET(targets, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->value, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Assign");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &value, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->type_comment,
&tmp) < 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
type_comment = NULL;
}
else {
int res;
res = obj2ast_string(tmp, &type_comment, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = Assign(targets, value, type_comment, lineno, col_offset,
end_lineno, end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->AugAssign_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty target;
operator_ty op;
expr_ty value;
if (_PyObject_LookupAttr(obj, astmodulestate_global->target, &tmp) < 0)
{
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from AugAssign");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &target, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->op, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from AugAssign");
return 1;
}
else {
int res;
res = obj2ast_operator(tmp, &op, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->value, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from AugAssign");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &value, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = AugAssign(target, op, value, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->AnnAssign_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty target;
expr_ty annotation;
expr_ty value;
int simple;
if (_PyObject_LookupAttr(obj, astmodulestate_global->target, &tmp) < 0)
{
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from AnnAssign");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &target, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->annotation, &tmp)
< 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"annotation\" missing from AnnAssign");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &annotation, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->value, &tmp) < 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
value = NULL;
}
else {
int res;
res = obj2ast_expr(tmp, &value, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->simple, &tmp) < 0)
{
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"simple\" missing from AnnAssign");
return 1;
}
else {
int res;
res = obj2ast_int(tmp, &simple, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = AnnAssign(target, annotation, value, simple, lineno, col_offset,
end_lineno, end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->For_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty target;
expr_ty iter;
asdl_seq* body;
asdl_seq* orelse;
string type_comment;
if (_PyObject_LookupAttr(obj, astmodulestate_global->target, &tmp) < 0)
{
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from For");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &target, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->iter, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"iter\" missing from For");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &iter, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->body, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from For");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "For field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
body = _Py_asdl_seq_new(len, arena);
if (body == NULL) goto failed;
for (i = 0; i < len; i++) {
stmt_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_stmt(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "For field \"body\" changed size during iteration");
goto failed;
}
asdl_seq_SET(body, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->orelse, &tmp) < 0)
{
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from For");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "For field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
orelse = _Py_asdl_seq_new(len, arena);
if (orelse == NULL) goto failed;
for (i = 0; i < len; i++) {
stmt_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_stmt(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "For field \"orelse\" changed size during iteration");
goto failed;
}
asdl_seq_SET(orelse, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->type_comment,
&tmp) < 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
type_comment = NULL;
}
else {
int res;
res = obj2ast_string(tmp, &type_comment, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = For(target, iter, body, orelse, type_comment, lineno,
col_offset, end_lineno, end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->AsyncFor_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty target;
expr_ty iter;
asdl_seq* body;
asdl_seq* orelse;
string type_comment;
if (_PyObject_LookupAttr(obj, astmodulestate_global->target, &tmp) < 0)
{
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from AsyncFor");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &target, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->iter, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"iter\" missing from AsyncFor");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &iter, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->body, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from AsyncFor");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "AsyncFor field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
body = _Py_asdl_seq_new(len, arena);
if (body == NULL) goto failed;
for (i = 0; i < len; i++) {
stmt_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_stmt(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "AsyncFor field \"body\" changed size during iteration");
goto failed;
}
asdl_seq_SET(body, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->orelse, &tmp) < 0)
{
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from AsyncFor");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "AsyncFor field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
orelse = _Py_asdl_seq_new(len, arena);
if (orelse == NULL) goto failed;
for (i = 0; i < len; i++) {
stmt_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_stmt(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "AsyncFor field \"orelse\" changed size during iteration");
goto failed;
}
asdl_seq_SET(orelse, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->type_comment,
&tmp) < 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
type_comment = NULL;
}
else {
int res;
res = obj2ast_string(tmp, &type_comment, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = AsyncFor(target, iter, body, orelse, type_comment, lineno,
col_offset, end_lineno, end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->While_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty test;
asdl_seq* body;
asdl_seq* orelse;
if (_PyObject_LookupAttr(obj, astmodulestate_global->test, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from While");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &test, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->body, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from While");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "While field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
body = _Py_asdl_seq_new(len, arena);
if (body == NULL) goto failed;
for (i = 0; i < len; i++) {
stmt_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_stmt(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "While field \"body\" changed size during iteration");
goto failed;
}
asdl_seq_SET(body, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->orelse, &tmp) < 0)
{
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from While");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "While field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
orelse = _Py_asdl_seq_new(len, arena);
if (orelse == NULL) goto failed;
for (i = 0; i < len; i++) {
stmt_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_stmt(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "While field \"orelse\" changed size during iteration");
goto failed;
}
asdl_seq_SET(orelse, i, val);
}
Py_CLEAR(tmp);
}
*out = While(test, body, orelse, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->If_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty test;
asdl_seq* body;
asdl_seq* orelse;
if (_PyObject_LookupAttr(obj, astmodulestate_global->test, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from If");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &test, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->body, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from If");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "If field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
body = _Py_asdl_seq_new(len, arena);
if (body == NULL) goto failed;
for (i = 0; i < len; i++) {
stmt_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_stmt(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "If field \"body\" changed size during iteration");
goto failed;
}
asdl_seq_SET(body, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->orelse, &tmp) < 0)
{
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from If");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "If field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
orelse = _Py_asdl_seq_new(len, arena);
if (orelse == NULL) goto failed;
for (i = 0; i < len; i++) {
stmt_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_stmt(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "If field \"orelse\" changed size during iteration");
goto failed;
}
asdl_seq_SET(orelse, i, val);
}
Py_CLEAR(tmp);
}
*out = If(test, body, orelse, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->With_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
asdl_seq* items;
asdl_seq* body;
string type_comment;
if (_PyObject_LookupAttr(obj, astmodulestate_global->items, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"items\" missing from With");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "With field \"items\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
items = _Py_asdl_seq_new(len, arena);
if (items == NULL) goto failed;
for (i = 0; i < len; i++) {
withitem_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_withitem(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "With field \"items\" changed size during iteration");
goto failed;
}
asdl_seq_SET(items, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->body, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from With");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "With field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
body = _Py_asdl_seq_new(len, arena);
if (body == NULL) goto failed;
for (i = 0; i < len; i++) {
stmt_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_stmt(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "With field \"body\" changed size during iteration");
goto failed;
}
asdl_seq_SET(body, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->type_comment,
&tmp) < 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
type_comment = NULL;
}
else {
int res;
res = obj2ast_string(tmp, &type_comment, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = With(items, body, type_comment, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->AsyncWith_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
asdl_seq* items;
asdl_seq* body;
string type_comment;
if (_PyObject_LookupAttr(obj, astmodulestate_global->items, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"items\" missing from AsyncWith");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "AsyncWith field \"items\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
items = _Py_asdl_seq_new(len, arena);
if (items == NULL) goto failed;
for (i = 0; i < len; i++) {
withitem_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_withitem(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "AsyncWith field \"items\" changed size during iteration");
goto failed;
}
asdl_seq_SET(items, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->body, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from AsyncWith");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "AsyncWith field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
body = _Py_asdl_seq_new(len, arena);
if (body == NULL) goto failed;
for (i = 0; i < len; i++) {
stmt_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_stmt(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "AsyncWith field \"body\" changed size during iteration");
goto failed;
}
asdl_seq_SET(body, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->type_comment,
&tmp) < 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
type_comment = NULL;
}
else {
int res;
res = obj2ast_string(tmp, &type_comment, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = AsyncWith(items, body, type_comment, lineno, col_offset,
end_lineno, end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Raise_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty exc;
expr_ty cause;
if (_PyObject_LookupAttr(obj, astmodulestate_global->exc, &tmp) < 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
exc = NULL;
}
else {
int res;
res = obj2ast_expr(tmp, &exc, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->cause, &tmp) < 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
cause = NULL;
}
else {
int res;
res = obj2ast_expr(tmp, &cause, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = Raise(exc, cause, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Try_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
asdl_seq* body;
asdl_seq* handlers;
asdl_seq* orelse;
asdl_seq* finalbody;
if (_PyObject_LookupAttr(obj, astmodulestate_global->body, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Try");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "Try field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
body = _Py_asdl_seq_new(len, arena);
if (body == NULL) goto failed;
for (i = 0; i < len; i++) {
stmt_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_stmt(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Try field \"body\" changed size during iteration");
goto failed;
}
asdl_seq_SET(body, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->handlers, &tmp) <
0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"handlers\" missing from Try");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "Try field \"handlers\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
handlers = _Py_asdl_seq_new(len, arena);
if (handlers == NULL) goto failed;
for (i = 0; i < len; i++) {
excepthandler_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_excepthandler(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Try field \"handlers\" changed size during iteration");
goto failed;
}
asdl_seq_SET(handlers, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->orelse, &tmp) < 0)
{
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from Try");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "Try field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
orelse = _Py_asdl_seq_new(len, arena);
if (orelse == NULL) goto failed;
for (i = 0; i < len; i++) {
stmt_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_stmt(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Try field \"orelse\" changed size during iteration");
goto failed;
}
asdl_seq_SET(orelse, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->finalbody, &tmp) <
0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"finalbody\" missing from Try");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "Try field \"finalbody\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
finalbody = _Py_asdl_seq_new(len, arena);
if (finalbody == NULL) goto failed;
for (i = 0; i < len; i++) {
stmt_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_stmt(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Try field \"finalbody\" changed size during iteration");
goto failed;
}
asdl_seq_SET(finalbody, i, val);
}
Py_CLEAR(tmp);
}
*out = Try(body, handlers, orelse, finalbody, lineno, col_offset,
end_lineno, end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Assert_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty test;
expr_ty msg;
if (_PyObject_LookupAttr(obj, astmodulestate_global->test, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from Assert");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &test, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->msg, &tmp) < 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
msg = NULL;
}
else {
int res;
res = obj2ast_expr(tmp, &msg, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = Assert(test, msg, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Import_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
asdl_seq* names;
if (_PyObject_LookupAttr(obj, astmodulestate_global->names, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"names\" missing from Import");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "Import field \"names\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
names = _Py_asdl_seq_new(len, arena);
if (names == NULL) goto failed;
for (i = 0; i < len; i++) {
alias_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_alias(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Import field \"names\" changed size during iteration");
goto failed;
}
asdl_seq_SET(names, i, val);
}
Py_CLEAR(tmp);
}
*out = Import(names, lineno, col_offset, end_lineno, end_col_offset,
arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->ImportFrom_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
identifier module;
asdl_seq* names;
int level;
if (_PyObject_LookupAttr(obj, astmodulestate_global->module, &tmp) < 0)
{
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
module = NULL;
}
else {
int res;
res = obj2ast_identifier(tmp, &module, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->names, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"names\" missing from ImportFrom");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "ImportFrom field \"names\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
names = _Py_asdl_seq_new(len, arena);
if (names == NULL) goto failed;
for (i = 0; i < len; i++) {
alias_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_alias(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "ImportFrom field \"names\" changed size during iteration");
goto failed;
}
asdl_seq_SET(names, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->level, &tmp) < 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
level = 0;
}
else {
int res;
res = obj2ast_int(tmp, &level, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = ImportFrom(module, names, level, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Global_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
asdl_seq* names;
if (_PyObject_LookupAttr(obj, astmodulestate_global->names, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"names\" missing from Global");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "Global field \"names\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
names = _Py_asdl_seq_new(len, arena);
if (names == NULL) goto failed;
for (i = 0; i < len; i++) {
identifier val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_identifier(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Global field \"names\" changed size during iteration");
goto failed;
}
asdl_seq_SET(names, i, val);
}
Py_CLEAR(tmp);
}
*out = Global(names, lineno, col_offset, end_lineno, end_col_offset,
arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Nonlocal_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
asdl_seq* names;
if (_PyObject_LookupAttr(obj, astmodulestate_global->names, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"names\" missing from Nonlocal");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "Nonlocal field \"names\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
names = _Py_asdl_seq_new(len, arena);
if (names == NULL) goto failed;
for (i = 0; i < len; i++) {
identifier val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_identifier(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Nonlocal field \"names\" changed size during iteration");
goto failed;
}
asdl_seq_SET(names, i, val);
}
Py_CLEAR(tmp);
}
*out = Nonlocal(names, lineno, col_offset, end_lineno, end_col_offset,
arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Expr_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty value;
if (_PyObject_LookupAttr(obj, astmodulestate_global->value, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Expr");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &value, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = Expr(value, lineno, col_offset, end_lineno, end_col_offset,
arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Pass_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = Pass(lineno, col_offset, end_lineno, end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Break_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = Break(lineno, col_offset, end_lineno, end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Continue_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = Continue(lineno, col_offset, end_lineno, end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
PyErr_Format(PyExc_TypeError, "expected some sort of stmt, but got %R", obj);
failed:
Py_XDECREF(tmp);
return 1;
}
int
obj2ast_expr(PyObject* obj, expr_ty* out, PyArena* arena)
{
int isinstance;
PyObject *tmp = NULL;
PyObject *tp;
int lineno;
int col_offset;
int end_lineno;
int end_col_offset;
if (obj == Py_None) {
*out = NULL;
return 0;
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->lineno, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from expr");
return 1;
}
else {
int res;
res = obj2ast_int(tmp, &lineno, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->col_offset, &tmp) < 0)
{
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from expr");
return 1;
}
else {
int res;
res = obj2ast_int(tmp, &col_offset, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->end_lineno, &tmp) < 0)
{
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
end_lineno = 0;
}
else {
int res;
res = obj2ast_int(tmp, &end_lineno, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->end_col_offset, &tmp)
< 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
end_col_offset = 0;
}
else {
int res;
res = obj2ast_int(tmp, &end_col_offset, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
tp = astmodulestate_global->BoolOp_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
boolop_ty op;
asdl_seq* values;
if (_PyObject_LookupAttr(obj, astmodulestate_global->op, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from BoolOp");
return 1;
}
else {
int res;
res = obj2ast_boolop(tmp, &op, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->values, &tmp) < 0)
{
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"values\" missing from BoolOp");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "BoolOp field \"values\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
values = _Py_asdl_seq_new(len, arena);
if (values == NULL) goto failed;
for (i = 0; i < len; i++) {
expr_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_expr(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "BoolOp field \"values\" changed size during iteration");
goto failed;
}
asdl_seq_SET(values, i, val);
}
Py_CLEAR(tmp);
}
*out = BoolOp(op, values, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->NamedExpr_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty target;
expr_ty value;
if (_PyObject_LookupAttr(obj, astmodulestate_global->target, &tmp) < 0)
{
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from NamedExpr");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &target, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->value, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from NamedExpr");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &value, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = NamedExpr(target, value, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->BinOp_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty left;
operator_ty op;
expr_ty right;
if (_PyObject_LookupAttr(obj, astmodulestate_global->left, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"left\" missing from BinOp");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &left, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->op, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from BinOp");
return 1;
}
else {
int res;
res = obj2ast_operator(tmp, &op, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->right, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"right\" missing from BinOp");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &right, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = BinOp(left, op, right, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->UnaryOp_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
unaryop_ty op;
expr_ty operand;
if (_PyObject_LookupAttr(obj, astmodulestate_global->op, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from UnaryOp");
return 1;
}
else {
int res;
res = obj2ast_unaryop(tmp, &op, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->operand, &tmp) <
0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"operand\" missing from UnaryOp");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &operand, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = UnaryOp(op, operand, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Lambda_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
arguments_ty args;
expr_ty body;
if (_PyObject_LookupAttr(obj, astmodulestate_global->args, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from Lambda");
return 1;
}
else {
int res;
res = obj2ast_arguments(tmp, &args, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->body, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Lambda");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &body, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = Lambda(args, body, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->IfExp_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty test;
expr_ty body;
expr_ty orelse;
if (_PyObject_LookupAttr(obj, astmodulestate_global->test, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from IfExp");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &test, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->body, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from IfExp");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &body, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->orelse, &tmp) < 0)
{
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from IfExp");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &orelse, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = IfExp(test, body, orelse, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Dict_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
asdl_seq* keys;
asdl_seq* values;
if (_PyObject_LookupAttr(obj, astmodulestate_global->keys, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"keys\" missing from Dict");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "Dict field \"keys\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
keys = _Py_asdl_seq_new(len, arena);
if (keys == NULL) goto failed;
for (i = 0; i < len; i++) {
expr_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_expr(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Dict field \"keys\" changed size during iteration");
goto failed;
}
asdl_seq_SET(keys, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->values, &tmp) < 0)
{
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"values\" missing from Dict");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "Dict field \"values\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
values = _Py_asdl_seq_new(len, arena);
if (values == NULL) goto failed;
for (i = 0; i < len; i++) {
expr_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_expr(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Dict field \"values\" changed size during iteration");
goto failed;
}
asdl_seq_SET(values, i, val);
}
Py_CLEAR(tmp);
}
*out = Dict(keys, values, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Set_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
asdl_seq* elts;
if (_PyObject_LookupAttr(obj, astmodulestate_global->elts, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"elts\" missing from Set");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "Set field \"elts\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
elts = _Py_asdl_seq_new(len, arena);
if (elts == NULL) goto failed;
for (i = 0; i < len; i++) {
expr_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_expr(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Set field \"elts\" changed size during iteration");
goto failed;
}
asdl_seq_SET(elts, i, val);
}
Py_CLEAR(tmp);
}
*out = Set(elts, lineno, col_offset, end_lineno, end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->ListComp_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty elt;
asdl_seq* generators;
if (_PyObject_LookupAttr(obj, astmodulestate_global->elt, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"elt\" missing from ListComp");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &elt, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->generators, &tmp)
< 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from ListComp");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "ListComp field \"generators\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
generators = _Py_asdl_seq_new(len, arena);
if (generators == NULL) goto failed;
for (i = 0; i < len; i++) {
comprehension_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_comprehension(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "ListComp field \"generators\" changed size during iteration");
goto failed;
}
asdl_seq_SET(generators, i, val);
}
Py_CLEAR(tmp);
}
*out = ListComp(elt, generators, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->SetComp_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty elt;
asdl_seq* generators;
if (_PyObject_LookupAttr(obj, astmodulestate_global->elt, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"elt\" missing from SetComp");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &elt, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->generators, &tmp)
< 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from SetComp");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "SetComp field \"generators\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
generators = _Py_asdl_seq_new(len, arena);
if (generators == NULL) goto failed;
for (i = 0; i < len; i++) {
comprehension_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_comprehension(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "SetComp field \"generators\" changed size during iteration");
goto failed;
}
asdl_seq_SET(generators, i, val);
}
Py_CLEAR(tmp);
}
*out = SetComp(elt, generators, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->DictComp_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty key;
expr_ty value;
asdl_seq* generators;
if (_PyObject_LookupAttr(obj, astmodulestate_global->key, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"key\" missing from DictComp");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &key, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->value, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from DictComp");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &value, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->generators, &tmp)
< 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from DictComp");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "DictComp field \"generators\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
generators = _Py_asdl_seq_new(len, arena);
if (generators == NULL) goto failed;
for (i = 0; i < len; i++) {
comprehension_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_comprehension(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "DictComp field \"generators\" changed size during iteration");
goto failed;
}
asdl_seq_SET(generators, i, val);
}
Py_CLEAR(tmp);
}
*out = DictComp(key, value, generators, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->GeneratorExp_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty elt;
asdl_seq* generators;
if (_PyObject_LookupAttr(obj, astmodulestate_global->elt, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"elt\" missing from GeneratorExp");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &elt, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->generators, &tmp)
< 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from GeneratorExp");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "GeneratorExp field \"generators\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
generators = _Py_asdl_seq_new(len, arena);
if (generators == NULL) goto failed;
for (i = 0; i < len; i++) {
comprehension_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_comprehension(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "GeneratorExp field \"generators\" changed size during iteration");
goto failed;
}
asdl_seq_SET(generators, i, val);
}
Py_CLEAR(tmp);
}
*out = GeneratorExp(elt, generators, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Await_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty value;
if (_PyObject_LookupAttr(obj, astmodulestate_global->value, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Await");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &value, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = Await(value, lineno, col_offset, end_lineno, end_col_offset,
arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Yield_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty value;
if (_PyObject_LookupAttr(obj, astmodulestate_global->value, &tmp) < 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
value = NULL;
}
else {
int res;
res = obj2ast_expr(tmp, &value, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = Yield(value, lineno, col_offset, end_lineno, end_col_offset,
arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->YieldFrom_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty value;
if (_PyObject_LookupAttr(obj, astmodulestate_global->value, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from YieldFrom");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &value, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = YieldFrom(value, lineno, col_offset, end_lineno, end_col_offset,
arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Compare_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty left;
asdl_int_seq* ops;
asdl_seq* comparators;
if (_PyObject_LookupAttr(obj, astmodulestate_global->left, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"left\" missing from Compare");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &left, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->ops, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"ops\" missing from Compare");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "Compare field \"ops\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
ops = _Py_asdl_int_seq_new(len, arena);
if (ops == NULL) goto failed;
for (i = 0; i < len; i++) {
cmpop_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_cmpop(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Compare field \"ops\" changed size during iteration");
goto failed;
}
asdl_seq_SET(ops, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->comparators, &tmp)
< 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"comparators\" missing from Compare");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "Compare field \"comparators\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
comparators = _Py_asdl_seq_new(len, arena);
if (comparators == NULL) goto failed;
for (i = 0; i < len; i++) {
expr_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_expr(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Compare field \"comparators\" changed size during iteration");
goto failed;
}
asdl_seq_SET(comparators, i, val);
}
Py_CLEAR(tmp);
}
*out = Compare(left, ops, comparators, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Call_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty func;
asdl_seq* args;
asdl_seq* keywords;
if (_PyObject_LookupAttr(obj, astmodulestate_global->func, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"func\" missing from Call");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &func, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->args, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from Call");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "Call field \"args\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
args = _Py_asdl_seq_new(len, arena);
if (args == NULL) goto failed;
for (i = 0; i < len; i++) {
expr_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_expr(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Call field \"args\" changed size during iteration");
goto failed;
}
asdl_seq_SET(args, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->keywords, &tmp) <
0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"keywords\" missing from Call");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "Call field \"keywords\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
keywords = _Py_asdl_seq_new(len, arena);
if (keywords == NULL) goto failed;
for (i = 0; i < len; i++) {
keyword_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_keyword(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Call field \"keywords\" changed size during iteration");
goto failed;
}
asdl_seq_SET(keywords, i, val);
}
Py_CLEAR(tmp);
}
*out = Call(func, args, keywords, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->FormattedValue_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty value;
int conversion;
expr_ty format_spec;
if (_PyObject_LookupAttr(obj, astmodulestate_global->value, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from FormattedValue");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &value, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->conversion, &tmp)
< 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
conversion = 0;
}
else {
int res;
res = obj2ast_int(tmp, &conversion, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->format_spec, &tmp)
< 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
format_spec = NULL;
}
else {
int res;
res = obj2ast_expr(tmp, &format_spec, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = FormattedValue(value, conversion, format_spec, lineno,
col_offset, end_lineno, end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->JoinedStr_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
asdl_seq* values;
if (_PyObject_LookupAttr(obj, astmodulestate_global->values, &tmp) < 0)
{
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"values\" missing from JoinedStr");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "JoinedStr field \"values\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
values = _Py_asdl_seq_new(len, arena);
if (values == NULL) goto failed;
for (i = 0; i < len; i++) {
expr_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_expr(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "JoinedStr field \"values\" changed size during iteration");
goto failed;
}
asdl_seq_SET(values, i, val);
}
Py_CLEAR(tmp);
}
*out = JoinedStr(values, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Constant_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
constant value;
string kind;
if (_PyObject_LookupAttr(obj, astmodulestate_global->value, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Constant");
return 1;
}
else {
int res;
res = obj2ast_constant(tmp, &value, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->kind, &tmp) < 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
kind = NULL;
}
else {
int res;
res = obj2ast_string(tmp, &kind, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = Constant(value, kind, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Attribute_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty value;
identifier attr;
expr_context_ty ctx;
if (_PyObject_LookupAttr(obj, astmodulestate_global->value, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Attribute");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &value, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->attr, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"attr\" missing from Attribute");
return 1;
}
else {
int res;
res = obj2ast_identifier(tmp, &attr, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->ctx, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Attribute");
return 1;
}
else {
int res;
res = obj2ast_expr_context(tmp, &ctx, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = Attribute(value, attr, ctx, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Subscript_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty value;
slice_ty slice;
expr_context_ty ctx;
if (_PyObject_LookupAttr(obj, astmodulestate_global->value, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Subscript");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &value, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->slice, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"slice\" missing from Subscript");
return 1;
}
else {
int res;
res = obj2ast_slice(tmp, &slice, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->ctx, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Subscript");
return 1;
}
else {
int res;
res = obj2ast_expr_context(tmp, &ctx, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = Subscript(value, slice, ctx, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Starred_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty value;
expr_context_ty ctx;
if (_PyObject_LookupAttr(obj, astmodulestate_global->value, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Starred");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &value, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->ctx, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Starred");
return 1;
}
else {
int res;
res = obj2ast_expr_context(tmp, &ctx, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = Starred(value, ctx, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Name_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
identifier id;
expr_context_ty ctx;
if (_PyObject_LookupAttr(obj, astmodulestate_global->id, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"id\" missing from Name");
return 1;
}
else {
int res;
res = obj2ast_identifier(tmp, &id, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->ctx, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Name");
return 1;
}
else {
int res;
res = obj2ast_expr_context(tmp, &ctx, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = Name(id, ctx, lineno, col_offset, end_lineno, end_col_offset,
arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->List_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
asdl_seq* elts;
expr_context_ty ctx;
if (_PyObject_LookupAttr(obj, astmodulestate_global->elts, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"elts\" missing from List");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "List field \"elts\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
elts = _Py_asdl_seq_new(len, arena);
if (elts == NULL) goto failed;
for (i = 0; i < len; i++) {
expr_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_expr(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "List field \"elts\" changed size during iteration");
goto failed;
}
asdl_seq_SET(elts, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->ctx, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from List");
return 1;
}
else {
int res;
res = obj2ast_expr_context(tmp, &ctx, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = List(elts, ctx, lineno, col_offset, end_lineno, end_col_offset,
arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Tuple_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
asdl_seq* elts;
expr_context_ty ctx;
if (_PyObject_LookupAttr(obj, astmodulestate_global->elts, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"elts\" missing from Tuple");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "Tuple field \"elts\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
elts = _Py_asdl_seq_new(len, arena);
if (elts == NULL) goto failed;
for (i = 0; i < len; i++) {
expr_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_expr(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "Tuple field \"elts\" changed size during iteration");
goto failed;
}
asdl_seq_SET(elts, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->ctx, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Tuple");
return 1;
}
else {
int res;
res = obj2ast_expr_context(tmp, &ctx, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = Tuple(elts, ctx, lineno, col_offset, end_lineno, end_col_offset,
arena);
if (*out == NULL) goto failed;
return 0;
}
PyErr_Format(PyExc_TypeError, "expected some sort of expr, but got %R", obj);
failed:
Py_XDECREF(tmp);
return 1;
}
int
obj2ast_expr_context(PyObject* obj, expr_context_ty* out, PyArena* arena)
{
int isinstance;
isinstance = PyObject_IsInstance(obj, astmodulestate_global->Load_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = Load;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->Store_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = Store;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->Del_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = Del;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->AugLoad_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = AugLoad;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->AugStore_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = AugStore;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->Param_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = Param;
return 0;
}
PyErr_Format(PyExc_TypeError, "expected some sort of expr_context, but got %R", obj);
return 1;
}
int
obj2ast_slice(PyObject* obj, slice_ty* out, PyArena* arena)
{
int isinstance;
PyObject *tmp = NULL;
PyObject *tp;
if (obj == Py_None) {
*out = NULL;
return 0;
}
tp = astmodulestate_global->Slice_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty lower;
expr_ty upper;
expr_ty step;
if (_PyObject_LookupAttr(obj, astmodulestate_global->lower, &tmp) < 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
lower = NULL;
}
else {
int res;
res = obj2ast_expr(tmp, &lower, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->upper, &tmp) < 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
upper = NULL;
}
else {
int res;
res = obj2ast_expr(tmp, &upper, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->step, &tmp) < 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
step = NULL;
}
else {
int res;
res = obj2ast_expr(tmp, &step, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = Slice(lower, upper, step, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->ExtSlice_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
asdl_seq* dims;
if (_PyObject_LookupAttr(obj, astmodulestate_global->dims, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"dims\" missing from ExtSlice");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "ExtSlice field \"dims\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
dims = _Py_asdl_seq_new(len, arena);
if (dims == NULL) goto failed;
for (i = 0; i < len; i++) {
slice_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_slice(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "ExtSlice field \"dims\" changed size during iteration");
goto failed;
}
asdl_seq_SET(dims, i, val);
}
Py_CLEAR(tmp);
}
*out = ExtSlice(dims, arena);
if (*out == NULL) goto failed;
return 0;
}
tp = astmodulestate_global->Index_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty value;
if (_PyObject_LookupAttr(obj, astmodulestate_global->value, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Index");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &value, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = Index(value, arena);
if (*out == NULL) goto failed;
return 0;
}
PyErr_Format(PyExc_TypeError, "expected some sort of slice, but got %R", obj);
failed:
Py_XDECREF(tmp);
return 1;
}
int
obj2ast_boolop(PyObject* obj, boolop_ty* out, PyArena* arena)
{
int isinstance;
isinstance = PyObject_IsInstance(obj, astmodulestate_global->And_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = And;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->Or_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = Or;
return 0;
}
PyErr_Format(PyExc_TypeError, "expected some sort of boolop, but got %R", obj);
return 1;
}
int
obj2ast_operator(PyObject* obj, operator_ty* out, PyArena* arena)
{
int isinstance;
isinstance = PyObject_IsInstance(obj, astmodulestate_global->Add_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = Add;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->Sub_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = Sub;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->Mult_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = Mult;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->MatMult_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = MatMult;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->Div_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = Div;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->Mod_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = Mod;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->Pow_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = Pow;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->LShift_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = LShift;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->RShift_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = RShift;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->BitOr_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = BitOr;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->BitXor_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = BitXor;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->BitAnd_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = BitAnd;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->FloorDiv_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = FloorDiv;
return 0;
}
PyErr_Format(PyExc_TypeError, "expected some sort of operator, but got %R", obj);
return 1;
}
int
obj2ast_unaryop(PyObject* obj, unaryop_ty* out, PyArena* arena)
{
int isinstance;
isinstance = PyObject_IsInstance(obj, astmodulestate_global->Invert_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = Invert;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->Not_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = Not;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->UAdd_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = UAdd;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->USub_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = USub;
return 0;
}
PyErr_Format(PyExc_TypeError, "expected some sort of unaryop, but got %R", obj);
return 1;
}
int
obj2ast_cmpop(PyObject* obj, cmpop_ty* out, PyArena* arena)
{
int isinstance;
isinstance = PyObject_IsInstance(obj, astmodulestate_global->Eq_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = Eq;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->NotEq_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = NotEq;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->Lt_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = Lt;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->LtE_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = LtE;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->Gt_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = Gt;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->GtE_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = GtE;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->Is_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = Is;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->IsNot_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = IsNot;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->In_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = In;
return 0;
}
isinstance = PyObject_IsInstance(obj, astmodulestate_global->NotIn_type);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
*out = NotIn;
return 0;
}
PyErr_Format(PyExc_TypeError, "expected some sort of cmpop, but got %R", obj);
return 1;
}
int
obj2ast_comprehension(PyObject* obj, comprehension_ty* out, PyArena* arena)
{
PyObject* tmp = NULL;
expr_ty target;
expr_ty iter;
asdl_seq* ifs;
int is_async;
if (_PyObject_LookupAttr(obj, astmodulestate_global->target, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from comprehension");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &target, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->iter, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"iter\" missing from comprehension");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &iter, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->ifs, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"ifs\" missing from comprehension");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "comprehension field \"ifs\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
ifs = _Py_asdl_seq_new(len, arena);
if (ifs == NULL) goto failed;
for (i = 0; i < len; i++) {
expr_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_expr(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "comprehension field \"ifs\" changed size during iteration");
goto failed;
}
asdl_seq_SET(ifs, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->is_async, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"is_async\" missing from comprehension");
return 1;
}
else {
int res;
res = obj2ast_int(tmp, &is_async, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = comprehension(target, iter, ifs, is_async, arena);
return 0;
failed:
Py_XDECREF(tmp);
return 1;
}
int
obj2ast_excepthandler(PyObject* obj, excepthandler_ty* out, PyArena* arena)
{
int isinstance;
PyObject *tmp = NULL;
PyObject *tp;
int lineno;
int col_offset;
int end_lineno;
int end_col_offset;
if (obj == Py_None) {
*out = NULL;
return 0;
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->lineno, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from excepthandler");
return 1;
}
else {
int res;
res = obj2ast_int(tmp, &lineno, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->col_offset, &tmp) < 0)
{
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from excepthandler");
return 1;
}
else {
int res;
res = obj2ast_int(tmp, &col_offset, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->end_lineno, &tmp) < 0)
{
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
end_lineno = 0;
}
else {
int res;
res = obj2ast_int(tmp, &end_lineno, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->end_col_offset, &tmp)
< 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
end_col_offset = 0;
}
else {
int res;
res = obj2ast_int(tmp, &end_col_offset, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
tp = astmodulestate_global->ExceptHandler_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
expr_ty type;
identifier name;
asdl_seq* body;
if (_PyObject_LookupAttr(obj, astmodulestate_global->type, &tmp) < 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
type = NULL;
}
else {
int res;
res = obj2ast_expr(tmp, &type, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->name, &tmp) < 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
name = NULL;
}
else {
int res;
res = obj2ast_identifier(tmp, &name, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->body, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from ExceptHandler");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "ExceptHandler field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
body = _Py_asdl_seq_new(len, arena);
if (body == NULL) goto failed;
for (i = 0; i < len; i++) {
stmt_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_stmt(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "ExceptHandler field \"body\" changed size during iteration");
goto failed;
}
asdl_seq_SET(body, i, val);
}
Py_CLEAR(tmp);
}
*out = ExceptHandler(type, name, body, lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed;
return 0;
}
PyErr_Format(PyExc_TypeError, "expected some sort of excepthandler, but got %R", obj);
failed:
Py_XDECREF(tmp);
return 1;
}
int
obj2ast_arguments(PyObject* obj, arguments_ty* out, PyArena* arena)
{
PyObject* tmp = NULL;
asdl_seq* posonlyargs;
asdl_seq* args;
arg_ty vararg;
asdl_seq* kwonlyargs;
asdl_seq* kw_defaults;
arg_ty kwarg;
asdl_seq* defaults;
if (_PyObject_LookupAttr(obj, astmodulestate_global->posonlyargs, &tmp) <
0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"posonlyargs\" missing from arguments");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "arguments field \"posonlyargs\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
posonlyargs = _Py_asdl_seq_new(len, arena);
if (posonlyargs == NULL) goto failed;
for (i = 0; i < len; i++) {
arg_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_arg(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "arguments field \"posonlyargs\" changed size during iteration");
goto failed;
}
asdl_seq_SET(posonlyargs, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->args, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from arguments");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "arguments field \"args\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
args = _Py_asdl_seq_new(len, arena);
if (args == NULL) goto failed;
for (i = 0; i < len; i++) {
arg_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_arg(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "arguments field \"args\" changed size during iteration");
goto failed;
}
asdl_seq_SET(args, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->vararg, &tmp) < 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
vararg = NULL;
}
else {
int res;
res = obj2ast_arg(tmp, &vararg, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->kwonlyargs, &tmp) < 0)
{
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"kwonlyargs\" missing from arguments");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "arguments field \"kwonlyargs\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
kwonlyargs = _Py_asdl_seq_new(len, arena);
if (kwonlyargs == NULL) goto failed;
for (i = 0; i < len; i++) {
arg_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_arg(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "arguments field \"kwonlyargs\" changed size during iteration");
goto failed;
}
asdl_seq_SET(kwonlyargs, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->kw_defaults, &tmp) <
0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"kw_defaults\" missing from arguments");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "arguments field \"kw_defaults\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
kw_defaults = _Py_asdl_seq_new(len, arena);
if (kw_defaults == NULL) goto failed;
for (i = 0; i < len; i++) {
expr_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_expr(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "arguments field \"kw_defaults\" changed size during iteration");
goto failed;
}
asdl_seq_SET(kw_defaults, i, val);
}
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->kwarg, &tmp) < 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
kwarg = NULL;
}
else {
int res;
res = obj2ast_arg(tmp, &kwarg, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->defaults, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"defaults\" missing from arguments");
return 1;
}
else {
int res;
Py_ssize_t len;
Py_ssize_t i;
if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "arguments field \"defaults\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed;
}
len = PyList_GET_SIZE(tmp);
defaults = _Py_asdl_seq_new(len, arena);
if (defaults == NULL) goto failed;
for (i = 0; i < len; i++) {
expr_ty val;
PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
Py_INCREF(tmp2);
res = obj2ast_expr(tmp2, &val, arena);
Py_DECREF(tmp2);
if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "arguments field \"defaults\" changed size during iteration");
goto failed;
}
asdl_seq_SET(defaults, i, val);
}
Py_CLEAR(tmp);
}
*out = arguments(posonlyargs, args, vararg, kwonlyargs, kw_defaults, kwarg,
defaults, arena);
return 0;
failed:
Py_XDECREF(tmp);
return 1;
}
int
obj2ast_arg(PyObject* obj, arg_ty* out, PyArena* arena)
{
PyObject* tmp = NULL;
identifier arg;
expr_ty annotation;
string type_comment;
int lineno;
int col_offset;
int end_lineno;
int end_col_offset;
if (_PyObject_LookupAttr(obj, astmodulestate_global->arg, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"arg\" missing from arg");
return 1;
}
else {
int res;
res = obj2ast_identifier(tmp, &arg, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->annotation, &tmp) < 0)
{
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
annotation = NULL;
}
else {
int res;
res = obj2ast_expr(tmp, &annotation, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->type_comment, &tmp) <
0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
type_comment = NULL;
}
else {
int res;
res = obj2ast_string(tmp, &type_comment, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->lineno, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from arg");
return 1;
}
else {
int res;
res = obj2ast_int(tmp, &lineno, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->col_offset, &tmp) < 0)
{
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from arg");
return 1;
}
else {
int res;
res = obj2ast_int(tmp, &col_offset, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->end_lineno, &tmp) < 0)
{
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
end_lineno = 0;
}
else {
int res;
res = obj2ast_int(tmp, &end_lineno, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->end_col_offset, &tmp)
< 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
end_col_offset = 0;
}
else {
int res;
res = obj2ast_int(tmp, &end_col_offset, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = arg(arg, annotation, type_comment, lineno, col_offset, end_lineno,
end_col_offset, arena);
return 0;
failed:
Py_XDECREF(tmp);
return 1;
}
int
obj2ast_keyword(PyObject* obj, keyword_ty* out, PyArena* arena)
{
PyObject* tmp = NULL;
identifier arg;
expr_ty value;
if (_PyObject_LookupAttr(obj, astmodulestate_global->arg, &tmp) < 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
arg = NULL;
}
else {
int res;
res = obj2ast_identifier(tmp, &arg, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->value, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from keyword");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &value, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = keyword(arg, value, arena);
return 0;
failed:
Py_XDECREF(tmp);
return 1;
}
int
obj2ast_alias(PyObject* obj, alias_ty* out, PyArena* arena)
{
PyObject* tmp = NULL;
identifier name;
identifier asname;
if (_PyObject_LookupAttr(obj, astmodulestate_global->name, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from alias");
return 1;
}
else {
int res;
res = obj2ast_identifier(tmp, &name, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->asname, &tmp) < 0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
asname = NULL;
}
else {
int res;
res = obj2ast_identifier(tmp, &asname, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = alias(name, asname, arena);
return 0;
failed:
Py_XDECREF(tmp);
return 1;
}
int
obj2ast_withitem(PyObject* obj, withitem_ty* out, PyArena* arena)
{
PyObject* tmp = NULL;
expr_ty context_expr;
expr_ty optional_vars;
if (_PyObject_LookupAttr(obj, astmodulestate_global->context_expr, &tmp) <
0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"context_expr\" missing from withitem");
return 1;
}
else {
int res;
res = obj2ast_expr(tmp, &context_expr, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->optional_vars, &tmp) <
0) {
return 1;
}
if (tmp == NULL || tmp == Py_None) {
Py_CLEAR(tmp);
optional_vars = NULL;
}
else {
int res;
res = obj2ast_expr(tmp, &optional_vars, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = withitem(context_expr, optional_vars, arena);
return 0;
failed:
Py_XDECREF(tmp);
return 1;
}
int
obj2ast_type_ignore(PyObject* obj, type_ignore_ty* out, PyArena* arena)
{
int isinstance;
PyObject *tmp = NULL;
PyObject *tp;
if (obj == Py_None) {
*out = NULL;
return 0;
}
tp = astmodulestate_global->TypeIgnore_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
return 1;
}
if (isinstance) {
int lineno;
string tag;
if (_PyObject_LookupAttr(obj, astmodulestate_global->lineno, &tmp) < 0)
{
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from TypeIgnore");
return 1;
}
else {
int res;
res = obj2ast_int(tmp, &lineno, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
if (_PyObject_LookupAttr(obj, astmodulestate_global->tag, &tmp) < 0) {
return 1;
}
if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"tag\" missing from TypeIgnore");
return 1;
}
else {
int res;
res = obj2ast_string(tmp, &tag, arena);
if (res != 0) goto failed;
Py_CLEAR(tmp);
}
*out = TypeIgnore(lineno, tag, arena);
if (*out == NULL) goto failed;
return 0;
}
PyErr_Format(PyExc_TypeError, "expected some sort of type_ignore, but got %R", obj);
failed:
Py_XDECREF(tmp);
return 1;
}
PyMODINIT_FUNC
PyInit__ast(void)
{
PyObject *m;
if (!init_types()) return NULL;
m = PyState_FindModule(&_astmodule);
if (!m) return NULL;
Py_INCREF(astmodulestate(m)->AST_type);
if (PyModule_AddObject(m, "AST", astmodulestate_global->AST_type) < 0)
return NULL;
if (PyModule_AddIntMacro(m, PyCF_ALLOW_TOP_LEVEL_AWAIT) < 0)
return NULL;
if (PyModule_AddIntMacro(m, PyCF_ONLY_AST) < 0)
return NULL;
if (PyModule_AddIntMacro(m, PyCF_TYPE_COMMENTS) < 0)
return NULL;
if (PyModule_AddObject(m, "mod", astmodulestate_global->mod_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->mod_type);
if (PyModule_AddObject(m, "Module", astmodulestate_global->Module_type) <
0) return NULL;
Py_INCREF(astmodulestate(m)->Module_type);
if (PyModule_AddObject(m, "Interactive",
astmodulestate_global->Interactive_type) < 0) return NULL;
Py_INCREF(astmodulestate(m)->Interactive_type);
if (PyModule_AddObject(m, "Expression",
astmodulestate_global->Expression_type) < 0) return NULL;
Py_INCREF(astmodulestate(m)->Expression_type);
if (PyModule_AddObject(m, "FunctionType",
astmodulestate_global->FunctionType_type) < 0) return NULL;
Py_INCREF(astmodulestate(m)->FunctionType_type);
if (PyModule_AddObject(m, "Suite", astmodulestate_global->Suite_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->Suite_type);
if (PyModule_AddObject(m, "stmt", astmodulestate_global->stmt_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->stmt_type);
if (PyModule_AddObject(m, "FunctionDef",
astmodulestate_global->FunctionDef_type) < 0) return NULL;
Py_INCREF(astmodulestate(m)->FunctionDef_type);
if (PyModule_AddObject(m, "AsyncFunctionDef",
astmodulestate_global->AsyncFunctionDef_type) < 0) return NULL;
Py_INCREF(astmodulestate(m)->AsyncFunctionDef_type);
if (PyModule_AddObject(m, "ClassDef", astmodulestate_global->ClassDef_type)
< 0) return NULL;
Py_INCREF(astmodulestate(m)->ClassDef_type);
if (PyModule_AddObject(m, "Return", astmodulestate_global->Return_type) <
0) return NULL;
Py_INCREF(astmodulestate(m)->Return_type);
if (PyModule_AddObject(m, "Delete", astmodulestate_global->Delete_type) <
0) return NULL;
Py_INCREF(astmodulestate(m)->Delete_type);
if (PyModule_AddObject(m, "Assign", astmodulestate_global->Assign_type) <
0) return NULL;
Py_INCREF(astmodulestate(m)->Assign_type);
if (PyModule_AddObject(m, "AugAssign",
astmodulestate_global->AugAssign_type) < 0) return NULL;
Py_INCREF(astmodulestate(m)->AugAssign_type);
if (PyModule_AddObject(m, "AnnAssign",
astmodulestate_global->AnnAssign_type) < 0) return NULL;
Py_INCREF(astmodulestate(m)->AnnAssign_type);
if (PyModule_AddObject(m, "For", astmodulestate_global->For_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->For_type);
if (PyModule_AddObject(m, "AsyncFor", astmodulestate_global->AsyncFor_type)
< 0) return NULL;
Py_INCREF(astmodulestate(m)->AsyncFor_type);
if (PyModule_AddObject(m, "While", astmodulestate_global->While_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->While_type);
if (PyModule_AddObject(m, "If", astmodulestate_global->If_type) < 0) return
NULL;
Py_INCREF(astmodulestate(m)->If_type);
if (PyModule_AddObject(m, "With", astmodulestate_global->With_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->With_type);
if (PyModule_AddObject(m, "AsyncWith",
astmodulestate_global->AsyncWith_type) < 0) return NULL;
Py_INCREF(astmodulestate(m)->AsyncWith_type);
if (PyModule_AddObject(m, "Raise", astmodulestate_global->Raise_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->Raise_type);
if (PyModule_AddObject(m, "Try", astmodulestate_global->Try_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->Try_type);
if (PyModule_AddObject(m, "Assert", astmodulestate_global->Assert_type) <
0) return NULL;
Py_INCREF(astmodulestate(m)->Assert_type);
if (PyModule_AddObject(m, "Import", astmodulestate_global->Import_type) <
0) return NULL;
Py_INCREF(astmodulestate(m)->Import_type);
if (PyModule_AddObject(m, "ImportFrom",
astmodulestate_global->ImportFrom_type) < 0) return NULL;
Py_INCREF(astmodulestate(m)->ImportFrom_type);
if (PyModule_AddObject(m, "Global", astmodulestate_global->Global_type) <
0) return NULL;
Py_INCREF(astmodulestate(m)->Global_type);
if (PyModule_AddObject(m, "Nonlocal", astmodulestate_global->Nonlocal_type)
< 0) return NULL;
Py_INCREF(astmodulestate(m)->Nonlocal_type);
if (PyModule_AddObject(m, "Expr", astmodulestate_global->Expr_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->Expr_type);
if (PyModule_AddObject(m, "Pass", astmodulestate_global->Pass_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->Pass_type);
if (PyModule_AddObject(m, "Break", astmodulestate_global->Break_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->Break_type);
if (PyModule_AddObject(m, "Continue", astmodulestate_global->Continue_type)
< 0) return NULL;
Py_INCREF(astmodulestate(m)->Continue_type);
if (PyModule_AddObject(m, "expr", astmodulestate_global->expr_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->expr_type);
if (PyModule_AddObject(m, "BoolOp", astmodulestate_global->BoolOp_type) <
0) return NULL;
Py_INCREF(astmodulestate(m)->BoolOp_type);
if (PyModule_AddObject(m, "NamedExpr",
astmodulestate_global->NamedExpr_type) < 0) return NULL;
Py_INCREF(astmodulestate(m)->NamedExpr_type);
if (PyModule_AddObject(m, "BinOp", astmodulestate_global->BinOp_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->BinOp_type);
if (PyModule_AddObject(m, "UnaryOp", astmodulestate_global->UnaryOp_type) <
0) return NULL;
Py_INCREF(astmodulestate(m)->UnaryOp_type);
if (PyModule_AddObject(m, "Lambda", astmodulestate_global->Lambda_type) <
0) return NULL;
Py_INCREF(astmodulestate(m)->Lambda_type);
if (PyModule_AddObject(m, "IfExp", astmodulestate_global->IfExp_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->IfExp_type);
if (PyModule_AddObject(m, "Dict", astmodulestate_global->Dict_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->Dict_type);
if (PyModule_AddObject(m, "Set", astmodulestate_global->Set_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->Set_type);
if (PyModule_AddObject(m, "ListComp", astmodulestate_global->ListComp_type)
< 0) return NULL;
Py_INCREF(astmodulestate(m)->ListComp_type);
if (PyModule_AddObject(m, "SetComp", astmodulestate_global->SetComp_type) <
0) return NULL;
Py_INCREF(astmodulestate(m)->SetComp_type);
if (PyModule_AddObject(m, "DictComp", astmodulestate_global->DictComp_type)
< 0) return NULL;
Py_INCREF(astmodulestate(m)->DictComp_type);
if (PyModule_AddObject(m, "GeneratorExp",
astmodulestate_global->GeneratorExp_type) < 0) return NULL;
Py_INCREF(astmodulestate(m)->GeneratorExp_type);
if (PyModule_AddObject(m, "Await", astmodulestate_global->Await_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->Await_type);
if (PyModule_AddObject(m, "Yield", astmodulestate_global->Yield_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->Yield_type);
if (PyModule_AddObject(m, "YieldFrom",
astmodulestate_global->YieldFrom_type) < 0) return NULL;
Py_INCREF(astmodulestate(m)->YieldFrom_type);
if (PyModule_AddObject(m, "Compare", astmodulestate_global->Compare_type) <
0) return NULL;
Py_INCREF(astmodulestate(m)->Compare_type);
if (PyModule_AddObject(m, "Call", astmodulestate_global->Call_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->Call_type);
if (PyModule_AddObject(m, "FormattedValue",
astmodulestate_global->FormattedValue_type) < 0) return NULL;
Py_INCREF(astmodulestate(m)->FormattedValue_type);
if (PyModule_AddObject(m, "JoinedStr",
astmodulestate_global->JoinedStr_type) < 0) return NULL;
Py_INCREF(astmodulestate(m)->JoinedStr_type);
if (PyModule_AddObject(m, "Constant", astmodulestate_global->Constant_type)
< 0) return NULL;
Py_INCREF(astmodulestate(m)->Constant_type);
if (PyModule_AddObject(m, "Attribute",
astmodulestate_global->Attribute_type) < 0) return NULL;
Py_INCREF(astmodulestate(m)->Attribute_type);
if (PyModule_AddObject(m, "Subscript",
astmodulestate_global->Subscript_type) < 0) return NULL;
Py_INCREF(astmodulestate(m)->Subscript_type);
if (PyModule_AddObject(m, "Starred", astmodulestate_global->Starred_type) <
0) return NULL;
Py_INCREF(astmodulestate(m)->Starred_type);
if (PyModule_AddObject(m, "Name", astmodulestate_global->Name_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->Name_type);
if (PyModule_AddObject(m, "List", astmodulestate_global->List_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->List_type);
if (PyModule_AddObject(m, "Tuple", astmodulestate_global->Tuple_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->Tuple_type);
if (PyModule_AddObject(m, "expr_context",
astmodulestate_global->expr_context_type) < 0) return NULL;
Py_INCREF(astmodulestate(m)->expr_context_type);
if (PyModule_AddObject(m, "Load", astmodulestate_global->Load_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->Load_type);
if (PyModule_AddObject(m, "Store", astmodulestate_global->Store_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->Store_type);
if (PyModule_AddObject(m, "Del", astmodulestate_global->Del_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->Del_type);
if (PyModule_AddObject(m, "AugLoad", astmodulestate_global->AugLoad_type) <
0) return NULL;
Py_INCREF(astmodulestate(m)->AugLoad_type);
if (PyModule_AddObject(m, "AugStore", astmodulestate_global->AugStore_type)
< 0) return NULL;
Py_INCREF(astmodulestate(m)->AugStore_type);
if (PyModule_AddObject(m, "Param", astmodulestate_global->Param_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->Param_type);
if (PyModule_AddObject(m, "slice", astmodulestate_global->slice_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->slice_type);
if (PyModule_AddObject(m, "Slice", astmodulestate_global->Slice_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->Slice_type);
if (PyModule_AddObject(m, "ExtSlice", astmodulestate_global->ExtSlice_type)
< 0) return NULL;
Py_INCREF(astmodulestate(m)->ExtSlice_type);
if (PyModule_AddObject(m, "Index", astmodulestate_global->Index_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->Index_type);
if (PyModule_AddObject(m, "boolop", astmodulestate_global->boolop_type) <
0) return NULL;
Py_INCREF(astmodulestate(m)->boolop_type);
if (PyModule_AddObject(m, "And", astmodulestate_global->And_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->And_type);
if (PyModule_AddObject(m, "Or", astmodulestate_global->Or_type) < 0) return
NULL;
Py_INCREF(astmodulestate(m)->Or_type);
if (PyModule_AddObject(m, "operator", astmodulestate_global->operator_type)
< 0) return NULL;
Py_INCREF(astmodulestate(m)->operator_type);
if (PyModule_AddObject(m, "Add", astmodulestate_global->Add_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->Add_type);
if (PyModule_AddObject(m, "Sub", astmodulestate_global->Sub_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->Sub_type);
if (PyModule_AddObject(m, "Mult", astmodulestate_global->Mult_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->Mult_type);
if (PyModule_AddObject(m, "MatMult", astmodulestate_global->MatMult_type) <
0) return NULL;
Py_INCREF(astmodulestate(m)->MatMult_type);
if (PyModule_AddObject(m, "Div", astmodulestate_global->Div_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->Div_type);
if (PyModule_AddObject(m, "Mod", astmodulestate_global->Mod_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->Mod_type);
if (PyModule_AddObject(m, "Pow", astmodulestate_global->Pow_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->Pow_type);
if (PyModule_AddObject(m, "LShift", astmodulestate_global->LShift_type) <
0) return NULL;
Py_INCREF(astmodulestate(m)->LShift_type);
if (PyModule_AddObject(m, "RShift", astmodulestate_global->RShift_type) <
0) return NULL;
Py_INCREF(astmodulestate(m)->RShift_type);
if (PyModule_AddObject(m, "BitOr", astmodulestate_global->BitOr_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->BitOr_type);
if (PyModule_AddObject(m, "BitXor", astmodulestate_global->BitXor_type) <
0) return NULL;
Py_INCREF(astmodulestate(m)->BitXor_type);
if (PyModule_AddObject(m, "BitAnd", astmodulestate_global->BitAnd_type) <
0) return NULL;
Py_INCREF(astmodulestate(m)->BitAnd_type);
if (PyModule_AddObject(m, "FloorDiv", astmodulestate_global->FloorDiv_type)
< 0) return NULL;
Py_INCREF(astmodulestate(m)->FloorDiv_type);
if (PyModule_AddObject(m, "unaryop", astmodulestate_global->unaryop_type) <
0) return NULL;
Py_INCREF(astmodulestate(m)->unaryop_type);
if (PyModule_AddObject(m, "Invert", astmodulestate_global->Invert_type) <
0) return NULL;
Py_INCREF(astmodulestate(m)->Invert_type);
if (PyModule_AddObject(m, "Not", astmodulestate_global->Not_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->Not_type);
if (PyModule_AddObject(m, "UAdd", astmodulestate_global->UAdd_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->UAdd_type);
if (PyModule_AddObject(m, "USub", astmodulestate_global->USub_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->USub_type);
if (PyModule_AddObject(m, "cmpop", astmodulestate_global->cmpop_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->cmpop_type);
if (PyModule_AddObject(m, "Eq", astmodulestate_global->Eq_type) < 0) return
NULL;
Py_INCREF(astmodulestate(m)->Eq_type);
if (PyModule_AddObject(m, "NotEq", astmodulestate_global->NotEq_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->NotEq_type);
if (PyModule_AddObject(m, "Lt", astmodulestate_global->Lt_type) < 0) return
NULL;
Py_INCREF(astmodulestate(m)->Lt_type);
if (PyModule_AddObject(m, "LtE", astmodulestate_global->LtE_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->LtE_type);
if (PyModule_AddObject(m, "Gt", astmodulestate_global->Gt_type) < 0) return
NULL;
Py_INCREF(astmodulestate(m)->Gt_type);
if (PyModule_AddObject(m, "GtE", astmodulestate_global->GtE_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->GtE_type);
if (PyModule_AddObject(m, "Is", astmodulestate_global->Is_type) < 0) return
NULL;
Py_INCREF(astmodulestate(m)->Is_type);
if (PyModule_AddObject(m, "IsNot", astmodulestate_global->IsNot_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->IsNot_type);
if (PyModule_AddObject(m, "In", astmodulestate_global->In_type) < 0) return
NULL;
Py_INCREF(astmodulestate(m)->In_type);
if (PyModule_AddObject(m, "NotIn", astmodulestate_global->NotIn_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->NotIn_type);
if (PyModule_AddObject(m, "comprehension",
astmodulestate_global->comprehension_type) < 0) return NULL;
Py_INCREF(astmodulestate(m)->comprehension_type);
if (PyModule_AddObject(m, "excepthandler",
astmodulestate_global->excepthandler_type) < 0) return NULL;
Py_INCREF(astmodulestate(m)->excepthandler_type);
if (PyModule_AddObject(m, "ExceptHandler",
astmodulestate_global->ExceptHandler_type) < 0) return NULL;
Py_INCREF(astmodulestate(m)->ExceptHandler_type);
if (PyModule_AddObject(m, "arguments",
astmodulestate_global->arguments_type) < 0) return NULL;
Py_INCREF(astmodulestate(m)->arguments_type);
if (PyModule_AddObject(m, "arg", astmodulestate_global->arg_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->arg_type);
if (PyModule_AddObject(m, "keyword", astmodulestate_global->keyword_type) <
0) return NULL;
Py_INCREF(astmodulestate(m)->keyword_type);
if (PyModule_AddObject(m, "alias", astmodulestate_global->alias_type) < 0)
return NULL;
Py_INCREF(astmodulestate(m)->alias_type);
if (PyModule_AddObject(m, "withitem", astmodulestate_global->withitem_type)
< 0) return NULL;
Py_INCREF(astmodulestate(m)->withitem_type);
if (PyModule_AddObject(m, "type_ignore",
astmodulestate_global->type_ignore_type) < 0) return NULL;
Py_INCREF(astmodulestate(m)->type_ignore_type);
if (PyModule_AddObject(m, "TypeIgnore",
astmodulestate_global->TypeIgnore_type) < 0) return NULL;
Py_INCREF(astmodulestate(m)->TypeIgnore_type);
return m;
}
PyObject* PyAST_mod2obj(mod_ty t)
{
if (!init_types())
return NULL;
return ast2obj_mod(t);
}
/* mode is 0 for "exec", 1 for "eval" and 2 for "single" input */
mod_ty PyAST_obj2mod(PyObject* ast, PyArena* arena, int mode)
{
PyObject *req_type[3];
const char * const req_name[] = {"Module", "Expression", "Interactive"};
int isinstance;
if (PySys_Audit("compile", "OO", ast, Py_None) < 0) {
return NULL;
}
req_type[0] = astmodulestate_global->Module_type;
req_type[1] = astmodulestate_global->Expression_type;
req_type[2] = astmodulestate_global->Interactive_type;
assert(0 <= mode && mode <= 2);
if (!init_types())
return NULL;
isinstance = PyObject_IsInstance(ast, req_type[mode]);
if (isinstance == -1)
return NULL;
if (!isinstance) {
PyErr_Format(PyExc_TypeError, "expected %s node, got %.400s",
req_name[mode], _PyType_Name(Py_TYPE(ast)));
return NULL;
}
mod_ty res = NULL;
if (obj2ast_mod(ast, &res, arena) != 0)
return NULL;
else
return res;
}
int PyAST_Check(PyObject* obj)
{
if (!init_types())
return -1;
return PyObject_IsInstance(obj, astmodulestate_global->AST_type);
}