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

/*

   __version__ 62047.

   This module must be committed separately after each AST grammar change;

   The __version__ number is set to the revision number of the commit

   containing the grammar change.

*/

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

};

static PyTypeObject *ClassDef_type;

static char *ClassDef_fields[]={

        "name",

        "bases",

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

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

}

/* Pickling support */

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_compare */

    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 = 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 = PyTuple_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;

        }

        PyTuple_SET_ITEM(l, i, s);

    }

    result = PyObject_SetAttrString((PyObject*)type, "_attributes", l) >= 0;

    Py_DECREF(l);

    return result;

}