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

#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",

"decorators",

};

static PyTypeObject *ClassDef_type;

static char *ClassDef_fields[]={

"name",

"bases",

"body",

};

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

static char *Print_fields[]={

"dest",

"values",

"nl",

};

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

"type",

"inst",

"tback",

};

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

static char *Exec_fields[]={

"body",

"globals",

"locals",

};

static PyTypeObject *Global_type;

static char *Global_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 *ListComp_type;

static char *ListComp_fields[]={

"elt",

"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 *Repr_type;

static char *Repr_fields[]={

"value",

};

static PyTypeObject *Num_type;

static char *Num_fields[]={

"n",

};

static PyTypeObject *Str_type;

static char *Str_fields[]={

"s",

};

static PyTypeObject *Attribute_type;

static char *Attribute_fields[]={

"value",

"attr",

"ctx",

};

static PyTypeObject *Subscript_type;

static char *Subscript_fields[]={

"value",

"slice",

"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 *Ellipsis_type;

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 PyObject* ast2obj_excepthandler(void*);

static char *excepthandler_fields[]={

"type",

"name",

"body",

"lineno",

"col_offset",

};

static PyTypeObject *arguments_type;

static PyObject* ast2obj_arguments(void*);

static char *arguments_fields[]={

"args",

"vararg",

"kwarg",

"defaults",

};

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 PyTypeObject* make_type(char *type, PyTypeObject* base, char**fields, int num_fields)

{

PyObject *fnames, *result;

int i;

if (num_fields) {

fnames = PyTuple_New(num_fields);

if (!fnames) return NULL;

} else {

fnames = Py_None;

Py_INCREF(Py_None);

}

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

PyObject *field = PyString_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 = PyList_New(num_fields);

if (!l) return 0;

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

s = PyString_FromString(attrs[i]);

if (!s) {

Py_DECREF(l);

return 0;

}

PyList_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_bool(bool b)

{

return PyBool_FromLong(b);

}

static PyObject* ast2obj_int(bool b)

{

return PyInt_FromLong(b);

}

static int init_types(void)

{

static int initialized;

if (initialized) return 1;

AST_type = make_type("AST", &PyBaseObject_Type, NULL, 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, 4);

if (!FunctionDef_type) return 0;

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

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;

Print_type = make_type("Print", stmt_type, Print_fields, 3);

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

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;

Exec_type = make_type("Exec", stmt_type, Exec_fields, 3);

if (!Exec_type) return 0;

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

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

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

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

Repr_type = make_type("Repr", expr_type, Repr_fields, 1);

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

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;

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;

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

if (!Ellipsis_type) 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,

excepthandler_fields, 5);

if (!excepthandler_type) return 0;

arguments_type = make_type("arguments", AST_type, arguments_fields, 4);

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

}

mod_ty

Module(asdl_seq * body, PyArena *arena)

{

mod_ty p;

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

if (!p) {

PyErr_NoMemory();

return NULL;

}

p->kind = Module_kind;

p->v.Module.body = body;

return p;

}

mod_ty

Interactive(asdl_seq * body, PyArena *arena)

{

mod_ty p;

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

if (!p) {

PyErr_NoMemory();

return NULL;

}

p->kind = Interactive_kind;

p->v.Interactive.body = body;

return p;

}

mod_ty

Expression(expr_ty body, PyArena *arena)

{

mod_ty p;

if (!body) {

PyErr_SetString(PyExc_ValueError,

"field body is required for Expression");

return NULL;

}

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

if (!p) {

PyErr_NoMemory();

return NULL;

}

p->kind = Expression_kind;

p->v.Expression.body = body;

return p;

}

mod_ty

Suite(asdl_seq * body, PyArena *arena)

{

mod_ty p;

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

if (!p) {

PyErr_NoMemory();

return NULL;

}

p->kind = Suite_kind;

p->v.Suite.body = body;

return p;

}

stmt_ty

FunctionDef(identifier name, arguments_ty args, asdl_seq * body, asdl_seq *

decorators, int lineno, int col_offset, PyArena *arena)

{

stmt_ty p;

if (!name) {

PyErr_SetString(PyExc_ValueError,

"field name is required for FunctionDef");

return NULL;

}

if (!args) {

PyErr_SetString(PyExc_ValueError,

"field args is required for FunctionDef");

return NULL;

}

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

if (!p) {

PyErr_NoMemory();

return NULL;

}

p->kind = FunctionDef_kind;

p->v.FunctionDef.name = name;

p->v.FunctionDef.args = args;

p->v.FunctionDef.body = body;

p->v.FunctionDef.decorators = decorators;

p->lineno = lineno;

p->col_offset = col_offset;

return p;

}

stmt_ty

ClassDef(identifier name, asdl_seq * bases, asdl_seq * body, int lineno, int

col_offset, PyArena *arena)

{

stmt_ty p;

if (!name) {

PyErr_SetString(PyExc_ValueError,

"field name is required for ClassDef");

return NULL;

}

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

if (!p) {

PyErr_NoMemory();

return NULL;

}

p->kind = ClassDef_kind;

p->v.ClassDef.name = name;

p->v.ClassDef.bases = bases;

p->v.ClassDef.body = body;

p->lineno = lineno;

p->col_offset = col_offset;

return p;

}

stmt_ty

Return(expr_ty value, int lineno, int col_offset, PyArena *arena)

{

stmt_ty p;

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

if (!p) {

PyErr_NoMemory();

return NULL;

}

p->kind = Return_kind;

p->v.Return.value = value;

p->lineno = lineno;

p->col_offset = col_offset;

return p;

}

stmt_ty

Delete(asdl_seq * targets, int lineno, int col_offset, PyArena *arena)

{

stmt_ty p;

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

if (!p) {

PyErr_NoMemory();

return NULL;

}

p->kind = Delete_kind;

p->v.Delete.targets = targets;

p->lineno = lineno;

p->col_offset = col_offset;

return p;

}

stmt_ty

Assign(asdl_seq * targets, expr_ty value, int lineno, int col_offset, PyArena

*arena)

{

stmt_ty p;

if (!value) {

PyErr_SetString(PyExc_ValueError,

"field value is required for Assign");

return NULL;

}

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

if (!p) {

PyErr_NoMemory();

return NULL;

}

p->kind = Assign_kind;

p->v.Assign.targets = targets;

p->v.Assign.value = value;

p->lineno = lineno;

p->col_offset = col_offset;

return p;

}

stmt_ty

AugAssign(expr_ty target, operator_ty op, expr_ty value, int lineno, int

col_offset, PyArena *arena)

{

stmt_ty p;

if (!target) {

PyErr_SetString(PyExc_ValueError,

"field target is required for AugAssign");

return NULL;

}

if (!op) {

PyErr_SetString(PyExc_ValueError,

"field op is required for AugAssign");

return NULL;

}

if (!value) {

PyErr_SetString(PyExc_ValueError,

"field value is required for AugAssign");

return NULL;

}

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

if (!p) {

PyErr_NoMemory();

return NULL;

}

p->kind = AugAssign_kind;

p->v.AugAssign.target = target;

p->v.AugAssign.op = op;

p->v.AugAssign.value = value;

p->lineno = lineno;

p->col_offset = col_offset;

return p;

}

stmt_ty

Print(expr_ty dest, asdl_seq * values, bool nl, int lineno, int col_offset,

PyArena *arena)

{

stmt_ty p;

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

if (!p) {

PyErr_NoMemory();

return NULL;

}

p->kind = Print_kind;

p->v.Print.dest = dest;

p->v.Print.values = values;

p->v.Print.nl = nl;

p->lineno = lineno;

p->col_offset = col_offset;

return p;

}

stmt_ty

For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * orelse, int

lineno, int col_offset, PyArena *arena)

{

stmt_ty p;

if (!target) {

PyErr_SetString(PyExc_ValueError,

"field target is required for For");

return NULL;

}

if (!iter) {

PyErr_SetString(PyExc_ValueError,

"field iter is required for For");

return NULL;

}

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

if (!p) {

PyErr_NoMemory();

return NULL;

}

p->kind = For_kind;

p->v.For.target = target;

p->v.For.iter = iter;

p->v.For.body = body;

p->v.For.orelse = orelse;

p->lineno = lineno;

p->col_offset = col_offset;

return p;

}

stmt_ty

While(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, int

col_offset, PyArena *arena)

{

stmt_ty p;

if (!test) {

PyErr_SetString(PyExc_ValueError,

"field test is required for While");

return NULL;

}

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

if (!p) {

PyErr_NoMemory();

return NULL;

}

p->kind = While_kind;

p->v.While.test = test;

p->v.While.body = body;

p->v.While.orelse = orelse;