#include "Python.h"

#include "Python-ast.h"

static PyTypeObject AST_type;

static PyTypeObject *mod_type;

static PyObject* ast2obj_mod(void*);

static PyTypeObject *Module_type;

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;

static char *stmt_attributes[] = {

"lineno",

"col_offset",

};

static PyObject* ast2obj_stmt(void*);

static PyTypeObject *FunctionDef_type;

static char *FunctionDef_fields[]={

"name",

"args",

"body",

"decorator_list",

"returns",

};

static PyTypeObject *ClassDef_type;

static char *ClassDef_fields[]={

"name",

"bases",

"keywords",

"starargs",

"kwargs",

"body",

"decorator_list",

};

static PyTypeObject *Return_type;

static char *Return_fields[]={

"value",

};

static PyTypeObject *Delete_type;

static char *Delete_fields[]={

"targets",

};

static PyTypeObject *Assign_type;

static char *Assign_fields[]={

"targets",

"value",

};

static PyTypeObject *AugAssign_type;

static char *AugAssign_fields[]={

"target",

"op",

"value",

};

static PyTypeObject *For_type;

static char *For_fields[]={

"target",

"iter",

"body",

"orelse",

};

static PyTypeObject *While_type;

static char *While_fields[]={

"test",

"body",

"orelse",

};

static PyTypeObject *If_type;

static char *If_fields[]={

"test",

"body",

"orelse",

};

static PyTypeObject *With_type;

static char *With_fields[]={

"context_expr",

"optional_vars",

"body",

};

static PyTypeObject *Raise_type;

static char *Raise_fields[]={

"exc",

"cause",

};

static PyTypeObject *TryExcept_type;

static char *TryExcept_fields[]={

"body",

"handlers",

"orelse",

};

static PyTypeObject *TryFinally_type;

static char *TryFinally_fields[]={

"body",

"finalbody",

};

static PyTypeObject *Assert_type;

static char *Assert_fields[]={

"test",

"msg",

};

static PyTypeObject *Import_type;

static char *Import_fields[]={

"names",

};

static PyTypeObject *ImportFrom_type;

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;

static char *BoolOp_fields[]={

"op",

"values",

};

static PyTypeObject *BinOp_type;

static char *BinOp_fields[]={

"left",

"op",

"right",

};

static PyTypeObject *UnaryOp_type;

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;

static char *Dict_fields[]={

"keys",

"values",

};

static PyTypeObject *Set_type;

static char *Set_fields[]={

"elts",

};

static PyTypeObject *ListComp_type;

static char *ListComp_fields[]={

"elt",

"generators",

};

static PyTypeObject *SetComp_type;

static char *SetComp_fields[]={

"elt",

"generators",

};

static PyTypeObject *DictComp_type;

static char *DictComp_fields[]={

"key",

"value",

"generators",

};

static PyTypeObject *GeneratorExp_type;

static char *GeneratorExp_fields[]={

"elt",

"generators",

};

static PyTypeObject *Yield_type;

static char *Yield_fields[]={

"value",

};

static PyTypeObject *Compare_type;

static char *Compare_fields[]={

"left",

"ops",

"comparators",

};

static PyTypeObject *Call_type;

static char *Call_fields[]={

"func",

"args",

"keywords",

"starargs",

"kwargs",

};

static PyTypeObject *Num_type;

static char *Num_fields[]={

"n",

};

static PyTypeObject *Str_type;

static char *Str_fields[]={

"s",

};

static PyTypeObject *Bytes_type;

static char *Bytes_fields[]={

"s",

};

static PyTypeObject *Ellipsis_type;

static PyTypeObject *Attribute_type;

static char *Attribute_fields[]={

"value",

"attr",

"ctx",

};

static PyTypeObject *Subscript_type;

static char *Subscript_fields[]={

"value",

"slice",

"ctx",

};

static PyTypeObject *Starred_type;

static char *Starred_fields[]={

"value",

"ctx",

};

static PyTypeObject *Name_type;

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;

static char *Slice_fields[]={

"lower",

"upper",

"step",

};

static PyTypeObject *ExtSlice_type;

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,

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

static char *comprehension_fields[]={

"target",

"iter",

"ifs",

};

static PyTypeObject *excepthandler_type;

static char *excepthandler_attributes[] = {

"lineno",

"col_offset",

};

static PyObject* ast2obj_excepthandler(void*);

static PyTypeObject *ExceptHandler_type;

static char *ExceptHandler_fields[]={

"type",

"name",

"body",

};

static PyTypeObject *arguments_type;

static PyObject* ast2obj_arguments(void*);

static char *arguments_fields[]={

"args",

"vararg",

"varargannotation",

"kwonlyargs",

"kwarg",

"kwargannotation",

"defaults",

"kw_defaults",

};

static PyTypeObject *arg_type;

static PyObject* ast2obj_arg(void*);

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

static char *alias_fields[]={

"name",

"asname",

};

static int

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

{

Py_ssize_t i, numfields = 0;

int res = -1;

PyObject *key, *value, *fields;

fields = PyObject_GetAttrString((PyObject*)Py_TYPE(self), "_fields");

if (!fields)

PyErr_Clear();

if (fields) {

numfields = PySequence_Size(fields);

if (numfields == -1)

goto cleanup;

}

res = 0; /* if no error occurs, this stays 0 to the end */

if (PyTuple_GET_SIZE(args) > 0) {

if (numfields != PyTuple_GET_SIZE(args)) {

PyErr_Format(PyExc_TypeError, "%.400s constructor takes %s"

"%zd positional argument%s",

Py_TYPE(self)->tp_name,

numfields == 0 ? "" : "either 0 or ",

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)

{

PyObject *res;

PyObject *dict = PyObject_GetAttrString(self, "__dict__");

if (dict == NULL) {

if (PyErr_ExceptionMatches(PyExc_AttributeError))

PyErr_Clear();

else

return NULL;

}

if (dict) {

res = Py_BuildValue("O()O", Py_TYPE(self), dict);

Py_DECREF(dict);

return res;

}

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

}

static PyMethodDef ast_type_methods[] = {

{"__reduce__", ast_type_reduce, METH_NOARGS, NULL},

{NULL}

};

static PyTypeObject AST_type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"_ast.AST",

sizeof(PyObject),

0,

0, /* 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, /* tp_flags */

0, /* tp_doc */

0, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

ast_type_methods, /* tp_methods */

0, /* tp_members */

0, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

0, /* tp_dictoffset */

(initproc)ast_type_init, /* tp_init */

PyType_GenericAlloc, /* tp_alloc */

PyType_GenericNew, /* tp_new */

PyObject_Del, /* tp_free */

};

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

{

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){sOss}",

type, base, "_fields", fnames, "__module__", "_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_SetAttrString((PyObject*)type, "_attributes", l) >= 0;

Py_DECREF(l);

return result;

}

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

{

int 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_identifier ast2obj_object

#define ast2obj_string 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)

PyArena_AddPyObject(arena, obj);

Py_XINCREF(obj);

*out = obj;

return 0;

}

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

{

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

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

return 1;

}

return obj2ast_object(obj, out, arena);

}

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

{

if (!PyUnicode_CheckExact(obj) && !PyBytes_CheckExact(obj)) {

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

return 1;

}

return obj2ast_object(obj, out, arena);

}

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

{

int i;

if (!PyLong_Check(obj)) {

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

return 1;

}

i = (int)PyLong_AsLong(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_SetItemString(d, "_fields", empty_tuple) < 0 ||

PyDict_SetItemString(d, "_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;

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

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;

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

if (!For_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, 3);

if (!With_type) return 0;

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

if (!Raise_type) return 0;

TryExcept_type = make_type("TryExcept", stmt_type, TryExcept_fields, 3);

if (!TryExcept_type) return 0;

TryFinally_type = make_type("TryFinally", stmt_type, TryFinally_fields,

2);

if (!TryFinally_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;

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

if (!Yield_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, 5);

if (!Call_type) return 0;

Num_type = make_type("Num", expr_type, Num_fields, 1);

if (!Num_type) return 0;

Str_type = make_type("Str", expr_type, Str_fields, 1);

if (!Str_type) return 0;

Bytes_type = make_type("Bytes", expr_type, Bytes_fields, 1);

if (!Bytes_type) return 0;

Ellipsis_type = make_type("Ellipsis", expr_type, NULL, 0);

if (!Ellipsis_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;

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;

BitOr_type = make_type("BitOr", operator_type, NULL, 0);

if (!BitOr_type) return 0;

BitOr_singleton = PyType_GenericNew(BitOr_type, NULL, NULL);

if (!BitOr_singleton) return 0;

BitXor_type = make_type("BitXor", operator_type, NULL, 0);

if (!BitXor_type) return 0;

BitXor_singleton = PyType_GenericNew(BitXor_type, NULL, NULL);

if (!BitXor_singleton) return 0;

BitAnd_type = make_type("BitAnd", operator_type, NULL, 0);

if (!BitAnd_type) return 0;

BitAnd_singleton = PyType_GenericNew(BitAnd_type, NULL, NULL);

if (!BitAnd_singleton) return 0;

FloorDiv_type = make_type("FloorDiv", operator_type, NULL, 0);

if (!FloorDiv_type) return 0;

FloorDiv_singleton = PyType_GenericNew(FloorDiv_type, NULL, NULL);

if (!FloorDiv_singleton) return 0;

unaryop_type = make_type("unaryop", &AST_type, NULL, 0);

if (!unaryop_type) return 0;

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

Invert_type = make_type("Invert", unaryop_type, NULL, 0);

if (!Invert_type) return 0;

Invert_singleton = PyType_GenericNew(Invert_type, NULL, NULL);

if (!Invert_singleton) return 0;

Not_type = make_type("Not", unaryop_type, NULL, 0);

if (!Not_type) return 0;

Not_singleton = PyType_GenericNew(Not_type, NULL, NULL);

if (!Not_singleton) return 0;

UAdd_type = make_type("UAdd", unaryop_type, NULL, 0);

if (!UAdd_type) return 0;

UAdd_singleton = PyType_GenericNew(UAdd_type, NULL, NULL);

if (!UAdd_singleton) return 0;

USub_type = make_type("USub", unaryop_type, NULL, 0);

if (!USub_type) return 0;

USub_singleton = PyType_GenericNew(USub_type, NULL, NULL);

if (!USub_singleton) return 0;

cmpop_type = make_type("cmpop", &AST_type, NULL, 0);

if (!cmpop_type) return 0;

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

Eq_type = make_type("Eq", cmpop_type, NULL, 0);

if (!Eq_type) return 0;

Eq_singleton = PyType_GenericNew(Eq_type, NULL, NULL);

if (!Eq_singleton) return 0;

NotEq_type = make_type("NotEq", cmpop_type, NULL, 0);

if (!NotEq_type) return 0;

NotEq_singleton = PyType_GenericNew(NotEq_type, NULL, NULL);

if (!NotEq_singleton) return 0;

Lt_type = make_type("Lt", cmpop_type, NULL, 0);

if (!Lt_type) return 0;

Lt_singleton = PyType_GenericNew(Lt_type, NULL, NULL);

if (!Lt_singleton) return 0;

LtE_type = make_type("LtE", cmpop_type, NULL, 0);

if (!LtE_type) return 0;

LtE_singleton = PyType_GenericNew(LtE_type, NULL, NULL);

if (!LtE_singleton) return 0;

Gt_type = make_type("Gt", cmpop_type, NULL, 0);

if (!Gt_type) return 0;

Gt_singleton = PyType_GenericNew(Gt_type, NULL, NULL);

if (!Gt_singleton) return 0;

GtE_type = make_type("GtE", cmpop_type, NULL, 0);

if (!GtE_type) return 0;

GtE_singleton = PyType_GenericNew(GtE_type, NULL, NULL);

if (!GtE_singleton) return 0;

Is_type = make_type("Is", cmpop_type, NULL, 0);

if (!Is_type) return 0;

Is_singleton = PyType_GenericNew(Is_type, NULL, NULL);

if (!Is_singleton) return 0;

IsNot_type = make_type("IsNot", cmpop_type, NULL, 0);

if (!IsNot_type) return 0;

IsNot_singleton = PyType_GenericNew(IsNot_type, NULL, NULL);

if (!IsNot_singleton) return 0;

In_type = make_type("In", cmpop_type, NULL, 0);

if (!In_type) return 0;

In_singleton = PyType_GenericNew(In_type, NULL, NULL);

if (!In_singleton) return 0;

NotIn_type = make_type("NotIn", cmpop_type, NULL, 0);

if (!NotIn_type) return 0;

NotIn_singleton = PyType_GenericNew(NotIn_type, NULL, NULL);

if (!NotIn_singleton) return 0;

comprehension_type = make_type("comprehension", &AST_type,

comprehension_fields, 3);

if (!comprehension_type) return 0;

excepthandler_type = make_type("excepthandler", &AST_type, NULL, 0);

if (!excepthandler_type) return 0;

if (!add_attributes(excepthandler_type, excepthandler_attributes, 2))

return 0;

ExceptHandler_type = make_type("ExceptHandler", excepthandler_type,

ExceptHandler_fields, 3);

if (!ExceptHandler_type) return 0;

arguments_type = make_type("arguments", &AST_type, arguments_fields, 8);

if (!arguments_type) return 0;

arg_type = make_type("arg", &AST_type, arg_fields, 2);

if (!arg_type) return 0;

keyword_type = make_type("keyword", &AST_type, keyword_fields, 2);

if (!keyword_type) return 0;

alias_type = make_type("alias", &AST_type, alias_fields, 2);

if (!alias_type) return 0;

initialized = 1;

return 1;

}

static int obj2ast_mod(PyObject* obj, mod_ty* out, PyArena* arena);

static int obj2ast_stmt(PyObject* obj, stmt_ty* out, PyArena* arena);

static int obj2ast_expr(PyObject* obj, expr_ty* out, PyArena* arena);

static int obj2ast_expr_context(PyObject* obj, expr_context_ty* out, PyArena*

arena);

static int obj2ast_slice(PyObject* obj, slice_ty* out, PyArena* arena);

static int obj2ast_boolop(PyObject* obj, boolop_ty* out, PyArena* arena);

static int obj2ast_operator(PyObject* obj, operator_ty* out, PyArena* arena);

static int obj2ast_unaryop(PyObject* obj, unaryop_ty* out, PyArena* arena);

static int obj2ast_cmpop(PyObject* obj, cmpop_ty* out, PyArena* arena);

static int obj2ast_comprehension(PyObject* obj, comprehension_ty* out, PyArena*

arena);

static int obj2ast_excepthandler(PyObject* obj, excepthandler_ty* out, PyArena*

arena);

static int obj2ast_arguments(PyObject* obj, arguments_ty* out, PyArena* arena);

static int obj2ast_arg(PyObject* obj, arg_ty* out, PyArena* arena);

static int obj2ast_keyword(PyObject* obj, keyword_ty* out, PyArena* arena);

static int obj2ast_alias(PyObject* obj, alias_ty* out, PyArena* arena);

Module(asdl_seq * body, 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;

return p;

}

Interactive(asdl_seq * body, PyArena *arena)

{

mod_ty p;

p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));

if (!p)

return NULL;

p->kind = Interactive_kind;

p->v.Interactive.body = body;

return p;

}

Expression(expr_ty body, PyArena *arena)