Staging
v0.5.1
v0.5.1
https://github.com/python/cpython
Revision 64838ce7172c7a92183b39b22504b433a33a884d authored by bobince on 11 March 2020, 23:39:02 UTC, committed by GitHub on 11 March 2020, 23:39:02 UTC
The 32-bit (49-day) TickCount relied on in EnterNonRecursiveMutex can overflow in the gap between the 'target' time and the 'now' time WaitForSingleObjectEx returns, causing the loop to think it needs to wait another 49 days. This is most likely to happen when the machine is hibernated during WaitForSingleObjectEx. This makes acquiring a lock/event/etc from the _thread or threading module appear to never timeout. Replace with GetTickCount64 - this is OK now Python no longer supports XP which lacks it, and is in use for time.monotonic(). Co-authored-by: And Clover <and.clover@bromium.com>
1 parent 894adc1
Tip revision: 64838ce7172c7a92183b39b22504b433a33a884d authored by bobince on 11 March 2020, 23:39:02 UTC
bpo-39847: EnterNonRecursiveMutex() uses GetTickCount64() (GH-18780)
bpo-39847: EnterNonRecursiveMutex() uses GetTickCount64() (GH-18780)
Tip revision: 64838ce
Python-ast.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 *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 *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 *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 *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 *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)->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)->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)->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)->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)->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)->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)->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)->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)->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)->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->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 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 const char * const Slice_fields[]={
"lower",
"upper",
"step",
};
static PyObject* ast2obj_expr_context(expr_context_ty);
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, 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->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;
if (PyObject_SetAttr(state->stmt_type, state->end_lineno, Py_None) == -1)
return 0;
if (PyObject_SetAttr(state->stmt_type, state->end_col_offset, Py_None) ==
-1)
return 0;
state->FunctionDef_type = make_type("FunctionDef", state->stmt_type,
FunctionDef_fields, 6);
if (!state->FunctionDef_type) return 0;
if (PyObject_SetAttr(state->FunctionDef_type, state->returns, Py_None) ==
-1)
return 0;
if (PyObject_SetAttr(state->FunctionDef_type, state->type_comment, Py_None)
== -1)
return 0;
state->AsyncFunctionDef_type = make_type("AsyncFunctionDef",
state->stmt_type,
AsyncFunctionDef_fields, 6);
if (!state->AsyncFunctionDef_type) return 0;
if (PyObject_SetAttr(state->AsyncFunctionDef_type, state->returns, Py_None)
== -1)
return 0;
if (PyObject_SetAttr(state->AsyncFunctionDef_type, state->type_comment,
Py_None) == -1)
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;
if (PyObject_SetAttr(state->Return_type, state->value, Py_None) == -1)
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;
if (PyObject_SetAttr(state->Assign_type, state->type_comment, Py_None) ==
-1)
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;
if (PyObject_SetAttr(state->AnnAssign_type, state->value, Py_None) == -1)
return 0;
state->For_type = make_type("For", state->stmt_type, For_fields, 5);
if (!state->For_type) return 0;
if (PyObject_SetAttr(state->For_type, state->type_comment, Py_None) == -1)
return 0;
state->AsyncFor_type = make_type("AsyncFor", state->stmt_type,
AsyncFor_fields, 5);
if (!state->AsyncFor_type) return 0;
if (PyObject_SetAttr(state->AsyncFor_type, state->type_comment, Py_None) ==
-1)
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;
if (PyObject_SetAttr(state->With_type, state->type_comment, Py_None) == -1)
return 0;
state->AsyncWith_type = make_type("AsyncWith", state->stmt_type,
AsyncWith_fields, 3);
if (!state->AsyncWith_type) return 0;
if (PyObject_SetAttr(state->AsyncWith_type, state->type_comment, Py_None)
== -1)
return 0;
state->Raise_type = make_type("Raise", state->stmt_type, Raise_fields, 2);
if (!state->Raise_type) return 0;
if (PyObject_SetAttr(state->Raise_type, state->exc, Py_None) == -1)
return 0;
if (PyObject_SetAttr(state->Raise_type, state->cause, Py_None) == -1)
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;
if (PyObject_SetAttr(state->Assert_type, state->msg, Py_None) == -1)
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;
if (PyObject_SetAttr(state->ImportFrom_type, state->module, Py_None) == -1)
return 0;
if (PyObject_SetAttr(state->ImportFrom_type, state->level, Py_None) == -1)
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;
if (PyObject_SetAttr(state->expr_type, state->end_lineno, Py_None) == -1)
return 0;
if (PyObject_SetAttr(state->expr_type, state->end_col_offset, Py_None) ==
-1)
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;
if (PyObject_SetAttr(state->Yield_type, state->value, Py_None) == -1)
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;
if (PyObject_SetAttr(state->FormattedValue_type, state->conversion,
Py_None) == -1)
return 0;
if (PyObject_SetAttr(state->FormattedValue_type, state->format_spec,
Py_None) == -1)
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;
if (PyObject_SetAttr(state->Constant_type, state->kind, Py_None) == -1)
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->Slice_type = make_type("Slice", state->expr_type, Slice_fields, 3);
if (!state->Slice_type) return 0;
if (PyObject_SetAttr(state->Slice_type, state->lower, Py_None) == -1)
return 0;
if (PyObject_SetAttr(state->Slice_type, state->upper, Py_None) == -1)
return 0;
if (PyObject_SetAttr(state->Slice_type, state->step, Py_None) == -1)
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->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;
if (PyObject_SetAttr(state->excepthandler_type, state->end_lineno, Py_None)
== -1)
return 0;
if (PyObject_SetAttr(state->excepthandler_type, state->end_col_offset,
Py_None) == -1)
return 0;
state->ExceptHandler_type = make_type("ExceptHandler",
state->excepthandler_type,
ExceptHandler_fields, 3);
if (!state->ExceptHandler_type) return 0;
if (PyObject_SetAttr(state->ExceptHandler_type, state->type, Py_None) == -1)
return 0;
if (PyObject_SetAttr(state->ExceptHandler_type, state->name, Py_None) == -1)
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;
if (PyObject_SetAttr(state->arguments_type, state->vararg, Py_None) == -1)
return 0;
if (PyObject_SetAttr(state->arguments_type, state->kwarg, Py_None) == -1)
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;
if (PyObject_SetAttr(state->arg_type, state->annotation, Py_None) == -1)
return 0;
if (PyObject_SetAttr(state->arg_type, state->type_comment, Py_None) == -1)
return 0;
if (PyObject_SetAttr(state->arg_type, state->end_lineno, Py_None) == -1)
return 0;
if (PyObject_SetAttr(state->arg_type, state->end_col_offset, Py_None) == -1)
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;
if (PyObject_SetAttr(state->keyword_type, state->arg, Py_None) == -1)
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;
if (PyObject_SetAttr(state->alias_type, state->asname, Py_None) == -1)
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;
if (PyObject_SetAttr(state->withitem_type, state->optional_vars, Py_None)
== -1)
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_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;
}
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, expr_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;
}
expr_ty
Slice(expr_ty lower, expr_ty upper, expr_ty step, 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 = Slice_kind;
p->v.Slice.lower = lower;
p->v.Slice.upper = upper;
p->v.Slice.step = step;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
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;
}
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_expr(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;
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;
}
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_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;
}
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;
expr_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_expr(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;
}
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, 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_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;
if (PyModule_AddObject(m, "AST", astmodulestate_global->AST_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->AST_type);
if (PyModule_AddIntMacro(m, PyCF_ALLOW_TOP_LEVEL_AWAIT) < 0) {
goto error;
}
if (PyModule_AddIntMacro(m, PyCF_ONLY_AST) < 0) {
goto error;
}
if (PyModule_AddIntMacro(m, PyCF_TYPE_COMMENTS) < 0) {
goto error;
}
if (PyModule_AddObject(m, "mod", astmodulestate_global->mod_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->mod_type);
if (PyModule_AddObject(m, "Module", astmodulestate_global->Module_type) <
0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Module_type);
if (PyModule_AddObject(m, "Interactive",
astmodulestate_global->Interactive_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Interactive_type);
if (PyModule_AddObject(m, "Expression",
astmodulestate_global->Expression_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Expression_type);
if (PyModule_AddObject(m, "FunctionType",
astmodulestate_global->FunctionType_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->FunctionType_type);
if (PyModule_AddObject(m, "stmt", astmodulestate_global->stmt_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->stmt_type);
if (PyModule_AddObject(m, "FunctionDef",
astmodulestate_global->FunctionDef_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->FunctionDef_type);
if (PyModule_AddObject(m, "AsyncFunctionDef",
astmodulestate_global->AsyncFunctionDef_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->AsyncFunctionDef_type);
if (PyModule_AddObject(m, "ClassDef", astmodulestate_global->ClassDef_type)
< 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->ClassDef_type);
if (PyModule_AddObject(m, "Return", astmodulestate_global->Return_type) <
0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Return_type);
if (PyModule_AddObject(m, "Delete", astmodulestate_global->Delete_type) <
0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Delete_type);
if (PyModule_AddObject(m, "Assign", astmodulestate_global->Assign_type) <
0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Assign_type);
if (PyModule_AddObject(m, "AugAssign",
astmodulestate_global->AugAssign_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->AugAssign_type);
if (PyModule_AddObject(m, "AnnAssign",
astmodulestate_global->AnnAssign_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->AnnAssign_type);
if (PyModule_AddObject(m, "For", astmodulestate_global->For_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->For_type);
if (PyModule_AddObject(m, "AsyncFor", astmodulestate_global->AsyncFor_type)
< 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->AsyncFor_type);
if (PyModule_AddObject(m, "While", astmodulestate_global->While_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->While_type);
if (PyModule_AddObject(m, "If", astmodulestate_global->If_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->If_type);
if (PyModule_AddObject(m, "With", astmodulestate_global->With_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->With_type);
if (PyModule_AddObject(m, "AsyncWith",
astmodulestate_global->AsyncWith_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->AsyncWith_type);
if (PyModule_AddObject(m, "Raise", astmodulestate_global->Raise_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Raise_type);
if (PyModule_AddObject(m, "Try", astmodulestate_global->Try_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Try_type);
if (PyModule_AddObject(m, "Assert", astmodulestate_global->Assert_type) <
0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Assert_type);
if (PyModule_AddObject(m, "Import", astmodulestate_global->Import_type) <
0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Import_type);
if (PyModule_AddObject(m, "ImportFrom",
astmodulestate_global->ImportFrom_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->ImportFrom_type);
if (PyModule_AddObject(m, "Global", astmodulestate_global->Global_type) <
0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Global_type);
if (PyModule_AddObject(m, "Nonlocal", astmodulestate_global->Nonlocal_type)
< 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Nonlocal_type);
if (PyModule_AddObject(m, "Expr", astmodulestate_global->Expr_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Expr_type);
if (PyModule_AddObject(m, "Pass", astmodulestate_global->Pass_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Pass_type);
if (PyModule_AddObject(m, "Break", astmodulestate_global->Break_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Break_type);
if (PyModule_AddObject(m, "Continue", astmodulestate_global->Continue_type)
< 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Continue_type);
if (PyModule_AddObject(m, "expr", astmodulestate_global->expr_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->expr_type);
if (PyModule_AddObject(m, "BoolOp", astmodulestate_global->BoolOp_type) <
0) {
goto error;
}
Py_INCREF(astmodulestate(m)->BoolOp_type);
if (PyModule_AddObject(m, "NamedExpr",
astmodulestate_global->NamedExpr_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->NamedExpr_type);
if (PyModule_AddObject(m, "BinOp", astmodulestate_global->BinOp_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->BinOp_type);
if (PyModule_AddObject(m, "UnaryOp", astmodulestate_global->UnaryOp_type) <
0) {
goto error;
}
Py_INCREF(astmodulestate(m)->UnaryOp_type);
if (PyModule_AddObject(m, "Lambda", astmodulestate_global->Lambda_type) <
0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Lambda_type);
if (PyModule_AddObject(m, "IfExp", astmodulestate_global->IfExp_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->IfExp_type);
if (PyModule_AddObject(m, "Dict", astmodulestate_global->Dict_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Dict_type);
if (PyModule_AddObject(m, "Set", astmodulestate_global->Set_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Set_type);
if (PyModule_AddObject(m, "ListComp", astmodulestate_global->ListComp_type)
< 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->ListComp_type);
if (PyModule_AddObject(m, "SetComp", astmodulestate_global->SetComp_type) <
0) {
goto error;
}
Py_INCREF(astmodulestate(m)->SetComp_type);
if (PyModule_AddObject(m, "DictComp", astmodulestate_global->DictComp_type)
< 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->DictComp_type);
if (PyModule_AddObject(m, "GeneratorExp",
astmodulestate_global->GeneratorExp_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->GeneratorExp_type);
if (PyModule_AddObject(m, "Await", astmodulestate_global->Await_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Await_type);
if (PyModule_AddObject(m, "Yield", astmodulestate_global->Yield_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Yield_type);
if (PyModule_AddObject(m, "YieldFrom",
astmodulestate_global->YieldFrom_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->YieldFrom_type);
if (PyModule_AddObject(m, "Compare", astmodulestate_global->Compare_type) <
0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Compare_type);
if (PyModule_AddObject(m, "Call", astmodulestate_global->Call_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Call_type);
if (PyModule_AddObject(m, "FormattedValue",
astmodulestate_global->FormattedValue_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->FormattedValue_type);
if (PyModule_AddObject(m, "JoinedStr",
astmodulestate_global->JoinedStr_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->JoinedStr_type);
if (PyModule_AddObject(m, "Constant", astmodulestate_global->Constant_type)
< 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Constant_type);
if (PyModule_AddObject(m, "Attribute",
astmodulestate_global->Attribute_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Attribute_type);
if (PyModule_AddObject(m, "Subscript",
astmodulestate_global->Subscript_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Subscript_type);
if (PyModule_AddObject(m, "Starred", astmodulestate_global->Starred_type) <
0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Starred_type);
if (PyModule_AddObject(m, "Name", astmodulestate_global->Name_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Name_type);
if (PyModule_AddObject(m, "List", astmodulestate_global->List_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->List_type);
if (PyModule_AddObject(m, "Tuple", astmodulestate_global->Tuple_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Tuple_type);
if (PyModule_AddObject(m, "Slice", astmodulestate_global->Slice_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Slice_type);
if (PyModule_AddObject(m, "expr_context",
astmodulestate_global->expr_context_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->expr_context_type);
if (PyModule_AddObject(m, "Load", astmodulestate_global->Load_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Load_type);
if (PyModule_AddObject(m, "Store", astmodulestate_global->Store_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Store_type);
if (PyModule_AddObject(m, "Del", astmodulestate_global->Del_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Del_type);
if (PyModule_AddObject(m, "AugLoad", astmodulestate_global->AugLoad_type) <
0) {
goto error;
}
Py_INCREF(astmodulestate(m)->AugLoad_type);
if (PyModule_AddObject(m, "AugStore", astmodulestate_global->AugStore_type)
< 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->AugStore_type);
if (PyModule_AddObject(m, "Param", astmodulestate_global->Param_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Param_type);
if (PyModule_AddObject(m, "boolop", astmodulestate_global->boolop_type) <
0) {
goto error;
}
Py_INCREF(astmodulestate(m)->boolop_type);
if (PyModule_AddObject(m, "And", astmodulestate_global->And_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->And_type);
if (PyModule_AddObject(m, "Or", astmodulestate_global->Or_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Or_type);
if (PyModule_AddObject(m, "operator", astmodulestate_global->operator_type)
< 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->operator_type);
if (PyModule_AddObject(m, "Add", astmodulestate_global->Add_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Add_type);
if (PyModule_AddObject(m, "Sub", astmodulestate_global->Sub_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Sub_type);
if (PyModule_AddObject(m, "Mult", astmodulestate_global->Mult_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Mult_type);
if (PyModule_AddObject(m, "MatMult", astmodulestate_global->MatMult_type) <
0) {
goto error;
}
Py_INCREF(astmodulestate(m)->MatMult_type);
if (PyModule_AddObject(m, "Div", astmodulestate_global->Div_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Div_type);
if (PyModule_AddObject(m, "Mod", astmodulestate_global->Mod_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Mod_type);
if (PyModule_AddObject(m, "Pow", astmodulestate_global->Pow_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Pow_type);
if (PyModule_AddObject(m, "LShift", astmodulestate_global->LShift_type) <
0) {
goto error;
}
Py_INCREF(astmodulestate(m)->LShift_type);
if (PyModule_AddObject(m, "RShift", astmodulestate_global->RShift_type) <
0) {
goto error;
}
Py_INCREF(astmodulestate(m)->RShift_type);
if (PyModule_AddObject(m, "BitOr", astmodulestate_global->BitOr_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->BitOr_type);
if (PyModule_AddObject(m, "BitXor", astmodulestate_global->BitXor_type) <
0) {
goto error;
}
Py_INCREF(astmodulestate(m)->BitXor_type);
if (PyModule_AddObject(m, "BitAnd", astmodulestate_global->BitAnd_type) <
0) {
goto error;
}
Py_INCREF(astmodulestate(m)->BitAnd_type);
if (PyModule_AddObject(m, "FloorDiv", astmodulestate_global->FloorDiv_type)
< 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->FloorDiv_type);
if (PyModule_AddObject(m, "unaryop", astmodulestate_global->unaryop_type) <
0) {
goto error;
}
Py_INCREF(astmodulestate(m)->unaryop_type);
if (PyModule_AddObject(m, "Invert", astmodulestate_global->Invert_type) <
0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Invert_type);
if (PyModule_AddObject(m, "Not", astmodulestate_global->Not_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Not_type);
if (PyModule_AddObject(m, "UAdd", astmodulestate_global->UAdd_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->UAdd_type);
if (PyModule_AddObject(m, "USub", astmodulestate_global->USub_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->USub_type);
if (PyModule_AddObject(m, "cmpop", astmodulestate_global->cmpop_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->cmpop_type);
if (PyModule_AddObject(m, "Eq", astmodulestate_global->Eq_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Eq_type);
if (PyModule_AddObject(m, "NotEq", astmodulestate_global->NotEq_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->NotEq_type);
if (PyModule_AddObject(m, "Lt", astmodulestate_global->Lt_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Lt_type);
if (PyModule_AddObject(m, "LtE", astmodulestate_global->LtE_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->LtE_type);
if (PyModule_AddObject(m, "Gt", astmodulestate_global->Gt_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Gt_type);
if (PyModule_AddObject(m, "GtE", astmodulestate_global->GtE_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->GtE_type);
if (PyModule_AddObject(m, "Is", astmodulestate_global->Is_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->Is_type);
if (PyModule_AddObject(m, "IsNot", astmodulestate_global->IsNot_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->IsNot_type);
if (PyModule_AddObject(m, "In", astmodulestate_global->In_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->In_type);
if (PyModule_AddObject(m, "NotIn", astmodulestate_global->NotIn_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->NotIn_type);
if (PyModule_AddObject(m, "comprehension",
astmodulestate_global->comprehension_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->comprehension_type);
if (PyModule_AddObject(m, "excepthandler",
astmodulestate_global->excepthandler_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->excepthandler_type);
if (PyModule_AddObject(m, "ExceptHandler",
astmodulestate_global->ExceptHandler_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->ExceptHandler_type);
if (PyModule_AddObject(m, "arguments",
astmodulestate_global->arguments_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->arguments_type);
if (PyModule_AddObject(m, "arg", astmodulestate_global->arg_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->arg_type);
if (PyModule_AddObject(m, "keyword", astmodulestate_global->keyword_type) <
0) {
goto error;
}
Py_INCREF(astmodulestate(m)->keyword_type);
if (PyModule_AddObject(m, "alias", astmodulestate_global->alias_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->alias_type);
if (PyModule_AddObject(m, "withitem", astmodulestate_global->withitem_type)
< 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->withitem_type);
if (PyModule_AddObject(m, "type_ignore",
astmodulestate_global->type_ignore_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->type_ignore_type);
if (PyModule_AddObject(m, "TypeIgnore",
astmodulestate_global->TypeIgnore_type) < 0) {
goto error;
}
Py_INCREF(astmodulestate(m)->TypeIgnore_type);
return m;
error:
Py_DECREF(m);
return NULL;
}
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);
}
Computing file changes ...
