blob: 2f84cad7749dd885990c91e537c587a338106d66 [file] [log] [blame]
// File automatically generated by Parser/asdl_c.py.
#include "Python.h"
#include "pycore_ast.h"
#include "pycore_ast_state.h" // struct ast_state
#include "pycore_interp.h" // _PyInterpreterState.ast
#include "pycore_pystate.h" // _PyInterpreterState_GET()
#include "structmember.h"
#include <stddef.h>
// Forward declaration
static int init_types(struct ast_state *state);
static struct ast_state*
get_ast_state(void)
{
PyInterpreterState *interp = _PyInterpreterState_GET();
struct ast_state *state = &interp->ast;
if (!init_types(state)) {
return NULL;
}
return state;
}
void _PyAST_Fini(PyInterpreterState *interp)
{
struct ast_state *state = &interp->ast;
Py_CLEAR(state->AST_type);
Py_CLEAR(state->Add_singleton);
Py_CLEAR(state->Add_type);
Py_CLEAR(state->And_singleton);
Py_CLEAR(state->And_type);
Py_CLEAR(state->AnnAssign_type);
Py_CLEAR(state->Assert_type);
Py_CLEAR(state->Assign_type);
Py_CLEAR(state->AsyncFor_type);
Py_CLEAR(state->AsyncFunctionDef_type);
Py_CLEAR(state->AsyncWith_type);
Py_CLEAR(state->Attribute_type);
Py_CLEAR(state->AugAssign_type);
Py_CLEAR(state->Await_type);
Py_CLEAR(state->BinOp_type);
Py_CLEAR(state->BitAnd_singleton);
Py_CLEAR(state->BitAnd_type);
Py_CLEAR(state->BitOr_singleton);
Py_CLEAR(state->BitOr_type);
Py_CLEAR(state->BitXor_singleton);
Py_CLEAR(state->BitXor_type);
Py_CLEAR(state->BoolOp_type);
Py_CLEAR(state->Break_type);
Py_CLEAR(state->Call_type);
Py_CLEAR(state->ClassDef_type);
Py_CLEAR(state->Compare_type);
Py_CLEAR(state->Constant_type);
Py_CLEAR(state->Continue_type);
Py_CLEAR(state->Del_singleton);
Py_CLEAR(state->Del_type);
Py_CLEAR(state->Delete_type);
Py_CLEAR(state->DictComp_type);
Py_CLEAR(state->Dict_type);
Py_CLEAR(state->Div_singleton);
Py_CLEAR(state->Div_type);
Py_CLEAR(state->Eq_singleton);
Py_CLEAR(state->Eq_type);
Py_CLEAR(state->ExceptHandler_type);
Py_CLEAR(state->Expr_type);
Py_CLEAR(state->Expression_type);
Py_CLEAR(state->FloorDiv_singleton);
Py_CLEAR(state->FloorDiv_type);
Py_CLEAR(state->For_type);
Py_CLEAR(state->FormattedValue_type);
Py_CLEAR(state->FunctionDef_type);
Py_CLEAR(state->FunctionType_type);
Py_CLEAR(state->GeneratorExp_type);
Py_CLEAR(state->Global_type);
Py_CLEAR(state->GtE_singleton);
Py_CLEAR(state->GtE_type);
Py_CLEAR(state->Gt_singleton);
Py_CLEAR(state->Gt_type);
Py_CLEAR(state->IfExp_type);
Py_CLEAR(state->If_type);
Py_CLEAR(state->ImportFrom_type);
Py_CLEAR(state->Import_type);
Py_CLEAR(state->In_singleton);
Py_CLEAR(state->In_type);
Py_CLEAR(state->Interactive_type);
Py_CLEAR(state->Invert_singleton);
Py_CLEAR(state->Invert_type);
Py_CLEAR(state->IsNot_singleton);
Py_CLEAR(state->IsNot_type);
Py_CLEAR(state->Is_singleton);
Py_CLEAR(state->Is_type);
Py_CLEAR(state->JoinedStr_type);
Py_CLEAR(state->LShift_singleton);
Py_CLEAR(state->LShift_type);
Py_CLEAR(state->Lambda_type);
Py_CLEAR(state->ListComp_type);
Py_CLEAR(state->List_type);
Py_CLEAR(state->Load_singleton);
Py_CLEAR(state->Load_type);
Py_CLEAR(state->LtE_singleton);
Py_CLEAR(state->LtE_type);
Py_CLEAR(state->Lt_singleton);
Py_CLEAR(state->Lt_type);
Py_CLEAR(state->MatMult_singleton);
Py_CLEAR(state->MatMult_type);
Py_CLEAR(state->MatchAs_type);
Py_CLEAR(state->MatchClass_type);
Py_CLEAR(state->MatchMapping_type);
Py_CLEAR(state->MatchOr_type);
Py_CLEAR(state->MatchSequence_type);
Py_CLEAR(state->MatchSingleton_type);
Py_CLEAR(state->MatchStar_type);
Py_CLEAR(state->MatchValue_type);
Py_CLEAR(state->Match_type);
Py_CLEAR(state->Mod_singleton);
Py_CLEAR(state->Mod_type);
Py_CLEAR(state->Module_type);
Py_CLEAR(state->Mult_singleton);
Py_CLEAR(state->Mult_type);
Py_CLEAR(state->Name_type);
Py_CLEAR(state->NamedExpr_type);
Py_CLEAR(state->Nonlocal_type);
Py_CLEAR(state->NotEq_singleton);
Py_CLEAR(state->NotEq_type);
Py_CLEAR(state->NotIn_singleton);
Py_CLEAR(state->NotIn_type);
Py_CLEAR(state->Not_singleton);
Py_CLEAR(state->Not_type);
Py_CLEAR(state->Or_singleton);
Py_CLEAR(state->Or_type);
Py_CLEAR(state->Pass_type);
Py_CLEAR(state->Pow_singleton);
Py_CLEAR(state->Pow_type);
Py_CLEAR(state->RShift_singleton);
Py_CLEAR(state->RShift_type);
Py_CLEAR(state->Raise_type);
Py_CLEAR(state->Return_type);
Py_CLEAR(state->SetComp_type);
Py_CLEAR(state->Set_type);
Py_CLEAR(state->Slice_type);
Py_CLEAR(state->Starred_type);
Py_CLEAR(state->Store_singleton);
Py_CLEAR(state->Store_type);
Py_CLEAR(state->Sub_singleton);
Py_CLEAR(state->Sub_type);
Py_CLEAR(state->Subscript_type);
Py_CLEAR(state->Try_type);
Py_CLEAR(state->Tuple_type);
Py_CLEAR(state->TypeIgnore_type);
Py_CLEAR(state->UAdd_singleton);
Py_CLEAR(state->UAdd_type);
Py_CLEAR(state->USub_singleton);
Py_CLEAR(state->USub_type);
Py_CLEAR(state->UnaryOp_type);
Py_CLEAR(state->While_type);
Py_CLEAR(state->With_type);
Py_CLEAR(state->YieldFrom_type);
Py_CLEAR(state->Yield_type);
Py_CLEAR(state->__dict__);
Py_CLEAR(state->__doc__);
Py_CLEAR(state->__match_args__);
Py_CLEAR(state->__module__);
Py_CLEAR(state->_attributes);
Py_CLEAR(state->_fields);
Py_CLEAR(state->alias_type);
Py_CLEAR(state->annotation);
Py_CLEAR(state->arg);
Py_CLEAR(state->arg_type);
Py_CLEAR(state->args);
Py_CLEAR(state->argtypes);
Py_CLEAR(state->arguments_type);
Py_CLEAR(state->asname);
Py_CLEAR(state->ast);
Py_CLEAR(state->attr);
Py_CLEAR(state->bases);
Py_CLEAR(state->body);
Py_CLEAR(state->boolop_type);
Py_CLEAR(state->cases);
Py_CLEAR(state->cause);
Py_CLEAR(state->cls);
Py_CLEAR(state->cmpop_type);
Py_CLEAR(state->col_offset);
Py_CLEAR(state->comparators);
Py_CLEAR(state->comprehension_type);
Py_CLEAR(state->context_expr);
Py_CLEAR(state->conversion);
Py_CLEAR(state->ctx);
Py_CLEAR(state->decorator_list);
Py_CLEAR(state->defaults);
Py_CLEAR(state->elt);
Py_CLEAR(state->elts);
Py_CLEAR(state->end_col_offset);
Py_CLEAR(state->end_lineno);
Py_CLEAR(state->exc);
Py_CLEAR(state->excepthandler_type);
Py_CLEAR(state->expr_context_type);
Py_CLEAR(state->expr_type);
Py_CLEAR(state->finalbody);
Py_CLEAR(state->format_spec);
Py_CLEAR(state->func);
Py_CLEAR(state->generators);
Py_CLEAR(state->guard);
Py_CLEAR(state->handlers);
Py_CLEAR(state->id);
Py_CLEAR(state->ifs);
Py_CLEAR(state->is_async);
Py_CLEAR(state->items);
Py_CLEAR(state->iter);
Py_CLEAR(state->key);
Py_CLEAR(state->keys);
Py_CLEAR(state->keyword_type);
Py_CLEAR(state->keywords);
Py_CLEAR(state->kind);
Py_CLEAR(state->kw_defaults);
Py_CLEAR(state->kwarg);
Py_CLEAR(state->kwd_attrs);
Py_CLEAR(state->kwd_patterns);
Py_CLEAR(state->kwonlyargs);
Py_CLEAR(state->left);
Py_CLEAR(state->level);
Py_CLEAR(state->lineno);
Py_CLEAR(state->lower);
Py_CLEAR(state->match_case_type);
Py_CLEAR(state->mod_type);
Py_CLEAR(state->module);
Py_CLEAR(state->msg);
Py_CLEAR(state->name);
Py_CLEAR(state->names);
Py_CLEAR(state->op);
Py_CLEAR(state->operand);
Py_CLEAR(state->operator_type);
Py_CLEAR(state->ops);
Py_CLEAR(state->optional_vars);
Py_CLEAR(state->orelse);
Py_CLEAR(state->pattern);
Py_CLEAR(state->pattern_type);
Py_CLEAR(state->patterns);
Py_CLEAR(state->posonlyargs);
Py_CLEAR(state->rest);
Py_CLEAR(state->returns);
Py_CLEAR(state->right);
Py_CLEAR(state->simple);
Py_CLEAR(state->slice);
Py_CLEAR(state->step);
Py_CLEAR(state->stmt_type);
Py_CLEAR(state->subject);
Py_CLEAR(state->tag);
Py_CLEAR(state->target);
Py_CLEAR(state->targets);
Py_CLEAR(state->test);
Py_CLEAR(state->type);
Py_CLEAR(state->type_comment);
Py_CLEAR(state->type_ignore_type);
Py_CLEAR(state->type_ignores);
Py_CLEAR(state->unaryop_type);
Py_CLEAR(state->upper);
Py_CLEAR(state->value);
Py_CLEAR(state->values);
Py_CLEAR(state->vararg);
Py_CLEAR(state->withitem_type);
#if !defined(NDEBUG)
state->initialized = -1;
#else
state->initialized = 0;
#endif
}
static int init_identifiers(struct ast_state *state)
{
if ((state->__dict__ = PyUnicode_InternFromString("__dict__")) == NULL) return 0;
if ((state->__doc__ = PyUnicode_InternFromString("__doc__")) == NULL) return 0;
if ((state->__match_args__ = PyUnicode_InternFromString("__match_args__")) == 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->cases = PyUnicode_InternFromString("cases")) == NULL) return 0;
if ((state->cause = PyUnicode_InternFromString("cause")) == NULL) return 0;
if ((state->cls = PyUnicode_InternFromString("cls")) == 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->guard = PyUnicode_InternFromString("guard")) == 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->kwd_attrs = PyUnicode_InternFromString("kwd_attrs")) == NULL) return 0;
if ((state->kwd_patterns = PyUnicode_InternFromString("kwd_patterns")) == 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->pattern = PyUnicode_InternFromString("pattern")) == NULL) return 0;
if ((state->patterns = PyUnicode_InternFromString("patterns")) == NULL) return 0;
if ((state->posonlyargs = PyUnicode_InternFromString("posonlyargs")) == NULL) return 0;
if ((state->rest = PyUnicode_InternFromString("rest")) == 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->subject = PyUnicode_InternFromString("subject")) == 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;
};
GENERATE_ASDL_SEQ_CONSTRUCTOR(mod, mod_ty)
GENERATE_ASDL_SEQ_CONSTRUCTOR(stmt, stmt_ty)
GENERATE_ASDL_SEQ_CONSTRUCTOR(expr, expr_ty)
GENERATE_ASDL_SEQ_CONSTRUCTOR(comprehension, comprehension_ty)
GENERATE_ASDL_SEQ_CONSTRUCTOR(excepthandler, excepthandler_ty)
GENERATE_ASDL_SEQ_CONSTRUCTOR(arguments, arguments_ty)
GENERATE_ASDL_SEQ_CONSTRUCTOR(arg, arg_ty)
GENERATE_ASDL_SEQ_CONSTRUCTOR(keyword, keyword_ty)
GENERATE_ASDL_SEQ_CONSTRUCTOR(alias, alias_ty)
GENERATE_ASDL_SEQ_CONSTRUCTOR(withitem, withitem_ty)
GENERATE_ASDL_SEQ_CONSTRUCTOR(match_case, match_case_ty)
GENERATE_ASDL_SEQ_CONSTRUCTOR(pattern, pattern_ty)
GENERATE_ASDL_SEQ_CONSTRUCTOR(type_ignore, type_ignore_ty)
static PyObject* ast2obj_mod(struct ast_state *state, 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(struct ast_state *state, 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 Match_fields[]={
"subject",
"cases",
};
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(struct ast_state *state, 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(struct ast_state *state, expr_context_ty);
static PyObject* ast2obj_boolop(struct ast_state *state, boolop_ty);
static PyObject* ast2obj_operator(struct ast_state *state, operator_ty);
static PyObject* ast2obj_unaryop(struct ast_state *state, unaryop_ty);
static PyObject* ast2obj_cmpop(struct ast_state *state, cmpop_ty);
static PyObject* ast2obj_comprehension(struct ast_state *state, 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(struct ast_state *state, void*);
static const char * const ExceptHandler_fields[]={
"type",
"name",
"body",
};
static PyObject* ast2obj_arguments(struct ast_state *state, void*);
static const char * const arguments_fields[]={
"posonlyargs",
"args",
"vararg",
"kwonlyargs",
"kw_defaults",
"kwarg",
"defaults",
};
static PyObject* ast2obj_arg(struct ast_state *state, 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(struct ast_state *state, 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(struct ast_state *state, void*);
static const char * const alias_attributes[] = {
"lineno",
"col_offset",
"end_lineno",
"end_col_offset",
};
static const char * const alias_fields[]={
"name",
"asname",
};
static PyObject* ast2obj_withitem(struct ast_state *state, void*);
static const char * const withitem_fields[]={
"context_expr",
"optional_vars",
};
static PyObject* ast2obj_match_case(struct ast_state *state, void*);
static const char * const match_case_fields[]={
"pattern",
"guard",
"body",
};
static const char * const pattern_attributes[] = {
"lineno",
"col_offset",
"end_lineno",
"end_col_offset",
};
static PyObject* ast2obj_pattern(struct ast_state *state, void*);
static const char * const MatchValue_fields[]={
"value",
};
static const char * const MatchSingleton_fields[]={
"value",
};
static const char * const MatchSequence_fields[]={
"patterns",
};
static const char * const MatchMapping_fields[]={
"keys",
"patterns",
"rest",
};
static const char * const MatchClass_fields[]={
"cls",
"patterns",
"kwd_attrs",
"kwd_patterns",
};
static const char * const MatchStar_fields[]={
"name",
};
static const char * const MatchAs_fields[]={
"pattern",
"name",
};
static const char * const MatchOr_fields[]={
"patterns",
};
static PyObject* ast2obj_type_ignore(struct ast_state *state, 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(Py_TYPE(self));
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)
{
struct ast_state *state = get_ast_state();
if (state == NULL) {
return -1;
}
Py_ssize_t i, numfields = 0;
int res = -1;
PyObject *key, *value, *fields;
if (_PyObject_LookupAttr((PyObject*)Py_TYPE(self), state->_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)) {
int contains = PySequence_Contains(fields, key);
if (contains == -1) {
res = -1;
goto cleanup;
} else if (contains == 1) {
Py_ssize_t p = PySequence_Index(fields, key);
if (p == -1) {
res = -1;
goto cleanup;
}
if (p < PyTuple_GET_SIZE(args)) {
PyErr_Format(PyExc_TypeError,
"%.400s got multiple values for argument '%U'",
Py_TYPE(self)->tp_name, key);
res = -1;
goto cleanup;
}
}
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)
{
struct ast_state *state = get_ast_state();
if (state == NULL) {
return NULL;
}
PyObject *dict;
if (_PyObject_LookupAttr(self, state->__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(struct ast_state *state, 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){OOOOOOOs}",
type, base,
state->_fields, fnames,
state->__match_args__, fnames,
state->__module__,
state->ast,
state->__doc__, doc);
Py_DECREF(fnames);
return result;
}
static int
add_attributes(struct ast_state *state, 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, state->_attributes, l) >= 0;
Py_DECREF(l);
return result;
}
/* Conversion AST -> Python */
static PyObject* ast2obj_list(struct ast_state *state, asdl_seq *seq, PyObject* (*func)(struct ast_state *state, 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(state, asdl_seq_GET_UNTYPED(seq, i));
if (!value) {
Py_DECREF(result);
return NULL;
}
PyList_SET_ITEM(result, i, value);
}
return result;
}
static PyObject* ast2obj_object(struct ast_state *Py_UNUSED(state), void *o)
{
if (!o)
o = Py_None;
Py_INCREF((PyObject*)o);
return (PyObject*)o;
}
#define ast2obj_constant ast2obj_object
#define ast2obj_identifier ast2obj_object
#define ast2obj_string ast2obj_object
static PyObject* ast2obj_int(struct ast_state *Py_UNUSED(state), long b)
{
return PyLong_FromLong(b);
}
/* Conversion Python -> AST */
static int obj2ast_object(struct ast_state *Py_UNUSED(state), 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(struct ast_state *Py_UNUSED(state), 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(struct ast_state *state, 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(state, obj, out, arena);
}
static int obj2ast_string(struct ast_state *state, 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(state, obj, out, arena);
}
static int obj2ast_int(struct ast_state* Py_UNUSED(state), 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(struct ast_state *state)
{
PyObject *empty_tuple;
empty_tuple = PyTuple_New(0);
if (!empty_tuple ||
PyObject_SetAttrString(state->AST_type, "_fields", empty_tuple) < 0 ||
PyObject_SetAttrString(state->AST_type, "__match_args__", empty_tuple) < 0 ||
PyObject_SetAttrString(state->AST_type, "_attributes", empty_tuple) < 0) {
Py_XDECREF(empty_tuple);
return -1;
}
Py_DECREF(empty_tuple);
return 0;
}
static int
init_types(struct ast_state *state)
{
// init_types() must not be called after _PyAST_Fini()
// has been called
assert(state->initialized >= 0);
if (state->initialized) {
return 1;
}
if (init_identifiers(state) < 0) {
return 0;
}
state->AST_type = PyType_FromSpec(&AST_type_spec);
if (!state->AST_type) {
return 0;
}
if (add_ast_fields(state) < 0) {
return 0;
}
state->mod_type = make_type(state, "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, state->mod_type, NULL, 0)) return 0;
state->Module_type = make_type(state, "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(state, "Interactive", state->mod_type,
Interactive_fields, 1,
"Interactive(stmt* body)");
if (!state->Interactive_type) return 0;
state->Expression_type = make_type(state, "Expression", state->mod_type,
Expression_fields, 1,
"Expression(expr body)");
if (!state->Expression_type) return 0;
state->FunctionType_type = make_type(state, "FunctionType",
state->mod_type, FunctionType_fields,
2,
"FunctionType(expr* argtypes, expr returns)");
if (!state->FunctionType_type) return 0;
state->stmt_type = make_type(state, "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"
" | Match(expr subject, match_case* cases)\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, 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(state, "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(state, "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(state, "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(state, "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(state, "Delete", state->stmt_type,
Delete_fields, 1,
"Delete(expr* targets)");
if (!state->Delete_type) return 0;
state->Assign_type = make_type(state, "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(state, "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(state, "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(state, "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(state, "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(state, "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(state, "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(state, "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(state, "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->Match_type = make_type(state, "Match", state->stmt_type,
Match_fields, 2,
"Match(expr subject, match_case* cases)");
if (!state->Match_type) return 0;
state->Raise_type = make_type(state, "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(state, "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(state, "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(state, "Import", state->stmt_type,
Import_fields, 1,
"Import(alias* names)");
if (!state->Import_type) return 0;
state->ImportFrom_type = make_type(state, "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(state, "Global", state->stmt_type,
Global_fields, 1,
"Global(identifier* names)");
if (!state->Global_type) return 0;
state->Nonlocal_type = make_type(state, "Nonlocal", state->stmt_type,
Nonlocal_fields, 1,
"Nonlocal(identifier* names)");
if (!state->Nonlocal_type) return 0;
state->Expr_type = make_type(state, "Expr", state->stmt_type, Expr_fields,
1,
"Expr(expr value)");
if (!state->Expr_type) return 0;
state->Pass_type = make_type(state, "Pass", state->stmt_type, NULL, 0,
"Pass");
if (!state->Pass_type) return 0;
state->Break_type = make_type(state, "Break", state->stmt_type, NULL, 0,
"Break");
if (!state->Break_type) return 0;
state->Continue_type = make_type(state, "Continue", state->stmt_type, NULL,
0,
"Continue");
if (!state->Continue_type) return 0;
state->expr_type = make_type(state, "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, 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(state, "BoolOp", state->expr_type,
BoolOp_fields, 2,
"BoolOp(boolop op, expr* values)");
if (!state->BoolOp_type) return 0;
state->NamedExpr_type = make_type(state, "NamedExpr", state->expr_type,
NamedExpr_fields, 2,
"NamedExpr(expr target, expr value)");
if (!state->NamedExpr_type) return 0;
state->BinOp_type = make_type(state, "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(state, "UnaryOp", state->expr_type,
UnaryOp_fields, 2,
"UnaryOp(unaryop op, expr operand)");
if (!state->UnaryOp_type) return 0;
state->Lambda_type = make_type(state, "Lambda", state->expr_type,
Lambda_fields, 2,
"Lambda(arguments args, expr body)");
if (!state->Lambda_type) return 0;
state->IfExp_type = make_type(state, "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(state, "Dict", state->expr_type, Dict_fields,
2,
"Dict(expr* keys, expr* values)");
if (!state->Dict_type) return 0;
state->Set_type = make_type(state, "Set", state->expr_type, Set_fields, 1,
"Set(expr* elts)");
if (!state->Set_type) return 0;
state->ListComp_type = make_type(state, "ListComp", state->expr_type,
ListComp_fields, 2,
"ListComp(expr elt, comprehension* generators)");
if (!state->ListComp_type) return 0;
state->SetComp_type = make_type(state, "SetComp", state->expr_type,
SetComp_fields, 2,
"SetComp(expr elt, comprehension* generators)");
if (!state->SetComp_type) return 0;
state->DictComp_type = make_type(state, "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(state, "GeneratorExp",
state->expr_type, GeneratorExp_fields,
2,
"GeneratorExp(expr elt, comprehension* generators)");
if (!state->GeneratorExp_type) return 0;
state->Await_type = make_type(state, "Await", state->expr_type,
Await_fields, 1,
"Await(expr value)");
if (!state->Await_type) return 0;
state->Yield_type = make_type(state, "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(state, "YieldFrom", state->expr_type,
YieldFrom_fields, 1,
"YieldFrom(expr value)");
if (!state->YieldFrom_type) return 0;
state->Compare_type = make_type(state, "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(state, "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(state, "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->format_spec,
Py_None) == -1)
return 0;
state->JoinedStr_type = make_type(state, "JoinedStr", state->expr_type,
JoinedStr_fields, 1,
"JoinedStr(expr* values)");
if (!state->JoinedStr_type) return 0;
state->Constant_type = make_type(state, "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(state, "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(state, "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(state, "Starred", state->expr_type,
Starred_fields, 2,
"Starred(expr value, expr_context ctx)");
if (!state->Starred_type) return 0;
state->Name_type = make_type(state, "Name", state->expr_type, Name_fields,
2,
"Name(identifier id, expr_context ctx)");
if (!state->Name_type) return 0;
state->List_type = make_type(state, "List", state->expr_type, List_fields,
2,
"List(expr* elts, expr_context ctx)");
if (!state->List_type) return 0;
state->Tuple_type = make_type(state, "Tuple", state->expr_type,
Tuple_fields, 2,
"Tuple(expr* elts, expr_context ctx)");
if (!state->Tuple_type) return 0;
state->Slice_type = make_type(state, "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(state, "expr_context",
state->AST_type, NULL, 0,
"expr_context = Load | Store | Del");
if (!state->expr_context_type) return 0;
if (!add_attributes(state, state->expr_context_type, NULL, 0)) return 0;
state->Load_type = make_type(state, "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(state, "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(state, "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(state, "boolop", state->AST_type, NULL, 0,
"boolop = And | Or");
if (!state->boolop_type) return 0;
if (!add_attributes(state, state->boolop_type, NULL, 0)) return 0;
state->And_type = make_type(state, "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(state, "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(state, "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, state->operator_type, NULL, 0)) return 0;
state->Add_type = make_type(state, "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(state, "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(state, "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(state, "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(state, "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(state, "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(state, "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(state, "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(state, "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(state, "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(state, "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(state, "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(state, "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(state, "unaryop", state->AST_type, NULL, 0,
"unaryop = Invert | Not | UAdd | USub");
if (!state->unaryop_type) return 0;
if (!add_attributes(state, state->unaryop_type, NULL, 0)) return 0;
state->Invert_type = make_type(state, "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(state, "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(state, "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(state, "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(state, "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, state->cmpop_type, NULL, 0)) return 0;
state->Eq_type = make_type(state, "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(state, "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(state, "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(state, "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(state, "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(state, "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(state, "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(state, "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(state, "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(state, "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(state, "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, state->comprehension_type, NULL, 0)) return 0;
state->excepthandler_type = make_type(state, "excepthandler",
state->AST_type, NULL, 0,
"excepthandler = ExceptHandler(expr? type, identifier? name, stmt* body)");
if (!state->excepthandler_type) return 0;
if (!add_attributes(state, 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(state, "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(state, "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, 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(state, "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, 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(state, "keyword", state->AST_type,
keyword_fields, 2,
"keyword(identifier? arg, expr value)");
if (!state->keyword_type) return 0;
if (!add_attributes(state, 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(state, "alias", state->AST_type,
alias_fields, 2,
"alias(identifier name, identifier? asname)");
if (!state->alias_type) return 0;
if (!add_attributes(state, state->alias_type, alias_attributes, 4)) return
0;
if (PyObject_SetAttr(state->alias_type, state->asname, Py_None) == -1)
return 0;
if (PyObject_SetAttr(state->alias_type, state->end_lineno, Py_None) == -1)
return 0;
if (PyObject_SetAttr(state->alias_type, state->end_col_offset, Py_None) ==
-1)
return 0;
state->withitem_type = make_type(state, "withitem", state->AST_type,
withitem_fields, 2,
"withitem(expr context_expr, expr? optional_vars)");
if (!state->withitem_type) return 0;
if (!add_attributes(state, state->withitem_type, NULL, 0)) return 0;
if (PyObject_SetAttr(state->withitem_type, state->optional_vars, Py_None)
== -1)
return 0;
state->match_case_type = make_type(state, "match_case", state->AST_type,
match_case_fields, 3,
"match_case(pattern pattern, expr? guard, stmt* body)");
if (!state->match_case_type) return 0;
if (!add_attributes(state, state->match_case_type, NULL, 0)) return 0;
if (PyObject_SetAttr(state->match_case_type, state->guard, Py_None) == -1)
return 0;
state->pattern_type = make_type(state, "pattern", state->AST_type, NULL, 0,
"pattern = MatchValue(expr value)\n"
" | MatchSingleton(constant value)\n"
" | MatchSequence(pattern* patterns)\n"
" | MatchMapping(expr* keys, pattern* patterns, identifier? rest)\n"
" | MatchClass(expr cls, pattern* patterns, identifier* kwd_attrs, pattern* kwd_patterns)\n"
" | MatchStar(identifier? name)\n"
" | MatchAs(pattern? pattern, identifier? name)\n"
" | MatchOr(pattern* patterns)");
if (!state->pattern_type) return 0;
if (!add_attributes(state, state->pattern_type, pattern_attributes, 4))
return 0;
state->MatchValue_type = make_type(state, "MatchValue",
state->pattern_type, MatchValue_fields,
1,
"MatchValue(expr value)");
if (!state->MatchValue_type) return 0;
state->MatchSingleton_type = make_type(state, "MatchSingleton",
state->pattern_type,
MatchSingleton_fields, 1,
"MatchSingleton(constant value)");
if (!state->MatchSingleton_type) return 0;
state->MatchSequence_type = make_type(state, "MatchSequence",
state->pattern_type,
MatchSequence_fields, 1,
"MatchSequence(pattern* patterns)");
if (!state->MatchSequence_type) return 0;
state->MatchMapping_type = make_type(state, "MatchMapping",
state->pattern_type,
MatchMapping_fields, 3,
"MatchMapping(expr* keys, pattern* patterns, identifier? rest)");
if (!state->MatchMapping_type) return 0;
if (PyObject_SetAttr(state->MatchMapping_type, state->rest, Py_None) == -1)
return 0;
state->MatchClass_type = make_type(state, "MatchClass",
state->pattern_type, MatchClass_fields,
4,
"MatchClass(expr cls, pattern* patterns, identifier* kwd_attrs, pattern* kwd_patterns)");
if (!state->MatchClass_type) return 0;
state->MatchStar_type = make_type(state, "MatchStar", state->pattern_type,
MatchStar_fields, 1,
"MatchStar(identifier? name)");
if (!state->MatchStar_type) return 0;
if (PyObject_SetAttr(state->MatchStar_type, state->name, Py_None) == -1)
return 0;
state->MatchAs_type = make_type(state, "MatchAs", state->pattern_type,
MatchAs_fields, 2,
"MatchAs(pattern? pattern, identifier? name)");
if (!state->MatchAs_type) return 0;
if (PyObject_SetAttr(state->MatchAs_type, state->pattern, Py_None) == -1)
return 0;
if (PyObject_SetAttr(state->MatchAs_type, state->name, Py_None) == -1)
return 0;
state->MatchOr_type = make_type(state, "MatchOr", state->pattern_type,
MatchOr_fields, 1,
"MatchOr(pattern* patterns)");
if (!state->MatchOr_type) return 0;
state->type_ignore_type = make_type(state, "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, state->type_ignore_type, NULL, 0)) return 0;
state->TypeIgnore_type = make_type(state, "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(struct ast_state *state, PyObject* obj, mod_ty* out,
PyArena* arena);
static int obj2ast_stmt(struct ast_state *state, PyObject* obj, stmt_ty* out,
PyArena* arena);
static int obj2ast_expr(struct ast_state *state, PyObject* obj, expr_ty* out,
PyArena* arena);
static int obj2ast_expr_context(struct ast_state *state, PyObject* obj,
expr_context_ty* out, PyArena* arena);
static int obj2ast_boolop(struct ast_state *state, PyObject* obj, boolop_ty*
out, PyArena* arena);
static int obj2ast_operator(struct ast_state *state, PyObject* obj,
operator_ty* out, PyArena* arena);
static int obj2ast_unaryop(struct ast_state *state, PyObject* obj, unaryop_ty*
out, PyArena* arena);
static int obj2ast_cmpop(struct ast_state *state, PyObject* obj, cmpop_ty* out,
PyArena* arena);
static int obj2ast_comprehension(struct ast_state *state, PyObject* obj,
comprehension_ty* out, PyArena* arena);
static int obj2ast_excepthandler(struct ast_state *state, PyObject* obj,
excepthandler_ty* out, PyArena* arena);
static int obj2ast_arguments(struct ast_state *state, PyObject* obj,
arguments_ty* out, PyArena* arena);
static int obj2ast_arg(struct ast_state *state, PyObject* obj, arg_ty* out,
PyArena* arena);
static int obj2ast_keyword(struct ast_state *state, PyObject* obj, keyword_ty*
out, PyArena* arena);
static int obj2ast_alias(struct ast_state *state, PyObject* obj, alias_ty* out,
PyArena* arena);
static int obj2ast_withitem(struct ast_state *state, PyObject* obj,
withitem_ty* out, PyArena* arena);
static int obj2ast_match_case(struct ast_state *state, PyObject* obj,
match_case_ty* out, PyArena* arena);
static int obj2ast_pattern(struct ast_state *state, PyObject* obj, pattern_ty*
out, PyArena* arena);
static int obj2ast_type_ignore(struct ast_state *state, PyObject* obj,
type_ignore_ty* out, PyArena* arena);
mod_ty
_PyAST_Module(asdl_stmt_seq * body, asdl_type_ignore_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
_PyAST_Interactive(asdl_stmt_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
_PyAST_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
_PyAST_FunctionType(asdl_expr_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
_PyAST_FunctionDef(identifier name, arguments_ty args, asdl_stmt_seq * body,
asdl_expr_seq * decorator_list, expr_ty returns, string
type_comment, int lineno, int col_offset, int end_lineno,
int end_col_offset, PyArena *arena)
{
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
_PyAST_AsyncFunctionDef(identifier name, arguments_ty args, asdl_stmt_seq *
body, asdl_expr_seq * decorator_list, expr_ty returns,
string type_comment, int lineno, int col_offset, int
end_lineno, int end_col_offset, PyArena *arena)
{
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
_PyAST_ClassDef(identifier name, asdl_expr_seq * bases, asdl_keyword_seq *
keywords, asdl_stmt_seq * body, asdl_expr_seq * decorator_list,
int lineno, int col_offset, int end_lineno, int end_col_offset,
PyArena *arena)
{
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
_PyAST_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
_PyAST_Delete(asdl_expr_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
_PyAST_Assign(asdl_expr_seq * targets, expr_ty value, string type_comment, int
lineno, int col_offset, int end_lineno, int end_col_offset,
PyArena *arena)
{
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
_PyAST_AugAssign(expr_ty target, operator_ty op, expr_ty value, int lineno, int
col_offset, int end_lineno, int end_col_offset, PyArena *arena)
{
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
_PyAST_AnnAssign(expr_ty target, expr_ty annotation, expr_ty value, int simple,
int lineno, int col_offset, int end_lineno, int
end_col_offset, PyArena *arena)
{
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
_PyAST_For(expr_ty target, expr_ty iter, asdl_stmt_seq * body, asdl_stmt_seq *
orelse, string type_comment, int lineno, int col_offset, int
end_lineno, int end_col_offset, PyArena *arena)
{
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
_PyAST_AsyncFor(expr_ty target, expr_ty iter, asdl_stmt_seq * body,
asdl_stmt_seq * orelse, string type_comment, int lineno, int
col_offset, int end_lineno, int end_col_offset, PyArena *arena)
{
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
_PyAST_While(expr_ty test, asdl_stmt_seq * body, asdl_stmt_seq * orelse, int
lineno, int col_offset, int end_lineno, int end_col_offset,
PyArena *arena)
{
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
_PyAST_If(expr_ty test, asdl_stmt_seq * body, asdl_stmt_seq * orelse, int
lineno, int col_offset, int end_lineno, int end_col_offset, PyArena
*arena)
{
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
_PyAST_With(asdl_withitem_seq * items, asdl_stmt_seq * body, string
type_comment, int lineno, int col_offset, int end_lineno, int
end_col_offset, PyArena *arena)
{
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
_PyAST_AsyncWith(asdl_withitem_seq * items, asdl_stmt_seq * body, string
type_comment, int lineno, int col_offset, int end_lineno, int
end_col_offset, PyArena *arena)
{
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
_PyAST_Match(expr_ty subject, asdl_match_case_seq * cases, int lineno, int
col_offset, int end_lineno, int end_col_offset, PyArena *arena)
{
stmt_ty p;
if (!subject) {
PyErr_SetString(PyExc_ValueError,
"field 'subject' is required for Match");
return NULL;
}
p = (stmt_ty)_PyArena_Malloc(arena, sizeof(*p));
if (!p)
return NULL;
p->kind = Match_kind;
p->v.Match.subject = subject;
p->v.Match.cases = cases;
p->lineno = lineno;
p->col_offset = col_offset;
p->end_lineno = end_lineno;
p->end_col_offset = end_col_offset;
return p;
}
stmt_ty
_PyAST_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
_PyAST_Try(asdl_stmt_seq * body, asdl_excepthandler_seq * handlers,
asdl_stmt_seq * orelse, asdl_stmt_seq * finalbody, int lineno, int
col_offset, int end_lineno, int end_col_offset, PyArena *arena)
{
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
_PyAST_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
_PyAST_Import(asdl_alias_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
_PyAST_ImportFrom(identifier module, asdl_alias_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
_PyAST_Global(asdl_identifier_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
_PyAST_Nonlocal(asdl_identifier_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
_PyAST_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