// File automatically generated by Parser/asdl_c.py.

#include <stddef.h>

#include "Python.h"

#include "pycore_ast_state.h" // struct ast_state

#include "pycore_interp.h" // _PyInterpreterState.ast

#include "pycore_pystate.h" // _PyInterpreterState_GET()

// 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;

}

// Include pycore_ast.h after pycore_interp.h to avoid conflicts

// with the Yield macro redefined by <winbase.h>

#include "pycore_ast.h"

#include "structmember.h"

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->MatchOr_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->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->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->patterns);

Py_CLEAR(state->posonlyargs);

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->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->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->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(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 const char * const MatchAs_fields[]={

"pattern",

"name",

};

static const char * const MatchOr_fields[]={

"patterns",

};

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_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 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);