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

     2 

     3 

     4 /*

     5    __version__ 62047.

     6 

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

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

     9    containing the grammar change.

    10 */

    11 

    12 #include "Python.h"

    13 #include "Python-ast.h"

    14 

    15 static PyTypeObject AST_type;

    16 static PyTypeObject *mod_type;

    17 static PyObject* ast2obj_mod(void*);

    18 static PyTypeObject *Module_type;

    19 static char *Module_fields[]={

    20         "body",

    21 };

    22 static PyTypeObject *Interactive_type;

    23 static char *Interactive_fields[]={

    24         "body",

    25 };

    26 static PyTypeObject *Expression_type;

    27 static char *Expression_fields[]={

    28         "body",

    29 };

    30 static PyTypeObject *Suite_type;

    31 static char *Suite_fields[]={

    32         "body",

    33 };

    34 static PyTypeObject *stmt_type;

    35 static char *stmt_attributes[] = {

    36         "lineno",

    37         "col_offset",

    38 };

    39 static PyObject* ast2obj_stmt(void*);

    40 static PyTypeObject *FunctionDef_type;

    41 static char *FunctionDef_fields[]={

    42         "name",

    43         "args",

    44         "body",

    45         "decorator_list",

    46 };

    47 static PyTypeObject *ClassDef_type;

    48 static char *ClassDef_fields[]={

    49         "name",

    50         "bases",

    51         "body",

    52         "decorator_list",

    53 };

    54 static PyTypeObject *Return_type;

    55 static char *Return_fields[]={

    56         "value",

    57 };

    58 static PyTypeObject *Delete_type;

    59 static char *Delete_fields[]={

    60         "targets",

    61 };

    62 static PyTypeObject *Assign_type;

    63 static char *Assign_fields[]={

    64         "targets",

    65         "value",

    66 };

    67 static PyTypeObject *AugAssign_type;

    68 static char *AugAssign_fields[]={

    69         "target",

    70         "op",

    71         "value",

    72 };

    73 static PyTypeObject *Print_type;

    74 static char *Print_fields[]={

    75         "dest",

    76         "values",

    77         "nl",

    78 };

    79 static PyTypeObject *For_type;

    80 static char *For_fields[]={

    81         "target",

    82         "iter",

    83         "body",

    84         "orelse",

    85 };

    86 static PyTypeObject *While_type;

    87 static char *While_fields[]={

    88         "test",

    89         "body",

    90         "orelse",

    91 };

    92 static PyTypeObject *If_type;

    93 static char *If_fields[]={

    94         "test",

    95         "body",

    96         "orelse",

    97 };

    98 static PyTypeObject *With_type;

    99 static char *With_fields[]={

   100         "context_expr",

   101         "optional_vars",

   102         "body",

   103 };

   104 static PyTypeObject *Raise_type;

   105 static char *Raise_fields[]={

   106         "type",

   107         "inst",

   108         "tback",

   109 };

   110 static PyTypeObject *TryExcept_type;

   111 static char *TryExcept_fields[]={

   112         "body",

   113         "handlers",

   114         "orelse",

   115 };

   116 static PyTypeObject *TryFinally_type;

   117 static char *TryFinally_fields[]={

   118         "body",

   119         "finalbody",

   120 };

   121 static PyTypeObject *Assert_type;

   122 static char *Assert_fields[]={

   123         "test",

   124         "msg",

   125 };

   126 static PyTypeObject *Import_type;

   127 static char *Import_fields[]={

   128         "names",

   129 };

   130 static PyTypeObject *ImportFrom_type;

   131 static char *ImportFrom_fields[]={

   132         "module",

   133         "names",

   134         "level",

   135 };

   136 static PyTypeObject *Exec_type;

   137 static char *Exec_fields[]={

   138         "body",

   139         "globals",

   140         "locals",

   141 };

   142 static PyTypeObject *Global_type;

   143 static char *Global_fields[]={

   144         "names",

   145 };

   146 static PyTypeObject *Expr_type;

   147 static char *Expr_fields[]={

   148         "value",

   149 };

   150 static PyTypeObject *Pass_type;

   151 static PyTypeObject *Break_type;

   152 static PyTypeObject *Continue_type;

   153 static PyTypeObject *expr_type;

   154 static char *expr_attributes[] = {

   155         "lineno",

   156         "col_offset",

   157 };

   158 static PyObject* ast2obj_expr(void*);

   159 static PyTypeObject *BoolOp_type;

   160 static char *BoolOp_fields[]={

   161         "op",

   162         "values",

   163 };

   164 static PyTypeObject *BinOp_type;

   165 static char *BinOp_fields[]={

   166         "left",

   167         "op",

   168         "right",

   169 };

   170 static PyTypeObject *UnaryOp_type;

   171 static char *UnaryOp_fields[]={

   172         "op",

   173         "operand",

   174 };

   175 static PyTypeObject *Lambda_type;

   176 static char *Lambda_fields[]={

   177         "args",

   178         "body",

   179 };

   180 static PyTypeObject *IfExp_type;

   181 static char *IfExp_fields[]={

   182         "test",

   183         "body",

   184         "orelse",

   185 };

   186 static PyTypeObject *Dict_type;

   187 static char *Dict_fields[]={

   188         "keys",

   189         "values",

   190 };

   191 static PyTypeObject *ListComp_type;

   192 static char *ListComp_fields[]={

   193         "elt",

   194         "generators",

   195 };

   196 static PyTypeObject *GeneratorExp_type;

   197 static char *GeneratorExp_fields[]={

   198         "elt",

   199         "generators",

   200 };

   201 static PyTypeObject *Yield_type;

   202 static char *Yield_fields[]={

   203         "value",

   204 };

   205 static PyTypeObject *Compare_type;

   206 static char *Compare_fields[]={

   207         "left",

   208         "ops",

   209         "comparators",

   210 };

   211 static PyTypeObject *Call_type;

   212 static char *Call_fields[]={

   213         "func",

   214         "args",

   215         "keywords",

   216         "starargs",

   217         "kwargs",

   218 };

   219 static PyTypeObject *Repr_type;

   220 static char *Repr_fields[]={

   221         "value",

   222 };

   223 static PyTypeObject *Num_type;

   224 static char *Num_fields[]={

   225         "n",

   226 };

   227 static PyTypeObject *Str_type;

   228 static char *Str_fields[]={

   229         "s",

   230 };

   231 static PyTypeObject *Attribute_type;

   232 static char *Attribute_fields[]={

   233         "value",

   234         "attr",

   235         "ctx",

   236 };

   237 static PyTypeObject *Subscript_type;

   238 static char *Subscript_fields[]={

   239         "value",

   240         "slice",

   241         "ctx",

   242 };

   243 static PyTypeObject *Name_type;

   244 static char *Name_fields[]={

   245         "id",

   246         "ctx",

   247 };

   248 static PyTypeObject *List_type;

   249 static char *List_fields[]={

   250         "elts",

   251         "ctx",

   252 };

   253 static PyTypeObject *Tuple_type;

   254 static char *Tuple_fields[]={

   255         "elts",

   256         "ctx",

   257 };

   258 static PyTypeObject *expr_context_type;

   259 static PyObject *Load_singleton, *Store_singleton, *Del_singleton,

   260 *AugLoad_singleton, *AugStore_singleton, *Param_singleton;

   261 static PyObject* ast2obj_expr_context(expr_context_ty);

   262 static PyTypeObject *Load_type;

   263 static PyTypeObject *Store_type;

   264 static PyTypeObject *Del_type;

   265 static PyTypeObject *AugLoad_type;

   266 static PyTypeObject *AugStore_type;

   267 static PyTypeObject *Param_type;

   268 static PyTypeObject *slice_type;

   269 static PyObject* ast2obj_slice(void*);

   270 static PyTypeObject *Ellipsis_type;

   271 static PyTypeObject *Slice_type;

   272 static char *Slice_fields[]={

   273         "lower",

   274         "upper",

   275         "step",

   276 };

   277 static PyTypeObject *ExtSlice_type;

   278 static char *ExtSlice_fields[]={

   279         "dims",

   280 };

   281 static PyTypeObject *Index_type;

   282 static char *Index_fields[]={

   283         "value",

   284 };

   285 static PyTypeObject *boolop_type;

   286 static PyObject *And_singleton, *Or_singleton;

   287 static PyObject* ast2obj_boolop(boolop_ty);

   288 static PyTypeObject *And_type;

   289 static PyTypeObject *Or_type;

   290 static PyTypeObject *operator_type;

   291 static PyObject *Add_singleton, *Sub_singleton, *Mult_singleton,

   292 *Div_singleton, *Mod_singleton, *Pow_singleton, *LShift_singleton,

   293 *RShift_singleton, *BitOr_singleton, *BitXor_singleton, *BitAnd_singleton,

   294 *FloorDiv_singleton;

   295 static PyObject* ast2obj_operator(operator_ty);

   296 static PyTypeObject *Add_type;

   297 static PyTypeObject *Sub_type;

   298 static PyTypeObject *Mult_type;

   299 static PyTypeObject *Div_type;

   300 static PyTypeObject *Mod_type;

   301 static PyTypeObject *Pow_type;

   302 static PyTypeObject *LShift_type;

   303 static PyTypeObject *RShift_type;

   304 static PyTypeObject *BitOr_type;

   305 static PyTypeObject *BitXor_type;

   306 static PyTypeObject *BitAnd_type;

   307 static PyTypeObject *FloorDiv_type;

   308 static PyTypeObject *unaryop_type;

   309 static PyObject *Invert_singleton, *Not_singleton, *UAdd_singleton,

   310 *USub_singleton;

   311 static PyObject* ast2obj_unaryop(unaryop_ty);

   312 static PyTypeObject *Invert_type;

   313 static PyTypeObject *Not_type;

   314 static PyTypeObject *UAdd_type;

   315 static PyTypeObject *USub_type;

   316 static PyTypeObject *cmpop_type;

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

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

   319 *NotIn_singleton;

   320 static PyObject* ast2obj_cmpop(cmpop_ty);

   321 static PyTypeObject *Eq_type;

   322 static PyTypeObject *NotEq_type;

   323 static PyTypeObject *Lt_type;

   324 static PyTypeObject *LtE_type;

   325 static PyTypeObject *Gt_type;

   326 static PyTypeObject *GtE_type;

   327 static PyTypeObject *Is_type;

   328 static PyTypeObject *IsNot_type;

   329 static PyTypeObject *In_type;

   330 static PyTypeObject *NotIn_type;

   331 static PyTypeObject *comprehension_type;

   332 static PyObject* ast2obj_comprehension(void*);

   333 static char *comprehension_fields[]={

   334         "target",

   335         "iter",

   336         "ifs",

   337 };

   338 static PyTypeObject *excepthandler_type;

   339 static char *excepthandler_attributes[] = {

   340         "lineno",

   341         "col_offset",

   342 };

   343 static PyObject* ast2obj_excepthandler(void*);

   344 static PyTypeObject *ExceptHandler_type;

   345 static char *ExceptHandler_fields[]={

   346         "type",

   347         "name",

   348         "body",

   349 };

   350 static PyTypeObject *arguments_type;

   351 static PyObject* ast2obj_arguments(void*);

   352 static char *arguments_fields[]={

   353         "args",

   354         "vararg",

   355         "kwarg",

   356         "defaults",

   357 };

   358 static PyTypeObject *keyword_type;

   359 static PyObject* ast2obj_keyword(void*);

   360 static char *keyword_fields[]={

   361         "arg",

   362         "value",

   363 };

   364 static PyTypeObject *alias_type;

   365 static PyObject* ast2obj_alias(void*);

   366 static char *alias_fields[]={

   367         "name",

   368         "asname",

   369 };

   370 

   371 

   372 static int

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

   374 {

   375     Py_ssize_t i, numfields = 0;

   376     int res = -1;

   377     PyObject *key, *value, *fields;

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

   379     if (!fields)

   380         PyErr_Clear();

   381     if (fields) {

   382         numfields = PySequence_Size(fields);

   383         if (numfields == -1)

   384             goto cleanup;

   385     }

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

   387     if (PyTuple_GET_SIZE(args) > 0) {

   388         if (numfields != PyTuple_GET_SIZE(args)) {

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

   390                          "%zd positional argument%s",

   391                          Py_TYPE(self)->tp_name,

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

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

   394             res = -1;

   395             goto cleanup;

   396         }

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

   398             /* cannot be reached when fields is NULL */

   399             PyObject *name = PySequence_GetItem(fields, i);

   400             if (!name) {

   401                 res = -1;

   402                 goto cleanup;

   403             }

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

   405             Py_DECREF(name);

   406             if (res < 0)

   407                 goto cleanup;

   408         }

   409     }

   410     if (kw) {

   411         i = 0;  /* needed by PyDict_Next */

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

   413             res = PyObject_SetAttr(self, key, value);

   414             if (res < 0)

   415                 goto cleanup;

   416         }

   417     }

   418   cleanup:

   419     Py_XDECREF(fields);

   420     return res;

   421 }

   422 

   423 /* Pickling support */

   424 static PyObject *

   425 ast_type_reduce(PyObject *self, PyObject *unused)

   426 {

   427     PyObject *res;

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

   429     if (dict == NULL) {

   430         if (PyErr_ExceptionMatches(PyExc_AttributeError))

   431             PyErr_Clear();

   432         else

   433             return NULL;

   434     }

   435     if (dict) {

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

   437         Py_DECREF(dict);

   438         return res;

   439     }

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

   441 }

   442 

   443 static PyMethodDef ast_type_methods[] = {

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

   445     {NULL}

   446 };

   447 

   448 static PyTypeObject AST_type = {

   449     PyVarObject_HEAD_INIT(&PyType_Type, 0)

   450     "_ast.AST",

   451     sizeof(PyObject),

   452     0,

   453     0,                       /* tp_dealloc */

   454     0,                       /* tp_print */

   455     0,                       /* tp_getattr */

   456     0,                       /* tp_setattr */

   457     0,                       /* tp_compare */

   458     0,                       /* tp_repr */

   459     0,                       /* tp_as_number */

   460     0,                       /* tp_as_sequence */

   461     0,                       /* tp_as_mapping */

   462     0,                       /* tp_hash */

   463     0,                       /* tp_call */

   464     0,                       /* tp_str */

   465     PyObject_GenericGetAttr, /* tp_getattro */

   466     PyObject_GenericSetAttr, /* tp_setattro */

   467     0,                       /* tp_as_buffer */

   468     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */

   469     0,                       /* tp_doc */

   470     0,                       /* tp_traverse */

   471     0,                       /* tp_clear */

   472     0,                       /* tp_richcompare */

   473     0,                       /* tp_weaklistoffset */

   474     0,                       /* tp_iter */

   475     0,                       /* tp_iternext */

   476     ast_type_methods,        /* tp_methods */

   477     0,                       /* tp_members */

   478     0,                       /* tp_getset */

   479     0,                       /* tp_base */

   480     0,                       /* tp_dict */

   481     0,                       /* tp_descr_get */

   482     0,                       /* tp_descr_set */

   483     0,                       /* tp_dictoffset */

   484     (initproc)ast_type_init, /* tp_init */

   485     PyType_GenericAlloc,     /* tp_alloc */

   486     PyType_GenericNew,       /* tp_new */

   487     PyObject_Del,            /* tp_free */

   488 };

   489 

   490 

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

   492 {

   493     PyObject *fnames, *result;

   494     int i;

   495     fnames = PyTuple_New(num_fields);

   496     if (!fnames) return NULL;

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

   498         PyObject *field = PyString_FromString(fields[i]);

   499         if (!field) {

   500             Py_DECREF(fnames);

   501             return NULL;

   502         }

   503         PyTuple_SET_ITEM(fnames, i, field);

   504     }

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

   506                     type, base, "_fields", fnames, "__module__", "_ast");

   507     Py_DECREF(fnames);

   508     return (PyTypeObject*)result;

   509 }

   510 

   511 static int add_attributes(PyTypeObject* type, char**attrs, int num_fields)

   512 {

   513     int i, result;

   514     PyObject *s, *l = PyTuple_New(num_fields);

   515     if (!l) return 0;

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

   517         s = PyString_FromString(attrs[i]);

   518         if (!s) {

   519             Py_DECREF(l);

   520             return 0;

   521         }

   522         PyTuple_SET_ITEM(l, i, s);

   523     }

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

   525     Py_DECREF(l);

   526     return result;

   527 }

   528 

   529 /* Conversion AST -> Python */

   530 

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

   532 {

   533     int i, n = asdl_seq_LEN(seq);

   534     PyObject *result = PyList_New(n);

   535     PyObject *value;

   536     if (!result)

   537         return NULL;

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

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

   540         if (!value) {

   541             Py_DECREF(result);

   542             return NULL;

   543         }

   544         PyList_SET_ITEM(result, i, value);

   545     }

   546     return result;

   547 }

   548 

   549 static PyObject* ast2obj_object(void *o)

   550 {

   551     if (!o)

   552         o = Py_None;

   553     Py_INCREF((PyObject*)o);

   554     return (PyObject*)o;

   555 }

   556 #define ast2obj_identifier ast2obj_object

   557 #define ast2obj_string ast2obj_object

   558 static PyObject* ast2obj_bool(bool b)

   559 {

   560     return PyBool_FromLong(b);

   561 }

   562 

   563 static PyObject* ast2obj_int(long b)

   564 {

   565     return PyInt_FromLong(b);

   566 }

   567 

   568 /* Conversion Python -> AST */

   569 

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

   571 {

   572     if (obj == Py_None)

   573         obj = NULL;

   574     if (obj)

   575         PyArena_AddPyObject(arena, obj);

   576     Py_XINCREF(obj);

   577     *out = obj;

   578     return 0;

   579 }

   580 

   581 #define obj2ast_identifier obj2ast_object

   582 #define obj2ast_string obj2ast_object

   583 

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

   585 {

   586     int i;

   587     if (!PyInt_Check(obj) && !PyLong_Check(obj)) {

   588         PyObject *s = PyObject_Repr(obj);

   589         if (s == NULL) return 1;

   590         PyErr_Format(PyExc_ValueError, "invalid integer value: %.400s",

   591                      PyString_AS_STRING(s));

   592         Py_DECREF(s);

   593         return 1;

   594     }

   595 

   596     i = (int)PyLong_AsLong(obj);

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

   598         return 1;

   599     *out = i;

   600     return 0;

   601 }

   602 

   603 static int obj2ast_bool(PyObject* obj, bool* out, PyArena* arena)

   604 {

   605     if (!PyBool_Check(obj)) {

   606         PyObject *s = PyObject_Repr(obj);

   607         if (s == NULL) return 1;

   608         PyErr_Format(PyExc_ValueError, "invalid boolean value: %.400s",

   609                      PyString_AS_STRING(s));

   610         Py_DECREF(s);

   611         return 1;

   612     }

   613 

   614     *out = (obj == Py_True);

   615     return 0;

   616 }

   617 

   618 static int add_ast_fields(void)

   619 {

   620     PyObject *empty_tuple, *d;

   621     if (PyType_Ready(&AST_type) < 0)

   622         return -1;

   623     d = AST_type.tp_dict;

   624     empty_tuple = PyTuple_New(0);

   625     if (!empty_tuple ||

   626         PyDict_SetItemString(d, "_fields", empty_tuple) < 0 ||

   627         PyDict_SetItemString(d, "_attributes", empty_tuple) < 0) {

   628         Py_XDECREF(empty_tuple);

   629         return -1;

   630     }

   631     Py_DECREF(empty_tuple);

   632     return 0;

   633 }

   634 

   635 

   636 static int init_types(void)

   637 {

   638         static int initialized;

   639         if (initialized) return 1;

   640         if (add_ast_fields() < 0) return 0;

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

   642         if (!mod_type) return 0;

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

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

   645         if (!Module_type) return 0;

   646         Interactive_type = make_type("Interactive", mod_type,

   647                                      Interactive_fields, 1);

   648         if (!Interactive_type) return 0;

   649         Expression_type = make_type("Expression", mod_type, Expression_fields,

   650                                     1);

   651         if (!Expression_type) return 0;

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

   653         if (!Suite_type) return 0;

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

   655         if (!stmt_type) return 0;

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

   657         FunctionDef_type = make_type("FunctionDef", stmt_type,

   658                                      FunctionDef_fields, 4);

   659         if (!FunctionDef_type) return 0;

   660         ClassDef_type = make_type("ClassDef", stmt_type, ClassDef_fields, 4);

   661         if (!ClassDef_type) return 0;

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

   663         if (!Return_type) return 0;

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

   665         if (!Delete_type) return 0;

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

   667         if (!Assign_type) return 0;

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

   669         if (!AugAssign_type) return 0;

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

   671         if (!Print_type) return 0;

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

   673         if (!For_type) return 0;

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

   675         if (!While_type) return 0;

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

   677         if (!If_type) return 0;

   678         With_type = make_type("With", stmt_type, With_fields, 3);

   679         if (!With_type) return 0;

   680         Raise_type = make_type("Raise", stmt_type, Raise_fields, 3);

   681         if (!Raise_type) return 0;

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

   683         if (!TryExcept_type) return 0;

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

   685                                     2);

   686         if (!TryFinally_type) return 0;

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

   688         if (!Assert_type) return 0;

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

   690         if (!Import_type) return 0;

   691         ImportFrom_type = make_type("ImportFrom", stmt_type, ImportFrom_fields,

   692                                     3);

   693         if (!ImportFrom_type) return 0;

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

   695         if (!Exec_type) return 0;

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

   697         if (!Global_type) return 0;

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

   699         if (!Expr_type) return 0;

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

   701         if (!Pass_type) return 0;

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

   703         if (!Break_type) return 0;

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

   705         if (!Continue_type) return 0;

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

   707         if (!expr_type) return 0;

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

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

   710         if (!BoolOp_type) return 0;

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

   712         if (!BinOp_type) return 0;

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

   714         if (!UnaryOp_type) return 0;

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

   716         if (!Lambda_type) return 0;

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

   718         if (!IfExp_type) return 0;

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

   720         if (!Dict_type) return 0;

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

   722         if (!ListComp_type) return 0;

   723         GeneratorExp_type = make_type("GeneratorExp", expr_type,

   724                                       GeneratorExp_fields, 2);

   725         if (!GeneratorExp_type) return 0;

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

   727         if (!Yield_type) return 0;

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

   729         if (!Compare_type) return 0;

   730         Call_type = make_type("Call", expr_type, Call_fields, 5);

   731         if (!Call_type) return 0;

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

   733         if (!Repr_type) return 0;

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

   735         if (!Num_type) return 0;

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

   737         if (!Str_type) return 0;

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

   739         if (!Attribute_type) return 0;

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

   741         if (!Subscript_type) return 0;

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

   743         if (!Name_type) return 0;

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

   745         if (!List_type) return 0;

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

   747         if (!Tuple_type) return 0;

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

   749         if (!expr_context_type) return 0;

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

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

   752         if (!Load_type) return 0;

   753         Load_singleton = PyType_GenericNew(Load_type, NULL, NULL);

   754         if (!Load_singleton) return 0;

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

   756         if (!Store_type) return 0;

   757         Store_singleton = PyType_GenericNew(Store_type, NULL, NULL);

   758         if (!Store_singleton) return 0;

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

   760         if (!Del_type) return 0;

   761         Del_singleton = PyType_GenericNew(Del_type, NULL, NULL);

   762         if (!Del_singleton) return 0;

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

   764         if (!AugLoad_type) return 0;

   765         AugLoad_singleton = PyType_GenericNew(AugLoad_type, NULL, NULL);

   766         if (!AugLoad_singleton) return 0;

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

   768         if (!AugStore_type) return 0;

   769         AugStore_singleton = PyType_GenericNew(AugStore_type, NULL, NULL);

   770         if (!AugStore_singleton) return 0;

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

   772         if (!Param_type) return 0;

   773         Param_singleton = PyType_GenericNew(Param_type, NULL, NULL);

   774         if (!Param_singleton) return 0;

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

   776         if (!slice_type) return 0;

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

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

   779         if (!Ellipsis_type) return 0;

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

   781         if (!Slice_type) return 0;

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

   783         if (!ExtSlice_type) return 0;

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

   785         if (!Index_type) return 0;

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

   787         if (!boolop_type) return 0;

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

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

   790         if (!And_type) return 0;

   791         And_singleton = PyType_GenericNew(And_type, NULL, NULL);

   792         if (!And_singleton) return 0;

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

   794         if (!Or_type) return 0;

   795         Or_singleton = PyType_GenericNew(Or_type, NULL, NULL);

   796         if (!Or_singleton) return 0;

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

   798         if (!operator_type) return 0;

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

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

   801         if (!Add_type) return 0;

   802         Add_singleton = PyType_GenericNew(Add_type, NULL, NULL);

   803         if (!Add_singleton) return 0;

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

   805         if (!Sub_type) return 0;

   806         Sub_singleton = PyType_GenericNew(Sub_type, NULL, NULL);

   807         if (!Sub_singleton) return 0;

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

   809         if (!Mult_type) return 0;

   810         Mult_singleton = PyType_GenericNew(Mult_type, NULL, NULL);

   811         if (!Mult_singleton) return 0;

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

   813         if (!Div_type) return 0;

   814         Div_singleton = PyType_GenericNew(Div_type, NULL, NULL);

   815         if (!Div_singleton) return 0;

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

   817         if (!Mod_type) return 0;

   818         Mod_singleton = PyType_GenericNew(Mod_type, NULL, NULL);

   819         if (!Mod_singleton) return 0;

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

   821         if (!Pow_type) return 0;

   822         Pow_singleton = PyType_GenericNew(Pow_type, NULL, NULL);

   823         if (!Pow_singleton) return 0;

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

   825         if (!LShift_type) return 0;

   826         LShift_singleton = PyType_GenericNew(LShift_type, NULL, NULL);

   827         if (!LShift_singleton) return 0;

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

   829         if (!RShift_type) return 0;

   830         RShift_singleton = PyType_GenericNew(RShift_type, NULL, NULL);

   831         if (!RShift_singleton) return 0;

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

   833         if (!BitOr_type) return 0;

   834         BitOr_singleton = PyType_GenericNew(BitOr_type, NULL, NULL);

   835         if (!BitOr_singleton) return 0;

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

   837         if (!BitXor_type) return 0;

   838         BitXor_singleton = PyType_GenericNew(BitXor_type, NULL, NULL);

   839         if (!BitXor_singleton) return 0;

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

   841         if (!BitAnd_type) return 0;

   842         BitAnd_singleton = PyType_GenericNew(BitAnd_type, NULL, NULL);

   843         if (!BitAnd_singleton) return 0;

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

   845         if (!FloorDiv_type) return 0;

   846         FloorDiv_singleton = PyType_GenericNew(FloorDiv_type, NULL, NULL);

   847         if (!FloorDiv_singleton) return 0;

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

   849         if (!unaryop_type) return 0;

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

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

   852         if (!Invert_type) return 0;

   853         Invert_singleton = PyType_GenericNew(Invert_type, NULL, NULL);

   854         if (!Invert_singleton) return 0;

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

   856         if (!Not_type) return 0;

   857         Not_singleton = PyType_GenericNew(Not_type, NULL, NULL);

   858         if (!Not_singleton) return 0;

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

   860         if (!UAdd_type) return 0;

   861         UAdd_singleton = PyType_GenericNew(UAdd_type, NULL, NULL);

   862         if (!UAdd_singleton) return 0;

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

   864         if (!USub_type) return 0;

   865         USub_singleton = PyType_GenericNew(USub_type, NULL, NULL);

   866         if (!USub_singleton) return 0;

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

   868         if (!cmpop_type) return 0;

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

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

   871         if (!Eq_type) return 0;

   872         Eq_singleton = PyType_GenericNew(Eq_type, NULL, NULL);

   873         if (!Eq_singleton) return 0;

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

   875         if (!NotEq_type) return 0;

   876         NotEq_singleton = PyType_GenericNew(NotEq_type, NULL, NULL);

   877         if (!NotEq_singleton) return 0;

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

   879         if (!Lt_type) return 0;

   880         Lt_singleton = PyType_GenericNew(Lt_type, NULL, NULL);

   881         if (!Lt_singleton) return 0;

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

   883         if (!LtE_type) return 0;

   884         LtE_singleton = PyType_GenericNew(LtE_type, NULL, NULL);

   885         if (!LtE_singleton) return 0;

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

   887         if (!Gt_type) return 0;

   888         Gt_singleton = PyType_GenericNew(Gt_type, NULL, NULL);

   889         if (!Gt_singleton) return 0;

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

   891         if (!GtE_type) return 0;

   892         GtE_singleton = PyType_GenericNew(GtE_type, NULL, NULL);

   893         if (!GtE_singleton) return 0;

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

   895         if (!Is_type) return 0;

   896         Is_singleton = PyType_GenericNew(Is_type, NULL, NULL);

   897         if (!Is_singleton) return 0;

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

   899         if (!IsNot_type) return 0;

   900         IsNot_singleton = PyType_GenericNew(IsNot_type, NULL, NULL);

   901         if (!IsNot_singleton) return 0;

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

   903         if (!In_type) return 0;

   904         In_singleton = PyType_GenericNew(In_type, NULL, NULL);

   905         if (!In_singleton) return 0;

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

   907         if (!NotIn_type) return 0;

   908         NotIn_singleton = PyType_GenericNew(NotIn_type, NULL, NULL);

   909         if (!NotIn_singleton) return 0;

   910         comprehension_type = make_type("comprehension", &AST_type,

   911                                        comprehension_fields, 3);

   912         if (!comprehension_type) return 0;

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

   914         if (!excepthandler_type) return 0;

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

   916             return 0;

   917         ExceptHandler_type = make_type("ExceptHandler", excepthandler_type,

   918                                        ExceptHandler_fields, 3);

   919         if (!ExceptHandler_type) return 0;

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

   921         if (!arguments_type) return 0;

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

   923         if (!keyword_type) return 0;

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

   925         if (!alias_type) return 0;

   926         initialized = 1;

   927         return 1;

   928 }

   929 

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

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

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

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

   934                                 arena);

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

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

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

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

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

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

   941                                  arena);

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

   943                                  arena);

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

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

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

   947 

   948 mod_ty

   949 Module(asdl_seq * body, PyArena *arena)

   950 {

   951         mod_ty p;

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

   953         if (!p)

   954                 return NULL;

   955         p->kind = Module_kind;

   956         p->v.Module.body = body;

   957         return p;

   958 }

   959 

   960 mod_ty

   961 Interactive(asdl_seq * body, PyArena *arena)

   962 {

   963         mod_ty p;

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

   965         if (!p)

   966                 return NULL;

   967         p->kind = Interactive_kind;

   968         p->v.Interactive.body = body;

   969         return p;

   970 }

   971 

   972 mod_ty

   973 Expression(expr_ty body, PyArena *arena)

   974 {

   975         mod_ty p;

   976         if (!body) {

   977                 PyErr_SetString(PyExc_ValueError,

   978                                 "field body is required for Expression");

   979                 return NULL;

   980         }

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

   982         if (!p)

   983                 return NULL;

   984         p->kind = Expression_kind;

   985         p->v.Expression.body = body;

   986         return p;

   987 }

   988 

   989 mod_ty

   990 Suite(asdl_seq * body, PyArena *arena)

   991 {

   992         mod_ty p;

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

   994         if (!p)

   995                 return NULL;

   996         p->kind = Suite_kind;

   997         p->v.Suite.body = body;

   998         return p;

   999 }

  1000 

  1001 stmt_ty

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

  1003             decorator_list, int lineno, int col_offset, PyArena *arena)

  1004 {

  1005         stmt_ty p;

  1006         if (!name) {

  1007                 PyErr_SetString(PyExc_ValueError,

  1008                                 "field name is required for FunctionDef");

  1009                 return NULL;

  1010         }

  1011         if (!args) {

  1012                 PyErr_SetString(PyExc_ValueError,

  1013                                 "field args is required for FunctionDef");

  1014                 return NULL;

  1015         }

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

  1017         if (!p)

  1018                 return NULL;

  1019         p->kind = FunctionDef_kind;

  1020         p->v.FunctionDef.name = name;

  1021         p->v.FunctionDef.args = args;

  1022         p->v.FunctionDef.body = body;

  1023         p->v.FunctionDef.decorator_list = decorator_list;

  1024         p->lineno = lineno;

  1025         p->col_offset = col_offset;

  1026         return p;

  1027 }

  1028 

  1029 stmt_ty

  1030 ClassDef(identifier name, asdl_seq * bases, asdl_seq * body, asdl_seq *

  1031          decorator_list, int lineno, int col_offset, PyArena *arena)

  1032 {

  1033         stmt_ty p;

  1034         if (!name) {

  1035                 PyErr_SetString(PyExc_ValueError,

  1036                                 "field name is required for ClassDef");

  1037                 return NULL;

  1038         }

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

  1040         if (!p)

  1041                 return NULL;

  1042         p->kind = ClassDef_kind;

  1043         p->v.ClassDef.name = name;

  1044         p->v.ClassDef.bases = bases;

  1045         p->v.ClassDef.body = body;

  1046         p->v.ClassDef.decorator_list = decorator_list;

  1047         p->lineno = lineno;

  1048         p->col_offset = col_offset;

  1049         return p;

  1050 }

  1051 

  1052 stmt_ty

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

  1054 {

  1055         stmt_ty p;

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

  1057         if (!p)

  1058                 return NULL;

  1059         p->kind = Return_kind;

  1060         p->v.Return.value = value;

  1061         p->lineno = lineno;

  1062         p->col_offset = col_offset;

  1063         return p;

  1064 }

  1065 

  1066 stmt_ty

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

  1068 {

  1069         stmt_ty p;

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

  1071         if (!p)

  1072                 return NULL;

  1073         p->kind = Delete_kind;

  1074         p->v.Delete.targets = targets;

  1075         p->lineno = lineno;

  1076         p->col_offset = col_offset;

  1077         return p;

  1078 }

  1079 

  1080 stmt_ty

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

  1082        *arena)

  1083 {

  1084         stmt_ty p;

  1085         if (!value) {

  1086                 PyErr_SetString(PyExc_ValueError,

  1087                                 "field value is required for Assign");

  1088                 return NULL;

  1089         }

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

  1091         if (!p)

  1092                 return NULL;

  1093         p->kind = Assign_kind;

  1094         p->v.Assign.targets = targets;

  1095         p->v.Assign.value = value;

  1096         p->lineno = lineno;

  1097         p->col_offset = col_offset;

  1098         return p;

  1099 }

  1100 

  1101 stmt_ty

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

  1103           col_offset, PyArena *arena)

  1104 {

  1105         stmt_ty p;

  1106         if (!target) {

  1107                 PyErr_SetString(PyExc_ValueError,

  1108                                 "field target is required for AugAssign");

  1109                 return NULL;

  1110         }

  1111         if (!op) {

  1112                 PyErr_SetString(PyExc_ValueError,

  1113                                 "field op is required for AugAssign");

  1114                 return NULL;

  1115         }

  1116         if (!value) {

  1117                 PyErr_SetString(PyExc_ValueError,

  1118                                 "field value is required for AugAssign");

  1119                 return NULL;

  1120         }

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

  1122         if (!p)

  1123                 return NULL;

  1124         p->kind = AugAssign_kind;

  1125         p->v.AugAssign.target = target;

  1126         p->v.AugAssign.op = op;

  1127         p->v.AugAssign.value = value;

  1128         p->lineno = lineno;

  1129         p->col_offset = col_offset;

  1130         return p;

  1131 }

  1132 

  1133 stmt_ty

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

  1135       PyArena *arena)