// 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_ceval.h" // _Py_EnterRecursiveCall

#include "pycore_lock.h" // _PyOnceFlag

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

#include "pycore_modsupport.h" // _PyArg_NoPositional()

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

#include "pycore_setobject.h" // _PySet_NextEntry(), _PySet_Update()

#include "pycore_unionobject.h" // _Py_union_type_or

#include "structmember.h"

#include <stddef.h>

struct validator {

int recursion_depth; /* current recursion depth */

int recursion_limit; /* recursion limit */

};

// Forward declaration

static int init_types(void *arg);

static struct ast_state*

get_ast_state(void)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

struct ast_state *state = &interp->ast;

assert(!state->finalized);

if (_PyOnceFlag_CallOnce(&state->once, (_Py_once_fn_t *)&init_types, state) < 0) {

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->ParamSpec_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->TryStar_type);

Py_CLEAR(state->Try_type);

Py_CLEAR(state->Tuple_type);

Py_CLEAR(state->TypeAlias_type);

Py_CLEAR(state->TypeIgnore_type);

Py_CLEAR(state->TypeVarTuple_type);

Py_CLEAR(state->TypeVar_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->bound);

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

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

Py_CLEAR(state->type_params);

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

Py_CLEAR(_Py_INTERP_CACHED_OBJECT(interp, str_replace_inf));

state->finalized = 1;

state->once = (_PyOnceFlag){0};

}

static int init_identifiers(struct ast_state *state)

{

if ((state->__dict__ = PyUnicode_InternFromString("__dict__")) == NULL) return -1;

if ((state->__doc__ = PyUnicode_InternFromString("__doc__")) == NULL) return -1;

if ((state->__match_args__ = PyUnicode_InternFromString("__match_args__")) == NULL) return -1;

if ((state->__module__ = PyUnicode_InternFromString("__module__")) == NULL) return -1;

if ((state->_attributes = PyUnicode_InternFromString("_attributes")) == NULL) return -1;

if ((state->_fields = PyUnicode_InternFromString("_fields")) == NULL) return -1;

if ((state->annotation = PyUnicode_InternFromString("annotation")) == NULL) return -1;

if ((state->arg = PyUnicode_InternFromString("arg")) == NULL) return -1;

if ((state->args = PyUnicode_InternFromString("args")) == NULL) return -1;

if ((state->argtypes = PyUnicode_InternFromString("argtypes")) == NULL) return -1;

if ((state->asname = PyUnicode_InternFromString("asname")) == NULL) return -1;

if ((state->ast = PyUnicode_InternFromString("ast")) == NULL) return -1;

if ((state->attr = PyUnicode_InternFromString("attr")) == NULL) return -1;

if ((state->bases = PyUnicode_InternFromString("bases")) == NULL) return -1;

if ((state->body = PyUnicode_InternFromString("body")) == NULL) return -1;

if ((state->bound = PyUnicode_InternFromString("bound")) == NULL) return -1;

if ((state->cases = PyUnicode_InternFromString("cases")) == NULL) return -1;

if ((state->cause = PyUnicode_InternFromString("cause")) == NULL) return -1;

if ((state->cls = PyUnicode_InternFromString("cls")) == NULL) return -1;

if ((state->col_offset = PyUnicode_InternFromString("col_offset")) == NULL) return -1;

if ((state->comparators = PyUnicode_InternFromString("comparators")) == NULL) return -1;

if ((state->context_expr = PyUnicode_InternFromString("context_expr")) == NULL) return -1;

if ((state->conversion = PyUnicode_InternFromString("conversion")) == NULL) return -1;

if ((state->ctx = PyUnicode_InternFromString("ctx")) == NULL) return -1;

if ((state->decorator_list = PyUnicode_InternFromString("decorator_list")) == NULL) return -1;

if ((state->default_value = PyUnicode_InternFromString("default_value")) == NULL) return -1;

if ((state->defaults = PyUnicode_InternFromString("defaults")) == NULL) return -1;

if ((state->elt = PyUnicode_InternFromString("elt")) == NULL) return -1;

if ((state->elts = PyUnicode_InternFromString("elts")) == NULL) return -1;

if ((state->end_col_offset = PyUnicode_InternFromString("end_col_offset")) == NULL) return -1;

if ((state->end_lineno = PyUnicode_InternFromString("end_lineno")) == NULL) return -1;

if ((state->exc = PyUnicode_InternFromString("exc")) == NULL) return -1;

if ((state->finalbody = PyUnicode_InternFromString("finalbody")) == NULL) return -1;

if ((state->format_spec = PyUnicode_InternFromString("format_spec")) == NULL) return -1;

if ((state->func = PyUnicode_InternFromString("func")) == NULL) return -1;

if ((state->generators = PyUnicode_InternFromString("generators")) == NULL) return -1;

if ((state->guard = PyUnicode_InternFromString("guard")) == NULL) return -1;

if ((state->handlers = PyUnicode_InternFromString("handlers")) == NULL) return -1;

if ((state->id = PyUnicode_InternFromString("id")) == NULL) return -1;

if ((state->ifs = PyUnicode_InternFromString("ifs")) == NULL) return -1;

if ((state->is_async = PyUnicode_InternFromString("is_async")) == NULL) return -1;

if ((state->items = PyUnicode_InternFromString("items")) == NULL) return -1;

if ((state->iter = PyUnicode_InternFromString("iter")) == NULL) return -1;

if ((state->key = PyUnicode_InternFromString("key")) == NULL) return -1;

if ((state->keys = PyUnicode_InternFromString("keys")) == NULL) return -1;

if ((state->keywords = PyUnicode_InternFromString("keywords")) == NULL) return -1;

if ((state->kind = PyUnicode_InternFromString("kind")) == NULL) return -1;

if ((state->kw_defaults = PyUnicode_InternFromString("kw_defaults")) == NULL) return -1;

if ((state->kwarg = PyUnicode_InternFromString("kwarg")) == NULL) return -1;

if ((state->kwd_attrs = PyUnicode_InternFromString("kwd_attrs")) == NULL) return -1;

if ((state->kwd_patterns = PyUnicode_InternFromString("kwd_patterns")) == NULL) return -1;

if ((state->kwonlyargs = PyUnicode_InternFromString("kwonlyargs")) == NULL) return -1;

if ((state->left = PyUnicode_InternFromString("left")) == NULL) return -1;

if ((state->level = PyUnicode_InternFromString("level")) == NULL) return -1;

if ((state->lineno = PyUnicode_InternFromString("lineno")) == NULL) return -1;

if ((state->lower = PyUnicode_InternFromString("lower")) == NULL) return -1;

if ((state->module = PyUnicode_InternFromString("module")) == NULL) return -1;

if ((state->msg = PyUnicode_InternFromString("msg")) == NULL) return -1;

if ((state->name = PyUnicode_InternFromString("name")) == NULL) return -1;

if ((state->names = PyUnicode_InternFromString("names")) == NULL) return -1;

if ((state->op = PyUnicode_InternFromString("op")) == NULL) return -1;

if ((state->operand = PyUnicode_InternFromString("operand")) == NULL) return -1;

if ((state->ops = PyUnicode_InternFromString("ops")) == NULL) return -1;

if ((state->optional_vars = PyUnicode_InternFromString("optional_vars")) == NULL) return -1;

if ((state->orelse = PyUnicode_InternFromString("orelse")) == NULL) return -1;

if ((state->pattern = PyUnicode_InternFromString("pattern")) == NULL) return -1;

if ((state->patterns = PyUnicode_InternFromString("patterns")) == NULL) return -1;

if ((state->posonlyargs = PyUnicode_InternFromString("posonlyargs")) == NULL) return -1;

if ((state->rest = PyUnicode_InternFromString("rest")) == NULL) return -1;

if ((state->returns = PyUnicode_InternFromString("returns")) == NULL) return -1;

if ((state->right = PyUnicode_InternFromString("right")) == NULL) return -1;

if ((state->simple = PyUnicode_InternFromString("simple")) == NULL) return -1;

if ((state->slice = PyUnicode_InternFromString("slice")) == NULL) return -1;

if ((state->step = PyUnicode_InternFromString("step")) == NULL) return -1;

if ((state->subject = PyUnicode_InternFromString("subject")) == NULL) return -1;

if ((state->tag = PyUnicode_InternFromString("tag")) == NULL) return -1;

if ((state->target = PyUnicode_InternFromString("target")) == NULL) return -1;

if ((state->targets = PyUnicode_InternFromString("targets")) == NULL) return -1;

if ((state->test = PyUnicode_InternFromString("test")) == NULL) return -1;

if ((state->type = PyUnicode_InternFromString("type")) == NULL) return -1;

if ((state->type_comment = PyUnicode_InternFromString("type_comment")) == NULL) return -1;

if ((state->type_ignores = PyUnicode_InternFromString("type_ignores")) == NULL) return -1;

if ((state->type_params = PyUnicode_InternFromString("type_params")) == NULL) return -1;

if ((state->upper = PyUnicode_InternFromString("upper")) == NULL) return -1;

if ((state->value = PyUnicode_InternFromString("value")) == NULL) return -1;

if ((state->values = PyUnicode_InternFromString("values")) == NULL) return -1;

if ((state->vararg = PyUnicode_InternFromString("vararg")) == NULL) return -1;

return 0;

};

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)

GENERATE_ASDL_SEQ_CONSTRUCTOR(type_param, type_param_ty)

static PyObject* ast2obj_mod(struct ast_state *state, struct validator *vstate,

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, struct validator

*vstate, void*);

static const char * const FunctionDef_fields[]={

"name",

"args",

"body",

"decorator_list",

"returns",

"type_comment",

"type_params",

};

static const char * const AsyncFunctionDef_fields[]={

"name",

"args",

"body",

"decorator_list",

"returns",

"type_comment",

"type_params",

};

static const char * const ClassDef_fields[]={

"name",

"bases",

"keywords",

"body",

"decorator_list",

"type_params",

};

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 TypeAlias_fields[]={

"name",

"type_params",

"value",

};

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 TryStar_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, struct validator

*vstate, 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, struct validator

*vstate, expr_context_ty);

static PyObject* ast2obj_boolop(struct ast_state *state, struct validator

*vstate, boolop_ty);

static PyObject* ast2obj_operator(struct ast_state *state, struct validator

*vstate, operator_ty);

static PyObject* ast2obj_unaryop(struct ast_state *state, struct validator

*vstate, unaryop_ty);

static PyObject* ast2obj_cmpop(struct ast_state *state, struct validator

*vstate, cmpop_ty);

static PyObject* ast2obj_comprehension(struct ast_state *state, struct

validator *vstate, 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, struct

validator *vstate, void*);

static const char * const ExceptHandler_fields[]={

"type",

"name",

"body",

};

static PyObject* ast2obj_arguments(struct ast_state *state, struct validator

*vstate, void*);

static const char * const arguments_fields[]={

"posonlyargs",

"args",

"vararg",

"kwonlyargs",

"kw_defaults",

"kwarg",

"defaults",

};

static PyObject* ast2obj_arg(struct ast_state *state, struct validator *vstate,

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, struct validator

*vstate, 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, struct validator

*vstate, 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, struct validator

*vstate, void*);

static const char * const withitem_fields[]={

"context_expr",

"optional_vars",

};

static PyObject* ast2obj_match_case(struct ast_state *state, struct validator

*vstate, 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, struct validator

*vstate, 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, struct validator

*vstate, void*);

static const char * const TypeIgnore_fields[]={

"lineno",

"tag",

};

static const char * const type_param_attributes[] = {

"lineno",

"col_offset",

"end_lineno",

"end_col_offset",

};

static PyObject* ast2obj_type_param(struct ast_state *state, struct validator

*vstate, void*);

static const char * const TypeVar_fields[]={

"name",

"bound",

"default_value",

};

static const char * const ParamSpec_fields[]={

"name",

"default_value",

};

static const char * const TypeVarTuple_fields[]={

"name",

"default_value",

};

static int

add_ast_annotations(struct ast_state *state)

{

bool cond;

PyObject *Module_annotations = PyDict_New();

if (!Module_annotations) return 0;

{

PyObject *type = state->stmt_type;

type = Py_GenericAlias((PyObject *)&PyList_Type, type);

cond = type != NULL;

if (!cond) {

Py_DECREF(Module_annotations);

return 0;

}

cond = PyDict_SetItemString(Module_annotations, "body", type) == 0;

Py_DECREF(type);

if (!cond) {

Py_DECREF(Module_annotations);

return 0;

}

}

{

PyObject *type = state->type_ignore_type;

type = Py_GenericAlias((PyObject *)&PyList_Type, type);

cond = type != NULL;

if (!cond) {

Py_DECREF(Module_annotations);

return 0;

}

cond = PyDict_SetItemString(Module_annotations, "type_ignores", type)

== 0;

Py_DECREF(type);

if (!cond) {

Py_DECREF(Module_annotations);

return 0;

}

}

cond = PyObject_SetAttrString(state->Module_type, "_field_types",

Module_annotations) == 0;

if (!cond) {

Py_DECREF(Module_annotations);

return 0;

}

cond = PyObject_SetAttrString(state->Module_type, "__annotations__",

Module_annotations) == 0;

if (!cond) {

Py_DECREF(Module_annotations);

return 0;

}

Py_DECREF(Module_annotations);

PyObject *Interactive_annotations = PyDict_New();

if (!Interactive_annotations) return 0;

{

PyObject *type = state->stmt_type;

type = Py_GenericAlias((PyObject *)&PyList_Type, type);

cond = type != NULL;

if (!cond) {

Py_DECREF(Interactive_annotations);

return 0;

}

cond = PyDict_SetItemString(Interactive_annotations, "body", type) == 0;

Py_DECREF(type);

if (!cond) {

Py_DECREF(Interactive_annotations);

return 0;

}

}

cond = PyObject_SetAttrString(state->Interactive_type, "_field_types",

Interactive_annotations) == 0;

if (!cond) {

Py_DECREF(Interactive_annotations);

return 0;

}

cond = PyObject_SetAttrString(state->Interactive_type, "__annotations__",

Interactive_annotations) == 0;

if (!cond) {

Py_DECREF(Interactive_annotations);

return 0;

}

Py_DECREF(Interactive_annotations);

PyObject *Expression_annotations = PyDict_New();

if (!Expression_annotations) return 0;

{

PyObject *type = state->expr_type;

Py_INCREF(type);

cond = PyDict_SetItemString(Expression_annotations, "body", type) == 0;

Py_DECREF(type);

if (!cond) {

Py_DECREF(Expression_annotations);

return 0;

}

}

cond = PyObject_SetAttrString(state->Expression_type, "_field_types",

Expression_annotations) == 0;

if (!cond) {

Py_DECREF(Expression_annotations);

return 0;

}

cond = PyObject_SetAttrString(state->Expression_type, "__annotations__",

Expression_annotations) == 0;

if (!cond) {

Py_DECREF(Expression_annotations);

return 0;

}

Py_DECREF(Expression_annotations);

PyObject *FunctionType_annotations = PyDict_New();

if (!FunctionType_annotations) return 0;

{

PyObject *type = state->expr_type;

type = Py_GenericAlias((PyObject *)&PyList_Type, type);

cond = type != NULL;

if (!cond) {

Py_DECREF(FunctionType_annotations);

return 0;

}

cond = PyDict_SetItemString(FunctionType_annotations, "argtypes", type)

== 0;

Py_DECREF(type);

if (!cond) {

Py_DECREF(FunctionType_annotations);

return 0;

}

}

{

PyObject *type = state->expr_type;

Py_INCREF(type);

cond = PyDict_SetItemString(FunctionType_annotations, "returns", type)

== 0;

Py_DECREF(type);

if (!cond) {

Py_DECREF(FunctionType_annotations);

return 0;

}

}

cond = PyObject_SetAttrString(state->FunctionType_type, "_field_types",

FunctionType_annotations) == 0;

if (!cond) {

Py_DECREF(FunctionType_annotations);

return 0;

}

cond = PyObject_SetAttrString(state->FunctionType_type, "__annotations__",

FunctionType_annotations) == 0;

if (!cond) {

Py_DECREF(FunctionType_annotations);

return 0;

}

Py_DECREF(FunctionType_annotations);

PyObject *FunctionDef_annotations = PyDict_New();

if (!FunctionDef_annotations) return 0;

{

PyObject *type = (PyObject *)&PyUnicode_Type;

Py_INCREF(type);

cond = PyDict_SetItemString(FunctionDef_annotations, "name", type) == 0;

Py_DECREF(type);

if (!cond) {

Py_DECREF(FunctionDef_annotations);

return 0;

}

}

{

PyObject *type = state->arguments_type;

Py_INCREF(type);

cond = PyDict_SetItemString(FunctionDef_annotations, "args", type) == 0;

Py_DECREF(type);

if (!cond) {

Py_DECREF(FunctionDef_annotations);

return 0;

}

}

{

PyObject *type = state->stmt_type;

type = Py_GenericAlias((PyObject *)&PyList_Type, type);

cond = type != NULL;