#include <stddef.h>

#include "Python.h"

#include "Python-ast.h"

static PyTypeObject AST_type;

static PyTypeObject *mod_type;

static PyObject* ast2obj_mod(void*);

static PyTypeObject *Module_type;

_Py_IDENTIFIER(body);

static char *Module_fields[]={

"body",

};

static PyTypeObject *Interactive_type;

static char *Interactive_fields[]={

"body",

};

static PyTypeObject *Expression_type;

static char *Expression_fields[]={

"body",

};

static PyTypeObject *Suite_type;

static char *Suite_fields[]={

"body",

};

static PyTypeObject *stmt_type;

_Py_IDENTIFIER(lineno);

_Py_IDENTIFIER(col_offset);

static char *stmt_attributes[] = {

"lineno",

"col_offset",

};

static PyObject* ast2obj_stmt(void*);

static PyTypeObject *FunctionDef_type;

_Py_IDENTIFIER(name);

_Py_IDENTIFIER(args);

_Py_IDENTIFIER(decorator_list);

_Py_IDENTIFIER(returns);

static char *FunctionDef_fields[]={

"name",

"args",

"body",

"decorator_list",

"returns",

};

static PyTypeObject *AsyncFunctionDef_type;

static char *AsyncFunctionDef_fields[]={

"name",

"args",

"body",

"decorator_list",

"returns",

};

static PyTypeObject *ClassDef_type;

_Py_IDENTIFIER(bases);

_Py_IDENTIFIER(keywords);

static char *ClassDef_fields[]={

"name",

"bases",

"keywords",

"body",

"decorator_list",

};

static PyTypeObject *Return_type;

_Py_IDENTIFIER(value);

static char *Return_fields[]={

"value",

};

static PyTypeObject *Delete_type;

_Py_IDENTIFIER(targets);

static char *Delete_fields[]={

"targets",

};

static PyTypeObject *Assign_type;

static char *Assign_fields[]={

"targets",

"value",

};

static PyTypeObject *AugAssign_type;

_Py_IDENTIFIER(target);

_Py_IDENTIFIER(op);

static char *AugAssign_fields[]={

"target",

"op",

"value",

};

static PyTypeObject *AnnAssign_type;

_Py_IDENTIFIER(annotation);

_Py_IDENTIFIER(simple);

static char *AnnAssign_fields[]={

"target",

"annotation",

"value",

"simple",

};

static PyTypeObject *For_type;

_Py_IDENTIFIER(iter);

_Py_IDENTIFIER(orelse);

static char *For_fields[]={

"target",

"iter",

"body",

"orelse",

};

static PyTypeObject *AsyncFor_type;

static char *AsyncFor_fields[]={

"target",

"iter",

"body",

"orelse",

};

static PyTypeObject *While_type;

_Py_IDENTIFIER(test);

static char *While_fields[]={

"test",

"body",

"orelse",

};

static PyTypeObject *If_type;

static char *If_fields[]={

"test",

"body",

"orelse",

};

static PyTypeObject *With_type;

_Py_IDENTIFIER(items);

static char *With_fields[]={

"items",

"body",

};

static PyTypeObject *AsyncWith_type;

static char *AsyncWith_fields[]={

"items",

"body",

};

static PyTypeObject *Raise_type;

_Py_IDENTIFIER(exc);

_Py_IDENTIFIER(cause);

static char *Raise_fields[]={

"exc",

"cause",

};

static PyTypeObject *Try_type;

_Py_IDENTIFIER(handlers);

_Py_IDENTIFIER(finalbody);

static char *Try_fields[]={

"body",

"handlers",

"orelse",

"finalbody",

};

static PyTypeObject *Assert_type;

_Py_IDENTIFIER(msg);

static char *Assert_fields[]={

"test",

"msg",

};

static PyTypeObject *Import_type;

_Py_IDENTIFIER(names);

static char *Import_fields[]={

"names",

};

static PyTypeObject *ImportFrom_type;

_Py_IDENTIFIER(module);

_Py_IDENTIFIER(level);

static char *ImportFrom_fields[]={

"module",

"names",

"level",

};

static PyTypeObject *Global_type;

static char *Global_fields[]={

"names",

};

static PyTypeObject *Nonlocal_type;

static char *Nonlocal_fields[]={

"names",

};

static PyTypeObject *Expr_type;

static char *Expr_fields[]={

"value",

};

static PyTypeObject *Pass_type;

static PyTypeObject *Break_type;

static PyTypeObject *Continue_type;

static PyTypeObject *expr_type;

static char *expr_attributes[] = {

"lineno",

"col_offset",

};

static PyObject* ast2obj_expr(void*);

static PyTypeObject *BoolOp_type;

_Py_IDENTIFIER(values);

static char *BoolOp_fields[]={

"op",

"values",

};

static PyTypeObject *BinOp_type;

_Py_IDENTIFIER(left);

_Py_IDENTIFIER(right);

static char *BinOp_fields[]={

"left",

"op",

"right",

};

static PyTypeObject *UnaryOp_type;

_Py_IDENTIFIER(operand);

static char *UnaryOp_fields[]={

"op",

"operand",

};

static PyTypeObject *Lambda_type;

static char *Lambda_fields[]={

"args",

"body",

};

static PyTypeObject *IfExp_type;

static char *IfExp_fields[]={

"test",

"body",

"orelse",

};

static PyTypeObject *Dict_type;

_Py_IDENTIFIER(keys);

static char *Dict_fields[]={

"keys",

"values",

};

static PyTypeObject *Set_type;

_Py_IDENTIFIER(elts);

static char *Set_fields[]={

"elts",

};

static PyTypeObject *ListComp_type;

_Py_IDENTIFIER(elt);

_Py_IDENTIFIER(generators);

static char *ListComp_fields[]={

"elt",

"generators",

};

static PyTypeObject *SetComp_type;

static char *SetComp_fields[]={

"elt",

"generators",

};

static PyTypeObject *DictComp_type;

_Py_IDENTIFIER(key);

static char *DictComp_fields[]={

"key",

"value",

"generators",

};

static PyTypeObject *GeneratorExp_type;

static char *GeneratorExp_fields[]={

"elt",

"generators",

};

static PyTypeObject *Await_type;

static char *Await_fields[]={

"value",

};

static PyTypeObject *Yield_type;

static char *Yield_fields[]={

"value",

};

static PyTypeObject *YieldFrom_type;

static char *YieldFrom_fields[]={

"value",

};

static PyTypeObject *Compare_type;

_Py_IDENTIFIER(ops);

_Py_IDENTIFIER(comparators);

static char *Compare_fields[]={

"left",

"ops",

"comparators",

};

static PyTypeObject *Call_type;

_Py_IDENTIFIER(func);

static char *Call_fields[]={

"func",

"args",

"keywords",

};

static PyTypeObject *FormattedValue_type;

_Py_IDENTIFIER(conversion);

_Py_IDENTIFIER(format_spec);

static char *FormattedValue_fields[]={

"value",

"conversion",

"format_spec",

};

static PyTypeObject *JoinedStr_type;

static char *JoinedStr_fields[]={

"values",

};

static PyTypeObject *Constant_type;

static char *Constant_fields[]={

"value",

};

static PyTypeObject *Attribute_type;

_Py_IDENTIFIER(attr);

_Py_IDENTIFIER(ctx);

static char *Attribute_fields[]={

"value",

"attr",

"ctx",

};

static PyTypeObject *Subscript_type;

_Py_IDENTIFIER(slice);

static char *Subscript_fields[]={

"value",

"slice",

"ctx",

};

static PyTypeObject *Starred_type;

static char *Starred_fields[]={

"value",

"ctx",

};

static PyTypeObject *Name_type;

_Py_IDENTIFIER(id);

static char *Name_fields[]={

"id",

"ctx",

};

static PyTypeObject *List_type;

static char *List_fields[]={

"elts",

"ctx",

};

static PyTypeObject *Tuple_type;

static char *Tuple_fields[]={

"elts",

"ctx",

};

static PyTypeObject *expr_context_type;

static PyObject *Load_singleton, *Store_singleton, *Del_singleton,

*AugLoad_singleton, *AugStore_singleton, *Param_singleton;

static PyObject* ast2obj_expr_context(expr_context_ty);

static PyTypeObject *Load_type;

static PyTypeObject *Store_type;

static PyTypeObject *Del_type;

static PyTypeObject *AugLoad_type;

static PyTypeObject *AugStore_type;

static PyTypeObject *Param_type;

static PyTypeObject *slice_type;

static PyObject* ast2obj_slice(void*);

static PyTypeObject *Slice_type;

_Py_IDENTIFIER(lower);

_Py_IDENTIFIER(upper);

_Py_IDENTIFIER(step);

static char *Slice_fields[]={

"lower",

"upper",

"step",

};

static PyTypeObject *ExtSlice_type;

_Py_IDENTIFIER(dims);

static char *ExtSlice_fields[]={

"dims",

};

static PyTypeObject *Index_type;

static char *Index_fields[]={

"value",

};

static PyTypeObject *boolop_type;

static PyObject *And_singleton, *Or_singleton;

static PyObject* ast2obj_boolop(boolop_ty);

static PyTypeObject *And_type;

static PyTypeObject *Or_type;

static PyTypeObject *operator_type;

static PyObject *Add_singleton, *Sub_singleton, *Mult_singleton,

*MatMult_singleton, *Div_singleton, *Mod_singleton, *Pow_singleton,

*LShift_singleton, *RShift_singleton, *BitOr_singleton, *BitXor_singleton,

*BitAnd_singleton, *FloorDiv_singleton;

static PyObject* ast2obj_operator(operator_ty);

static PyTypeObject *Add_type;

static PyTypeObject *Sub_type;

static PyTypeObject *Mult_type;

static PyTypeObject *MatMult_type;

static PyTypeObject *Div_type;

static PyTypeObject *Mod_type;

static PyTypeObject *Pow_type;

static PyTypeObject *LShift_type;

static PyTypeObject *RShift_type;

static PyTypeObject *BitOr_type;

static PyTypeObject *BitXor_type;

static PyTypeObject *BitAnd_type;

static PyTypeObject *FloorDiv_type;

static PyTypeObject *unaryop_type;

static PyObject *Invert_singleton, *Not_singleton, *UAdd_singleton,

*USub_singleton;

static PyObject* ast2obj_unaryop(unaryop_ty);

static PyTypeObject *Invert_type;

static PyTypeObject *Not_type;

static PyTypeObject *UAdd_type;

static PyTypeObject *USub_type;

static PyTypeObject *cmpop_type;

static PyObject *Eq_singleton, *NotEq_singleton, *Lt_singleton, *LtE_singleton,

*Gt_singleton, *GtE_singleton, *Is_singleton, *IsNot_singleton, *In_singleton,

*NotIn_singleton;

static PyObject* ast2obj_cmpop(cmpop_ty);

static PyTypeObject *Eq_type;

static PyTypeObject *NotEq_type;

static PyTypeObject *Lt_type;

static PyTypeObject *LtE_type;

static PyTypeObject *Gt_type;

static PyTypeObject *GtE_type;

static PyTypeObject *Is_type;

static PyTypeObject *IsNot_type;

static PyTypeObject *In_type;

static PyTypeObject *NotIn_type;

static PyTypeObject *comprehension_type;

static PyObject* ast2obj_comprehension(void*);

_Py_IDENTIFIER(ifs);

_Py_IDENTIFIER(is_async);

static char *comprehension_fields[]={

"target",

"iter",

"ifs",

"is_async",

};

static PyTypeObject *excepthandler_type;

static char *excepthandler_attributes[] = {

"lineno",

"col_offset",

};

static PyObject* ast2obj_excepthandler(void*);

static PyTypeObject *ExceptHandler_type;

_Py_IDENTIFIER(type);

static char *ExceptHandler_fields[]={

"type",

"name",

"body",

};

static PyTypeObject *arguments_type;

static PyObject* ast2obj_arguments(void*);

_Py_IDENTIFIER(vararg);

_Py_IDENTIFIER(kwonlyargs);

_Py_IDENTIFIER(kw_defaults);

_Py_IDENTIFIER(kwarg);

_Py_IDENTIFIER(defaults);

static char *arguments_fields[]={

"args",

"vararg",

"kwonlyargs",

"kw_defaults",

"kwarg",

"defaults",

};

static PyTypeObject *arg_type;

static PyObject* ast2obj_arg(void*);

static char *arg_attributes[] = {

"lineno",

"col_offset",

};

_Py_IDENTIFIER(arg);

static char *arg_fields[]={

"arg",

"annotation",

};

static PyTypeObject *keyword_type;

static PyObject* ast2obj_keyword(void*);

static char *keyword_fields[]={

"arg",

"value",

};

static PyTypeObject *alias_type;

static PyObject* ast2obj_alias(void*);

_Py_IDENTIFIER(asname);

static char *alias_fields[]={

"name",

"asname",

};

static PyTypeObject *withitem_type;

static PyObject* ast2obj_withitem(void*);

_Py_IDENTIFIER(context_expr);

_Py_IDENTIFIER(optional_vars);

static char *withitem_fields[]={

"context_expr",

"optional_vars",

};

_Py_IDENTIFIER(_fields);

_Py_IDENTIFIER(_attributes);

typedef struct {

PyObject_HEAD

PyObject *dict;

} AST_object;

static void

ast_dealloc(AST_object *self)

{

/* bpo-31095: UnTrack is needed before calling any callbacks */

PyObject_GC_UnTrack(self);

Py_CLEAR(self->dict);

Py_TYPE(self)->tp_free(self);

}

static int

ast_traverse(AST_object *self, visitproc visit, void *arg)

{

Py_VISIT(self->dict);

return 0;

}

static int

ast_clear(AST_object *self)

{

Py_CLEAR(self->dict);

return 0;

}

static int

ast_type_init(PyObject *self, PyObject *args, PyObject *kw)

{

Py_ssize_t i, numfields = 0;

int res = -1;

PyObject *key, *value, *fields;

if (_PyObject_LookupAttrId((PyObject*)Py_TYPE(self), &PyId__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",

Py_TYPE(self)->tp_name,

numfields, numfields == 1 ? "" : "s");

res = -1;

goto cleanup;

}

for (i = 0; i < PyTuple_GET_SIZE(args); i++) {

/* cannot be reached when fields is NULL */

PyObject *name = PySequence_GetItem(fields, i);

if (!name) {

res = -1;

goto cleanup;

}

res = PyObject_SetAttr(self, name, PyTuple_GET_ITEM(args, i));

Py_DECREF(name);

if (res < 0)

goto cleanup;

}

if (kw) {

i = 0; /* needed by PyDict_Next */

while (PyDict_Next(kw, &i, &key, &value)) {

res = PyObject_SetAttr(self, key, value);

if (res < 0)

goto cleanup;

}

}

cleanup:

Py_XDECREF(fields);

return res;

}

static PyObject *

ast_type_reduce(PyObject *self, PyObject *unused)

{

_Py_IDENTIFIER(__dict__);

PyObject *dict;

if (_PyObject_LookupAttrId(self, &PyId___dict__, &dict) < 0) {

return NULL;

}

if (dict) {

return Py_BuildValue("O()N", Py_TYPE(self), dict);

}

return Py_BuildValue("O()", Py_TYPE(self));

}

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 PyTypeObject AST_type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"_ast.AST",

sizeof(AST_object),

0,

(destructor)ast_dealloc, /* tp_dealloc */

0, /* tp_print */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_reserved */

0, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

0, /* tp_call */

0, /* tp_str */

PyObject_GenericGetAttr, /* tp_getattro */

PyObject_GenericSetAttr, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /* tp_flags */

0, /* tp_doc */

(traverseproc)ast_traverse, /* tp_traverse */

(inquiry)ast_clear, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

ast_type_methods, /* tp_methods */

0, /* tp_members */

ast_type_getsets, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

offsetof(AST_object, dict),/* tp_dictoffset */

(initproc)ast_type_init, /* tp_init */

PyType_GenericAlloc, /* tp_alloc */

PyType_GenericNew, /* tp_new */

PyObject_GC_Del, /* tp_free */

};

static PyTypeObject* make_type(char *type, PyTypeObject* base, char**fields, int num_fields)

{

_Py_IDENTIFIER(__module__);

_Py_IDENTIFIER(_ast);

PyObject *fnames, *result;

int i;

fnames = PyTuple_New(num_fields);

if (!fnames) return NULL;

for (i = 0; i < num_fields; i++) {

PyObject *field = PyUnicode_FromString(fields[i]);

if (!field) {

Py_DECREF(fnames);

return NULL;

}

PyTuple_SET_ITEM(fnames, i, field);

}

result = PyObject_CallFunction((PyObject*)&PyType_Type, "s(O){OOOO}",

type, base,

_PyUnicode_FromId(&PyId__fields), fnames,

_PyUnicode_FromId(&PyId___module__),

_PyUnicode_FromId(&PyId__ast));

Py_DECREF(fnames);

return (PyTypeObject*)result;

}

static int add_attributes(PyTypeObject* type, char**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_FromString(attrs[i]);

if (!s) {

Py_DECREF(l);

return 0;

}

PyTuple_SET_ITEM(l, i, s);

}

result = _PyObject_SetAttrId((PyObject*)type, &PyId__attributes, l) >= 0;

Py_DECREF(l);

return result;

}

static PyObject* ast2obj_list(asdl_seq *seq, PyObject* (*func)(void*))

{

Py_ssize_t i, n = asdl_seq_LEN(seq);

PyObject *result = PyList_New(n);

PyObject *value;

if (!result)

return NULL;

for (i = 0; i < n; i++) {

value = func(asdl_seq_GET(seq, i));

if (!value) {

Py_DECREF(result);

return NULL;

}

PyList_SET_ITEM(result, i, value);

}

return result;

}

static PyObject* ast2obj_object(void *o)

{

if (!o)

o = Py_None;

Py_INCREF((PyObject*)o);

return (PyObject*)o;

}

#define ast2obj_singleton ast2obj_object

#define ast2obj_constant ast2obj_object

#define ast2obj_identifier ast2obj_object

#define ast2obj_string ast2obj_object

#define ast2obj_bytes ast2obj_object

static PyObject* ast2obj_int(long b)

{

return PyLong_FromLong(b);

}

static int obj2ast_object(PyObject* obj, PyObject** out, PyArena* arena)

{

if (obj == Py_None)

obj = NULL;

if (obj) {

if (PyArena_AddPyObject(arena, obj) < 0) {

*out = NULL;

return -1;

}

Py_INCREF(obj);

}

*out = obj;

return 0;

}

static int obj2ast_constant(PyObject* obj, PyObject** out, PyArena* arena)

{

if (PyArena_AddPyObject(arena, obj) < 0) {

*out = NULL;

return -1;

}

Py_INCREF(obj);

*out = obj;

return 0;

}

static int obj2ast_identifier(PyObject* obj, PyObject** out, PyArena* arena)

{

if (!PyUnicode_CheckExact(obj) && obj != Py_None) {

PyErr_SetString(PyExc_TypeError, "AST identifier must be of type str");

return 1;

}

return obj2ast_object(obj, out, arena);

}

static int obj2ast_int(PyObject* obj, int* out, PyArena* arena)

{

int i;

if (!PyLong_Check(obj)) {

PyErr_Format(PyExc_ValueError, "invalid integer value: %R", obj);

return 1;

}

i = _PyLong_AsInt(obj);

if (i == -1 && PyErr_Occurred())

return 1;

*out = i;

return 0;

}

static int add_ast_fields(void)

{

PyObject *empty_tuple, *d;

if (PyType_Ready(&AST_type) < 0)

return -1;

d = AST_type.tp_dict;

empty_tuple = PyTuple_New(0);

if (!empty_tuple ||

_PyDict_SetItemId(d, &PyId__fields, empty_tuple) < 0 ||

_PyDict_SetItemId(d, &PyId__attributes, empty_tuple) < 0) {

Py_XDECREF(empty_tuple);

return -1;

}

Py_DECREF(empty_tuple);

return 0;

}

static int init_types(void)

{

static int initialized;

if (initialized) return 1;

if (add_ast_fields() < 0) return 0;

mod_type = make_type("mod", &AST_type, NULL, 0);

if (!mod_type) return 0;

if (!add_attributes(mod_type, NULL, 0)) return 0;

Module_type = make_type("Module", mod_type, Module_fields, 1);

if (!Module_type) return 0;

Interactive_type = make_type("Interactive", mod_type, Interactive_fields,

1);

if (!Interactive_type) return 0;

Expression_type = make_type("Expression", mod_type, Expression_fields, 1);

if (!Expression_type) return 0;

Suite_type = make_type("Suite", mod_type, Suite_fields, 1);

if (!Suite_type) return 0;

stmt_type = make_type("stmt", &AST_type, NULL, 0);

if (!stmt_type) return 0;

if (!add_attributes(stmt_type, stmt_attributes, 2)) return 0;

FunctionDef_type = make_type("FunctionDef", stmt_type, FunctionDef_fields,

5);

if (!FunctionDef_type) return 0;

AsyncFunctionDef_type = make_type("AsyncFunctionDef", stmt_type,

AsyncFunctionDef_fields, 5);

if (!AsyncFunctionDef_type) return 0;

ClassDef_type = make_type("ClassDef", stmt_type, ClassDef_fields, 5);

if (!ClassDef_type) return 0;

Return_type = make_type("Return", stmt_type, Return_fields, 1);

if (!Return_type) return 0;

Delete_type = make_type("Delete", stmt_type, Delete_fields, 1);

if (!Delete_type) return 0;

Assign_type = make_type("Assign", stmt_type, Assign_fields, 2);

if (!Assign_type) return 0;

AugAssign_type = make_type("AugAssign", stmt_type, AugAssign_fields, 3);

if (!AugAssign_type) return 0;

AnnAssign_type = make_type("AnnAssign", stmt_type, AnnAssign_fields, 4);

if (!AnnAssign_type) return 0;

For_type = make_type("For", stmt_type, For_fields, 4);

if (!For_type) return 0;

AsyncFor_type = make_type("AsyncFor", stmt_type, AsyncFor_fields, 4);

if (!AsyncFor_type) return 0;

While_type = make_type("While", stmt_type, While_fields, 3);

if (!While_type) return 0;

If_type = make_type("If", stmt_type, If_fields, 3);

if (!If_type) return 0;

With_type = make_type("With", stmt_type, With_fields, 2);

if (!With_type) return 0;

AsyncWith_type = make_type("AsyncWith", stmt_type, AsyncWith_fields, 2);

if (!AsyncWith_type) return 0;

Raise_type = make_type("Raise", stmt_type, Raise_fields, 2);

if (!Raise_type) return 0;

Try_type = make_type("Try", stmt_type, Try_fields, 4);

if (!Try_type) return 0;

Assert_type = make_type("Assert", stmt_type, Assert_fields, 2);

if (!Assert_type) return 0;

Import_type = make_type("Import", stmt_type, Import_fields, 1);

if (!Import_type) return 0;

ImportFrom_type = make_type("ImportFrom", stmt_type, ImportFrom_fields, 3);

if (!ImportFrom_type) return 0;

Global_type = make_type("Global", stmt_type, Global_fields, 1);

if (!Global_type) return 0;

Nonlocal_type = make_type("Nonlocal", stmt_type, Nonlocal_fields, 1);

if (!Nonlocal_type) return 0;

Expr_type = make_type("Expr", stmt_type, Expr_fields, 1);

if (!Expr_type) return 0;

Pass_type = make_type("Pass", stmt_type, NULL, 0);

if (!Pass_type) return 0;

Break_type = make_type("Break", stmt_type, NULL, 0);

if (!Break_type) return 0;

Continue_type = make_type("Continue", stmt_type, NULL, 0);

if (!Continue_type) return 0;

expr_type = make_type("expr", &AST_type, NULL, 0);

if (!expr_type) return 0;

if (!add_attributes(expr_type, expr_attributes, 2)) return 0;

BoolOp_type = make_type("BoolOp", expr_type, BoolOp_fields, 2);

if (!BoolOp_type) return 0;

BinOp_type = make_type("BinOp", expr_type, BinOp_fields, 3);

if (!BinOp_type) return 0;

UnaryOp_type = make_type("UnaryOp", expr_type, UnaryOp_fields, 2);

if (!UnaryOp_type) return 0;

Lambda_type = make_type("Lambda", expr_type, Lambda_fields, 2);

if (!Lambda_type) return 0;

IfExp_type = make_type("IfExp", expr_type, IfExp_fields, 3);

if (!IfExp_type) return 0;

Dict_type = make_type("Dict", expr_type, Dict_fields, 2);

if (!Dict_type) return 0;

Set_type = make_type("Set", expr_type, Set_fields, 1);

if (!Set_type) return 0;

ListComp_type = make_type("ListComp", expr_type, ListComp_fields, 2);

if (!ListComp_type) return 0;

SetComp_type = make_type("SetComp", expr_type, SetComp_fields, 2);

if (!SetComp_type) return 0;

DictComp_type = make_type("DictComp", expr_type, DictComp_fields, 3);

if (!DictComp_type) return 0;

GeneratorExp_type = make_type("GeneratorExp", expr_type,

GeneratorExp_fields, 2);

if (!GeneratorExp_type) return 0;

Await_type = make_type("Await", expr_type, Await_fields, 1);

if (!Await_type) return 0;

Yield_type = make_type("Yield", expr_type, Yield_fields, 1);

if (!Yield_type) return 0;

YieldFrom_type = make_type("YieldFrom", expr_type, YieldFrom_fields, 1);

if (!YieldFrom_type) return 0;

Compare_type = make_type("Compare", expr_type, Compare_fields, 3);

if (!Compare_type) return 0;

Call_type = make_type("Call", expr_type, Call_fields, 3);

if (!Call_type) return 0;

FormattedValue_type = make_type("FormattedValue", expr_type,

FormattedValue_fields, 3);

if (!FormattedValue_type) return 0;

JoinedStr_type = make_type("JoinedStr", expr_type, JoinedStr_fields, 1);

if (!JoinedStr_type) return 0;

Constant_type = make_type("Constant", expr_type, Constant_fields, 1);

if (!Constant_type) return 0;

Attribute_type = make_type("Attribute", expr_type, Attribute_fields, 3);

if (!Attribute_type) return 0;

Subscript_type = make_type("Subscript", expr_type, Subscript_fields, 3);

if (!Subscript_type) return 0;

Starred_type = make_type("Starred", expr_type, Starred_fields, 2);

if (!Starred_type) return 0;

Name_type = make_type("Name", expr_type, Name_fields, 2);

if (!Name_type) return 0;

List_type = make_type("List", expr_type, List_fields, 2);

if (!List_type) return 0;

Tuple_type = make_type("Tuple", expr_type, Tuple_fields, 2);

if (!Tuple_type) return 0;

expr_context_type = make_type("expr_context", &AST_type, NULL, 0);

if (!expr_context_type) return 0;

if (!add_attributes(expr_context_type, NULL, 0)) return 0;

Load_type = make_type("Load", expr_context_type, NULL, 0);

if (!Load_type) return 0;

Load_singleton = PyType_GenericNew(Load_type, NULL, NULL);

if (!Load_singleton) return 0;

Store_type = make_type("Store", expr_context_type, NULL, 0);

if (!Store_type) return 0;

Store_singleton = PyType_GenericNew(Store_type, NULL, NULL);

if (!Store_singleton) return 0;

Del_type = make_type("Del", expr_context_type, NULL, 0);

if (!Del_type) return 0;

Del_singleton = PyType_GenericNew(Del_type, NULL, NULL);

if (!Del_singleton) return 0;

AugLoad_type = make_type("AugLoad", expr_context_type, NULL, 0);

if (!AugLoad_type) return 0;

AugLoad_singleton = PyType_GenericNew(AugLoad_type, NULL, NULL);

if (!AugLoad_singleton) return 0;

AugStore_type = make_type("AugStore", expr_context_type, NULL, 0);

if (!AugStore_type) return 0;

AugStore_singleton = PyType_GenericNew(AugStore_type, NULL, NULL);

if (!AugStore_singleton) return 0;

Param_type = make_type("Param", expr_context_type, NULL, 0);

if (!Param_type) return 0;

Param_singleton = PyType_GenericNew(Param_type, NULL, NULL);

if (!Param_singleton) return 0;

slice_type = make_type("slice", &AST_type, NULL, 0);

if (!slice_type) return 0;

if (!add_attributes(slice_type, NULL, 0)) return 0;

Slice_type = make_type("Slice", slice_type, Slice_fields, 3);

if (!Slice_type) return 0;

ExtSlice_type = make_type("ExtSlice", slice_type, ExtSlice_fields, 1);

if (!ExtSlice_type) return 0;

Index_type = make_type("Index", slice_type, Index_fields, 1);

if (!Index_type) return 0;

boolop_type = make_type("boolop", &AST_type, NULL, 0);

if (!boolop_type) return 0;

if (!add_attributes(boolop_type, NULL, 0)) return 0;

And_type = make_type("And", boolop_type, NULL, 0);

if (!And_type) return 0;

And_singleton = PyType_GenericNew(And_type, NULL, NULL);

if (!And_singleton) return 0;

Or_type = make_type("Or", boolop_type, NULL, 0);

if (!Or_type) return 0;

Or_singleton = PyType_GenericNew(Or_type, NULL, NULL);

if (!Or_singleton) return 0;

operator_type = make_type("operator", &AST_type, NULL, 0);

if (!operator_type) return 0;

if (!add_attributes(operator_type, NULL, 0)) return 0;

Add_type = make_type("Add", operator_type, NULL, 0);

if (!Add_type) return 0;

Add_singleton = PyType_GenericNew(Add_type, NULL, NULL);

if (!Add_singleton) return 0;

Sub_type = make_type("Sub", operator_type, NULL, 0);

if (!Sub_type) return 0;

Sub_singleton = PyType_GenericNew(Sub_type, NULL, NULL);

if (!Sub_singleton) return 0;

Mult_type = make_type("Mult", operator_type, NULL, 0);

if (!Mult_type) return 0;

Mult_singleton = PyType_GenericNew(Mult_type, NULL, NULL);

if (!Mult_singleton) return 0;

MatMult_type = make_type("MatMult", operator_type, NULL, 0);

if (!MatMult_type) return 0;

MatMult_singleton = PyType_GenericNew(MatMult_type, NULL, NULL);

if (!MatMult_singleton) return 0;

Div_type = make_type("Div", operator_type, NULL, 0);

if (!Div_type) return 0;

Div_singleton = PyType_GenericNew(Div_type, NULL, NULL);

if (!Div_singleton) return 0;

Mod_type = make_type("Mod", operator_type, NULL, 0);

if (!Mod_type) return 0;

Mod_singleton = PyType_GenericNew(Mod_type, NULL, NULL);

if (!Mod_singleton) return 0;

Pow_type = make_type("Pow", operator_type, NULL, 0);

if (!Pow_type) return 0;

Pow_singleton = PyType_GenericNew(Pow_type, NULL, NULL);

if (!Pow_singleton) return 0;

LShift_type = make_type("LShift", operator_type, NULL, 0);

if (!LShift_type) return 0;

LShift_singleton = PyType_GenericNew(LShift_type, NULL, NULL);

if (!LShift_singleton) return 0;

RShift_type = make_type("RShift", operator_type, NULL, 0);

if (!RShift_type) return 0;

RShift_singleton = PyType_GenericNew(RShift_type, NULL, NULL);

if (!RShift_singleton) return 0;