mirror of
https://github.com/python/cpython.git
synced 2024-12-18 14:24:33 +08:00
10461 lines
350 KiB
C
Generated
10461 lines
350 KiB
C
Generated
/* 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 *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 *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 *__doc__;
|
|
PyObject *__module__;
|
|
PyObject *_attributes;
|
|
PyObject *_fields;
|
|
PyObject *alias_type;
|
|
PyObject *annotation;
|
|
PyObject *arg;
|
|
PyObject *arg_type;
|
|
PyObject *args;
|
|
PyObject *argtypes;
|
|
PyObject *arguments_type;
|
|
PyObject *asname;
|
|
PyObject *ast;
|
|
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)->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)->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)->__doc__);
|
|
Py_CLEAR(astmodulestate(module)->__module__);
|
|
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)->ast);
|
|
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)->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)->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)->__doc__);
|
|
Py_VISIT(astmodulestate(module)->__module__);
|
|
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)->ast);
|
|
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->__doc__ = PyUnicode_InternFromString("__doc__")) == NULL) return 0;
|
|
if ((state->__module__ = PyUnicode_InternFromString("__module__")) == 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->ast = PyUnicode_InternFromString("ast")) == 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_attributes[] = {
|
|
"lineno",
|
|
"col_offset",
|
|
"end_lineno",
|
|
"end_col_offset",
|
|
};
|
|
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, const char *doc)
|
|
{
|
|
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){OOOOOs}",
|
|
type, base,
|
|
astmodulestate_global->_fields, fnames,
|
|
astmodulestate_global->__module__,
|
|
astmodulestate_global->ast,
|
|
astmodulestate_global->__doc__, doc);
|
|
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,
|
|
"mod = Module(stmt* body, type_ignore* type_ignores)\n"
|
|
" | Interactive(stmt* body)\n"
|
|
" | Expression(expr body)\n"
|
|
" | FunctionType(expr* argtypes, expr returns)");
|
|
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,
|
|
"Module(stmt* body, type_ignore* type_ignores)");
|
|
if (!state->Module_type) return 0;
|
|
state->Interactive_type = make_type("Interactive", state->mod_type,
|
|
Interactive_fields, 1,
|
|
"Interactive(stmt* body)");
|
|
if (!state->Interactive_type) return 0;
|
|
state->Expression_type = make_type("Expression", state->mod_type,
|
|
Expression_fields, 1,
|
|
"Expression(expr body)");
|
|
if (!state->Expression_type) return 0;
|
|
state->FunctionType_type = make_type("FunctionType", state->mod_type,
|
|
FunctionType_fields, 2,
|
|
"FunctionType(expr* argtypes, expr returns)");
|
|
if (!state->FunctionType_type) return 0;
|
|
state->stmt_type = make_type("stmt", state->AST_type, NULL, 0,
|
|
"stmt = FunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)\n"
|
|
" | AsyncFunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)\n"
|
|
" | ClassDef(identifier name, expr* bases, keyword* keywords, stmt* body, expr* decorator_list)\n"
|
|
" | Return(expr? value)\n"
|
|
" | Delete(expr* targets)\n"
|
|
" | Assign(expr* targets, expr value, string? type_comment)\n"
|
|
" | AugAssign(expr target, operator op, expr value)\n"
|
|
" | AnnAssign(expr target, expr annotation, expr? value, int simple)\n"
|
|
" | For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)\n"
|
|
" | AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)\n"
|
|
" | While(expr test, stmt* body, stmt* orelse)\n"
|
|
" | If(expr test, stmt* body, stmt* orelse)\n"
|
|
" | With(withitem* items, stmt* body, string? type_comment)\n"
|
|
" | AsyncWith(withitem* items, stmt* body, string? type_comment)\n"
|
|
" | Raise(expr? exc, expr? cause)\n"
|
|
" | Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)\n"
|
|
" | Assert(expr test, expr? msg)\n"
|
|
" | Import(alias* names)\n"
|
|
" | ImportFrom(identifier? module, alias* names, int? level)\n"
|
|
" | Global(identifier* names)\n"
|
|
" | Nonlocal(identifier* names)\n"
|
|
" | Expr(expr value)\n"
|
|
" | Pass\n"
|
|
" | Break\n"
|
|
" | Continue");
|
|
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,
|
|
"FunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)");
|
|
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,
|
|
"AsyncFunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)");
|
|
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,
|
|
"ClassDef(identifier name, expr* bases, keyword* keywords, stmt* body, expr* decorator_list)");
|
|
if (!state->ClassDef_type) return 0;
|
|
state->Return_type = make_type("Return", state->stmt_type, Return_fields, 1,
|
|
"Return(expr? value)");
|
|
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,
|
|
"Delete(expr* targets)");
|
|
if (!state->Delete_type) return 0;
|
|
state->Assign_type = make_type("Assign", state->stmt_type, Assign_fields, 3,
|
|
"Assign(expr* targets, expr value, string? type_comment)");
|
|
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,
|
|
"AugAssign(expr target, operator op, expr value)");
|
|
if (!state->AugAssign_type) return 0;
|
|
state->AnnAssign_type = make_type("AnnAssign", state->stmt_type,
|
|
AnnAssign_fields, 4,
|
|
"AnnAssign(expr target, expr annotation, expr? value, int simple)");
|
|
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,
|
|
"For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)");
|
|
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,
|
|
"AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)");
|
|
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,
|
|
"While(expr test, stmt* body, stmt* orelse)");
|
|
if (!state->While_type) return 0;
|
|
state->If_type = make_type("If", state->stmt_type, If_fields, 3,
|
|
"If(expr test, stmt* body, stmt* orelse)");
|
|
if (!state->If_type) return 0;
|
|
state->With_type = make_type("With", state->stmt_type, With_fields, 3,
|
|
"With(withitem* items, stmt* body, string? type_comment)");
|
|
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,
|
|
"AsyncWith(withitem* items, stmt* body, string? type_comment)");
|
|
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,
|
|
"Raise(expr? exc, expr? cause)");
|
|
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,
|
|
"Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)");
|
|
if (!state->Try_type) return 0;
|
|
state->Assert_type = make_type("Assert", state->stmt_type, Assert_fields, 2,
|
|
"Assert(expr test, expr? msg)");
|
|
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,
|
|
"Import(alias* names)");
|
|
if (!state->Import_type) return 0;
|
|
state->ImportFrom_type = make_type("ImportFrom", state->stmt_type,
|
|
ImportFrom_fields, 3,
|
|
"ImportFrom(identifier? module, alias* names, int? level)");
|
|
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,
|
|
"Global(identifier* names)");
|
|
if (!state->Global_type) return 0;
|
|
state->Nonlocal_type = make_type("Nonlocal", state->stmt_type,
|
|
Nonlocal_fields, 1,
|
|
"Nonlocal(identifier* names)");
|
|
if (!state->Nonlocal_type) return 0;
|
|
state->Expr_type = make_type("Expr", state->stmt_type, Expr_fields, 1,
|
|
"Expr(expr value)");
|
|
if (!state->Expr_type) return 0;
|
|
state->Pass_type = make_type("Pass", state->stmt_type, NULL, 0,
|
|
"Pass");
|
|
if (!state->Pass_type) return 0;
|
|
state->Break_type = make_type("Break", state->stmt_type, NULL, 0,
|
|
"Break");
|
|
if (!state->Break_type) return 0;
|
|
state->Continue_type = make_type("Continue", state->stmt_type, NULL, 0,
|
|
"Continue");
|
|
if (!state->Continue_type) return 0;
|
|
state->expr_type = make_type("expr", state->AST_type, NULL, 0,
|
|
"expr = BoolOp(boolop op, expr* values)\n"
|
|
" | NamedExpr(expr target, expr value)\n"
|
|
" | BinOp(expr left, operator op, expr right)\n"
|
|
" | UnaryOp(unaryop op, expr operand)\n"
|
|
" | Lambda(arguments args, expr body)\n"
|
|
" | IfExp(expr test, expr body, expr orelse)\n"
|
|
" | Dict(expr* keys, expr* values)\n"
|
|
" | Set(expr* elts)\n"
|
|
" | ListComp(expr elt, comprehension* generators)\n"
|
|
" | SetComp(expr elt, comprehension* generators)\n"
|
|
" | DictComp(expr key, expr value, comprehension* generators)\n"
|
|
" | GeneratorExp(expr elt, comprehension* generators)\n"
|
|
" | Await(expr value)\n"
|
|
" | Yield(expr? value)\n"
|
|
" | YieldFrom(expr value)\n"
|
|
" | Compare(expr left, cmpop* ops, expr* comparators)\n"
|
|
" | Call(expr func, expr* args, keyword* keywords)\n"
|
|
" | FormattedValue(expr value, int? conversion, expr? format_spec)\n"
|
|
" | JoinedStr(expr* values)\n"
|
|
" | Constant(constant value, string? kind)\n"
|
|
" | Attribute(expr value, identifier attr, expr_context ctx)\n"
|
|
" | Subscript(expr value, expr slice, expr_context ctx)\n"
|
|
" | Starred(expr value, expr_context ctx)\n"
|
|
" | Name(identifier id, expr_context ctx)\n"
|
|
" | List(expr* elts, expr_context ctx)\n"
|
|
" | Tuple(expr* elts, expr_context ctx)\n"
|
|
" | Slice(expr? lower, expr? upper, expr? step)");
|
|
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,
|
|
"BoolOp(boolop op, expr* values)");
|
|
if (!state->BoolOp_type) return 0;
|
|
state->NamedExpr_type = make_type("NamedExpr", state->expr_type,
|
|
NamedExpr_fields, 2,
|
|
"NamedExpr(expr target, expr value)");
|
|
if (!state->NamedExpr_type) return 0;
|
|
state->BinOp_type = make_type("BinOp", state->expr_type, BinOp_fields, 3,
|
|
"BinOp(expr left, operator op, expr right)");
|
|
if (!state->BinOp_type) return 0;
|
|
state->UnaryOp_type = make_type("UnaryOp", state->expr_type,
|
|
UnaryOp_fields, 2,
|
|
"UnaryOp(unaryop op, expr operand)");
|
|
if (!state->UnaryOp_type) return 0;
|
|
state->Lambda_type = make_type("Lambda", state->expr_type, Lambda_fields, 2,
|
|
"Lambda(arguments args, expr body)");
|
|
if (!state->Lambda_type) return 0;
|
|
state->IfExp_type = make_type("IfExp", state->expr_type, IfExp_fields, 3,
|
|
"IfExp(expr test, expr body, expr orelse)");
|
|
if (!state->IfExp_type) return 0;
|
|
state->Dict_type = make_type("Dict", state->expr_type, Dict_fields, 2,
|
|
"Dict(expr* keys, expr* values)");
|
|
if (!state->Dict_type) return 0;
|
|
state->Set_type = make_type("Set", state->expr_type, Set_fields, 1,
|
|
"Set(expr* elts)");
|
|
if (!state->Set_type) return 0;
|
|
state->ListComp_type = make_type("ListComp", state->expr_type,
|
|
ListComp_fields, 2,
|
|
"ListComp(expr elt, comprehension* generators)");
|
|
if (!state->ListComp_type) return 0;
|
|
state->SetComp_type = make_type("SetComp", state->expr_type,
|
|
SetComp_fields, 2,
|
|
"SetComp(expr elt, comprehension* generators)");
|
|
if (!state->SetComp_type) return 0;
|
|
state->DictComp_type = make_type("DictComp", state->expr_type,
|
|
DictComp_fields, 3,
|
|
"DictComp(expr key, expr value, comprehension* generators)");
|
|
if (!state->DictComp_type) return 0;
|
|
state->GeneratorExp_type = make_type("GeneratorExp", state->expr_type,
|
|
GeneratorExp_fields, 2,
|
|
"GeneratorExp(expr elt, comprehension* generators)");
|
|
if (!state->GeneratorExp_type) return 0;
|
|
state->Await_type = make_type("Await", state->expr_type, Await_fields, 1,
|
|
"Await(expr value)");
|
|
if (!state->Await_type) return 0;
|
|
state->Yield_type = make_type("Yield", state->expr_type, Yield_fields, 1,
|
|
"Yield(expr? value)");
|
|
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,
|
|
"YieldFrom(expr value)");
|
|
if (!state->YieldFrom_type) return 0;
|
|
state->Compare_type = make_type("Compare", state->expr_type,
|
|
Compare_fields, 3,
|
|
"Compare(expr left, cmpop* ops, expr* comparators)");
|
|
if (!state->Compare_type) return 0;
|
|
state->Call_type = make_type("Call", state->expr_type, Call_fields, 3,
|
|
"Call(expr func, expr* args, keyword* keywords)");
|
|
if (!state->Call_type) return 0;
|
|
state->FormattedValue_type = make_type("FormattedValue", state->expr_type,
|
|
FormattedValue_fields, 3,
|
|
"FormattedValue(expr value, int? conversion, expr? format_spec)");
|
|
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,
|
|
"JoinedStr(expr* values)");
|
|
if (!state->JoinedStr_type) return 0;
|
|
state->Constant_type = make_type("Constant", state->expr_type,
|
|
Constant_fields, 2,
|
|
"Constant(constant value, string? kind)");
|
|
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,
|
|
"Attribute(expr value, identifier attr, expr_context ctx)");
|
|
if (!state->Attribute_type) return 0;
|
|
state->Subscript_type = make_type("Subscript", state->expr_type,
|
|
Subscript_fields, 3,
|
|
"Subscript(expr value, expr slice, expr_context ctx)");
|
|
if (!state->Subscript_type) return 0;
|
|
state->Starred_type = make_type("Starred", state->expr_type,
|
|
Starred_fields, 2,
|
|
"Starred(expr value, expr_context ctx)");
|
|
if (!state->Starred_type) return 0;
|
|
state->Name_type = make_type("Name", state->expr_type, Name_fields, 2,
|
|
"Name(identifier id, expr_context ctx)");
|
|
if (!state->Name_type) return 0;
|
|
state->List_type = make_type("List", state->expr_type, List_fields, 2,
|
|
"List(expr* elts, expr_context ctx)");
|
|
if (!state->List_type) return 0;
|
|
state->Tuple_type = make_type("Tuple", state->expr_type, Tuple_fields, 2,
|
|
"Tuple(expr* elts, expr_context ctx)");
|
|
if (!state->Tuple_type) return 0;
|
|
state->Slice_type = make_type("Slice", state->expr_type, Slice_fields, 3,
|
|
"Slice(expr? lower, expr? upper, expr? step)");
|
|
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,
|
|
"expr_context = Load | Store | Del");
|
|
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,
|
|
"Load");
|
|
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,
|
|
"Store");
|
|
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,
|
|
"Del");
|
|
if (!state->Del_type) return 0;
|
|
state->Del_singleton = PyType_GenericNew((PyTypeObject *)state->Del_type,
|
|
NULL, NULL);
|
|
if (!state->Del_singleton) return 0;
|
|
state->boolop_type = make_type("boolop", state->AST_type, NULL, 0,
|
|
"boolop = And | Or");
|
|
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,
|
|
"And");
|
|
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,
|
|
"Or");
|
|
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,
|
|
"operator = Add | Sub | Mult | MatMult | Div | Mod | Pow | LShift | RShift | BitOr | BitXor | BitAnd | FloorDiv");
|
|
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,
|
|
"Add");
|
|
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,
|
|
"Sub");
|
|
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,
|
|
"Mult");
|
|
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,
|
|
"MatMult");
|
|
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,
|
|
"Div");
|
|
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,
|
|
"Mod");
|
|
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,
|
|
"Pow");
|
|
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,
|
|
"LShift");
|
|
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,
|
|
"RShift");
|
|
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,
|
|
"BitOr");
|
|
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,
|
|
"BitXor");
|
|
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,
|
|
"BitAnd");
|
|
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,
|
|
"FloorDiv");
|
|
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,
|
|
"unaryop = Invert | Not | UAdd | USub");
|
|
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,
|
|
"Invert");
|
|
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,
|
|
"Not");
|
|
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,
|
|
"UAdd");
|
|
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,
|
|
"USub");
|
|
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,
|
|
"cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn");
|
|
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,
|
|
"Eq");
|
|
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,
|
|
"NotEq");
|
|
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,
|
|
"Lt");
|
|
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,
|
|
"LtE");
|
|
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,
|
|
"Gt");
|
|
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,
|
|
"GtE");
|
|
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,
|
|
"Is");
|
|
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,
|
|
"IsNot");
|
|
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,
|
|
"In");
|
|
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,
|
|
"NotIn");
|
|
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,
|
|
"comprehension(expr target, expr iter, expr* ifs, int is_async)");
|
|
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,
|
|
"excepthandler = ExceptHandler(expr? type, identifier? name, stmt* body)");
|
|
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,
|
|
"ExceptHandler(expr? type, identifier? name, stmt* body)");
|
|
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,
|
|
"arguments(arg* posonlyargs, arg* args, arg? vararg, arg* kwonlyargs, expr* kw_defaults, arg? kwarg, expr* defaults)");
|
|
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,
|
|
"arg(identifier arg, expr? annotation, string? type_comment)");
|
|
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,
|
|
"keyword(identifier? arg, expr value)");
|
|
if (!state->keyword_type) return 0;
|
|
if (!add_attributes(state->keyword_type, keyword_attributes, 4)) return 0;
|
|
if (PyObject_SetAttr(state->keyword_type, state->arg, Py_None) == -1)
|
|
return 0;
|
|
if (PyObject_SetAttr(state->keyword_type, state->end_lineno, Py_None) == -1)
|
|
return 0;
|
|
if (PyObject_SetAttr(state->keyword_type, state->end_col_offset, Py_None)
|
|
== -1)
|
|
return 0;
|
|
state->alias_type = make_type("alias", state->AST_type, alias_fields, 2,
|
|
"alias(identifier name, identifier? asname)");
|
|
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,
|
|
"withitem(expr context_expr, expr? optional_vars)");
|
|
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,
|
|
"type_ignore = TypeIgnore(int lineno, string tag)");
|
|
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,
|
|
"TypeIgnore(int lineno, string tag)");
|
|
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, int lineno, int col_offset, int
|
|
end_lineno, int end_col_offset, 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;
|
|
p->lineno = lineno;
|
|
p->col_offset = col_offset;
|
|
p->end_lineno = end_lineno;
|
|
p->end_col_offset = end_col_offset;
|
|
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;
|
|
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);
|
|
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_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;
|
|
}
|
|
|
|
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;
|
|
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 || 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);
|
|
}
|
|
if (_PyObject_LookupAttr(obj, astmodulestate_global->lineno, &tmp) < 0) {
|
|
return 1;
|
|
}
|
|
if (tmp == NULL) {
|
|
PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from keyword");
|
|
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 keyword");
|
|
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 = keyword(arg, value, lineno, col_offset, end_lineno, end_col_offset,
|
|
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, "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);
|
|
}
|
|
|
|
|