Python/Python-ast.c

   1 /* File automatically generated by Parser/asdl_c.py. */
   2
   3
   4 /*
   5    __version__ 82160.
   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 *Set_type;
 192 static char *Set_fields[]={
 193         "elts",
 194 };
 195 static PyTypeObject *ListComp_type;
 196 static char *ListComp_fields[]={
 197         "elt",
 198         "generators",
 199 };
 200 static PyTypeObject *SetComp_type;
 201 static char *SetComp_fields[]={
 202         "elt",
 203         "generators",
 204 };
 205 static PyTypeObject *DictComp_type;
 206 static char *DictComp_fields[]={
 207         "key",
 208         "value",
 209         "generators",
 210 };
 211 static PyTypeObject *GeneratorExp_type;
 212 static char *GeneratorExp_fields[]={
 213         "elt",
 214         "generators",
 215 };
 216 static PyTypeObject *Yield_type;
 217 static char *Yield_fields[]={
 218         "value",
 219 };
 220 static PyTypeObject *Compare_type;
 221 static char *Compare_fields[]={
 222         "left",
 223         "ops",
 224         "comparators",
 225 };
 226 static PyTypeObject *Call_type;
 227 static char *Call_fields[]={
 228         "func",
 229         "args",
 230         "keywords",
 231         "starargs",
 232         "kwargs",
 233 };
 234 static PyTypeObject *Repr_type;
 235 static char *Repr_fields[]={
 236         "value",
 237 };
 238 static PyTypeObject *Num_type;
 239 static char *Num_fields[]={
 240         "n",
 241 };
 242 static PyTypeObject *Str_type;
 243 static char *Str_fields[]={
 244         "s",
 245 };
 246 static PyTypeObject *Attribute_type;
 247 static char *Attribute_fields[]={
 248         "value",
 249         "attr",
 250         "ctx",
 251 };
 252 static PyTypeObject *Subscript_type;
 253 static char *Subscript_fields[]={
 254         "value",
 255         "slice",
 256         "ctx",
 257 };
 258 static PyTypeObject *Name_type;
 259 static char *Name_fields[]={
 260         "id",
 261         "ctx",
 262 };
 263 static PyTypeObject *List_type;
 264 static char *List_fields[]={
 265         "elts",
 266         "ctx",
 267 };
 268 static PyTypeObject *Tuple_type;
 269 static char *Tuple_fields[]={
 270         "elts",
 271         "ctx",
 272 };
 273 static PyTypeObject *expr_context_type;
 274 static PyObject *Load_singleton, *Store_singleton, *Del_singleton,
 275 *AugLoad_singleton, *AugStore_singleton, *Param_singleton;
 276 static PyObject* ast2obj_expr_context(expr_context_ty);
 277 static PyTypeObject *Load_type;
 278 static PyTypeObject *Store_type;
 279 static PyTypeObject *Del_type;
 280 static PyTypeObject *AugLoad_type;
 281 static PyTypeObject *AugStore_type;
 282 static PyTypeObject *Param_type;
 283 static PyTypeObject *slice_type;
 284 static PyObject* ast2obj_slice(void*);
 285 static PyTypeObject *Ellipsis_type;
 286 static PyTypeObject *Slice_type;
 287 static char *Slice_fields[]={
 288         "lower",
 289         "upper",
 290         "step",
 291 };
 292 static PyTypeObject *ExtSlice_type;
 293 static char *ExtSlice_fields[]={
 294         "dims",
 295 };
 296 static PyTypeObject *Index_type;
 297 static char *Index_fields[]={
 298         "value",
 299 };
 300 static PyTypeObject *boolop_type;
 301 static PyObject *And_singleton, *Or_singleton;
 302 static PyObject* ast2obj_boolop(boolop_ty);
 303 static PyTypeObject *And_type;
 304 static PyTypeObject *Or_type;
 305 static PyTypeObject *operator_type;
 306 static PyObject *Add_singleton, *Sub_singleton, *Mult_singleton,
 307 *Div_singleton, *Mod_singleton, *Pow_singleton, *LShift_singleton,
 308 *RShift_singleton, *BitOr_singleton, *BitXor_singleton, *BitAnd_singleton,
 309 *FloorDiv_singleton;
 310 static PyObject* ast2obj_operator(operator_ty);
 311 static PyTypeObject *Add_type;
 312 static PyTypeObject *Sub_type;
 313 static PyTypeObject *Mult_type;
 314 static PyTypeObject *Div_type;
 315 static PyTypeObject *Mod_type;
 316 static PyTypeObject *Pow_type;
 317 static PyTypeObject *LShift_type;
 318 static PyTypeObject *RShift_type;
 319 static PyTypeObject *BitOr_type;
 320 static PyTypeObject *BitXor_type;
 321 static PyTypeObject *BitAnd_type;
 322 static PyTypeObject *FloorDiv_type;
 323 static PyTypeObject *unaryop_type;
 324 static PyObject *Invert_singleton, *Not_singleton, *UAdd_singleton,
 325 *USub_singleton;
 326 static PyObject* ast2obj_unaryop(unaryop_ty);
 327 static PyTypeObject *Invert_type;
 328 static PyTypeObject *Not_type;
 329 static PyTypeObject *UAdd_type;
 330 static PyTypeObject *USub_type;
 331 static PyTypeObject *cmpop_type;
 332 static PyObject *Eq_singleton, *NotEq_singleton, *Lt_singleton, *LtE_singleton,
 333 *Gt_singleton, *GtE_singleton, *Is_singleton, *IsNot_singleton, *In_singleton,
 334 *NotIn_singleton;
 335 static PyObject* ast2obj_cmpop(cmpop_ty);
 336 static PyTypeObject *Eq_type;
 337 static PyTypeObject *NotEq_type;
 338 static PyTypeObject *Lt_type;
 339 static PyTypeObject *LtE_type;
 340 static PyTypeObject *Gt_type;
 341 static PyTypeObject *GtE_type;
 342 static PyTypeObject *Is_type;
 343 static PyTypeObject *IsNot_type;
 344 static PyTypeObject *In_type;
 345 static PyTypeObject *NotIn_type;
 346 static PyTypeObject *comprehension_type;
 347 static PyObject* ast2obj_comprehension(void*);
 348 static char *comprehension_fields[]={
 349         "target",
 350         "iter",
 351         "ifs",
 352 };
 353 static PyTypeObject *excepthandler_type;
 354 static char *excepthandler_attributes[] = {
 355         "lineno",
 356         "col_offset",
 357 };
 358 static PyObject* ast2obj_excepthandler(void*);
 359 static PyTypeObject *ExceptHandler_type;
 360 static char *ExceptHandler_fields[]={
 361         "type",
 362         "name",
 363         "body",
 364 };
 365 static PyTypeObject *arguments_type;
 366 static PyObject* ast2obj_arguments(void*);
 367 static char *arguments_fields[]={
 368         "args",
 369         "vararg",
 370         "kwarg",
 371         "defaults",
 372 };
 373 static PyTypeObject *keyword_type;
 374 static PyObject* ast2obj_keyword(void*);
 375 static char *keyword_fields[]={
 376         "arg",
 377         "value",
 378 };
 379 static PyTypeObject *alias_type;
 380 static PyObject* ast2obj_alias(void*);
 381 static char *alias_fields[]={
 382         "name",
 383         "asname",
 384 };
 385
 386
 387 static int
 388 ast_type_init(PyObject *self, PyObject *args, PyObject *kw)
 389 {
 390     Py_ssize_t i, numfields = 0;
 391     int res = -1;
 392     PyObject *key, *value, *fields;
 393     fields = PyObject_GetAttrString((PyObject*)Py_TYPE(self), "_fields");
 394     if (!fields)
 395         PyErr_Clear();
 396     if (fields) {
 397         numfields = PySequence_Size(fields);
 398         if (numfields == -1)
 399             goto cleanup;
 400     }
 401     res = 0; /* if no error occurs, this stays 0 to the end */
 402     if (PyTuple_GET_SIZE(args) > 0) {
 403         if (numfields != PyTuple_GET_SIZE(args)) {
 404             PyErr_Format(PyExc_TypeError, "%.400s constructor takes %s"
 405                          "%zd positional argument%s",
 406                          Py_TYPE(self)->tp_name,
 407                          numfields == 0 ? "" : "either 0 or ",
 408                          numfields, numfields == 1 ? "" : "s");
 409             res = -1;
 410             goto cleanup;
 411         }
 412         for (i = 0; i < PyTuple_GET_SIZE(args); i++) {
 413             /* cannot be reached when fields is NULL */
 414             PyObject *name = PySequence_GetItem(fields, i);
 415             if (!name) {
 416                 res = -1;
 417                 goto cleanup;
 418             }
 419             res = PyObject_SetAttr(self, name, PyTuple_GET_ITEM(args, i));
 420             Py_DECREF(name);
 421             if (res < 0)
 422                 goto cleanup;
 423         }
 424     }
 425     if (kw) {
 426         i = 0;  /* needed by PyDict_Next */
 427         while (PyDict_Next(kw, &i, &key, &value)) {
 428             res = PyObject_SetAttr(self, key, value);
 429             if (res < 0)
 430                 goto cleanup;
 431         }
 432     }
 433   cleanup:
 434     Py_XDECREF(fields);
 435     return res;
 436 }
 437
 438 /* Pickling support */
 439 static PyObject *
 440 ast_type_reduce(PyObject *self, PyObject *unused)
 441 {
 442     PyObject *res;
 443     PyObject *dict = PyObject_GetAttrString(self, "__dict__");
 444     if (dict == NULL) {
 445         if (PyErr_ExceptionMatches(PyExc_AttributeError))
 446             PyErr_Clear();
 447         else
 448             return NULL;
 449     }
 450     if (dict) {
 451         res = Py_BuildValue("O()O", Py_TYPE(self), dict);
 452         Py_DECREF(dict);
 453         return res;
 454     }
 455     return Py_BuildValue("O()", Py_TYPE(self));
 456 }
 457
 458 static PyMethodDef ast_type_methods[] = {
 459     {"__reduce__", ast_type_reduce, METH_NOARGS, NULL},
 460     {NULL}
 461 };
 462
 463 static PyTypeObject AST_type = {
 464     PyVarObject_HEAD_INIT(&PyType_Type, 0)
 465     "_ast.AST",
 466     sizeof(PyObject),
 467     0,
 468     0,                       /* tp_dealloc */
 469     0,                       /* tp_print */
 470     0,                       /* tp_getattr */
 471     0,                       /* tp_setattr */
 472     0,                       /* tp_compare */
 473     0,                       /* tp_repr */
 474     0,                       /* tp_as_number */
 475     0,                       /* tp_as_sequence */
 476     0,                       /* tp_as_mapping */
 477     0,                       /* tp_hash */
 478     0,                       /* tp_call */
 479     0,                       /* tp_str */
 480     PyObject_GenericGetAttr, /* tp_getattro */
 481     PyObject_GenericSetAttr, /* tp_setattro */
 482     0,                       /* tp_as_buffer */
 483     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
 484     0,                       /* tp_doc */
 485     0,                       /* tp_traverse */
 486     0,                       /* tp_clear */
 487     0,                       /* tp_richcompare */
 488     0,                       /* tp_weaklistoffset */
 489     0,                       /* tp_iter */
 490     0,                       /* tp_iternext */
 491     ast_type_methods,        /* tp_methods */
 492     0,                       /* tp_members */
 493     0,                       /* tp_getset */
 494     0,                       /* tp_base */
 495     0,                       /* tp_dict */
 496     0,                       /* tp_descr_get */
 497     0,                       /* tp_descr_set */
 498     0,                       /* tp_dictoffset */
 499     (initproc)ast_type_init, /* tp_init */
 500     PyType_GenericAlloc,     /* tp_alloc */
 501     PyType_GenericNew,       /* tp_new */
 502     PyObject_Del,            /* tp_free */
 503 };
 504
 505
 506 static PyTypeObject* make_type(char *type, PyTypeObject* base, char**fields, int num_fields)
 507 {
 508     PyObject *fnames, *result;
 509     int i;
 510     fnames = PyTuple_New(num_fields);
 511     if (!fnames) return NULL;
 512     for (i = 0; i < num_fields; i++) {
 513         PyObject *field = PyString_FromString(fields[i]);
 514         if (!field) {
 515             Py_DECREF(fnames);
 516             return NULL;
 517         }
 518         PyTuple_SET_ITEM(fnames, i, field);
 519     }
 520     result = PyObject_CallFunction((PyObject*)&PyType_Type, "s(O){sOss}",
 521                     type, base, "_fields", fnames, "__module__", "_ast");
 522     Py_DECREF(fnames);
 523     return (PyTypeObject*)result;
 524 }
 525
 526 static int add_attributes(PyTypeObject* type, char**attrs, int num_fields)
 527 {
 528     int i, result;
 529     PyObject *s, *l = PyTuple_New(num_fields);
 530     if (!l)
 531         return 0;
 532     for (i = 0; i < num_fields; i++) {
 533         s = PyString_FromString(attrs[i]);
 534         if (!s) {
 535             Py_DECREF(l);
 536             return 0;
 537         }
 538         PyTuple_SET_ITEM(l, i, s);
 539     }
 540     result = PyObject_SetAttrString((PyObject*)type, "_attributes", l) >= 0;
 541     Py_DECREF(l);
 542     return result;
 543 }
 544
 545 /* Conversion AST -> Python */
 546
 547 static PyObject* ast2obj_list(asdl_seq *seq, PyObject* (*func)(void*))
 548 {
 549     int i, n = asdl_seq_LEN(seq);
 550     PyObject *result = PyList_New(n);
 551     PyObject *value;
 552     if (!result)
 553         return NULL;
 554     for (i = 0; i < n; i++) {
 555         value = func(asdl_seq_GET(seq, i));
 556         if (!value) {
 557             Py_DECREF(result);
 558             return NULL;
 559         }
 560         PyList_SET_ITEM(result, i, value);
 561     }
 562     return result;
 563 }
 564
 565 static PyObject* ast2obj_object(void *o)
 566 {
 567     if (!o)
 568         o = Py_None;
 569     Py_INCREF((PyObject*)o);
 570     return (PyObject*)o;
 571 }
 572 #define ast2obj_identifier ast2obj_object
 573 #define ast2obj_string ast2obj_object
 574 static PyObject* ast2obj_bool(bool b)
 575 {
 576     return PyBool_FromLong(b);
 577 }
 578
 579 static PyObject* ast2obj_int(long b)
 580 {
 581     return PyInt_FromLong(b);
 582 }
 583
 584 /* Conversion Python -> AST */
 585
 586 static int obj2ast_object(PyObject* obj, PyObject** out, PyArena* arena)
 587 {
 588     if (obj == Py_None)
 589         obj = NULL;
 590     if (obj)
 591         PyArena_AddPyObject(arena, obj);
 592     Py_XINCREF(obj);
 593     *out = obj;
 594     return 0;
 595 }
 596
 597 #define obj2ast_identifier obj2ast_object
 598 #define obj2ast_string obj2ast_object
 599
 600 static int obj2ast_int(PyObject* obj, int* out, PyArena* arena)
 601 {
 602     int i;
 603     if (!PyInt_Check(obj) && !PyLong_Check(obj)) {
 604         PyObject *s = PyObject_Repr(obj);
 605         if (s == NULL) return 1;
 606         PyErr_Format(PyExc_ValueError, "invalid integer value: %.400s",
 607                      PyString_AS_STRING(s));
 608         Py_DECREF(s);
 609         return 1;
 610     }
 611
 612     i = (int)PyLong_AsLong(obj);
 613     if (i == -1 && PyErr_Occurred())
 614         return 1;
 615     *out = i;
 616     return 0;
 617 }
 618
 619 static int obj2ast_bool(PyObject* obj, bool* out, PyArena* arena)
 620 {
 621     if (!PyBool_Check(obj)) {
 622         PyObject *s = PyObject_Repr(obj);
 623         if (s == NULL) return 1;
 624         PyErr_Format(PyExc_ValueError, "invalid boolean value: %.400s",
 625                      PyString_AS_STRING(s));
 626         Py_DECREF(s);
 627         return 1;
 628     }
 629
 630     *out = (obj == Py_True);
 631     return 0;
 632 }
 633
 634 static int add_ast_fields(void)
 635 {
 636     PyObject *empty_tuple, *d;
 637     if (PyType_Ready(&AST_type) < 0)
 638         return -1;
 639     d = AST_type.tp_dict;
 640     empty_tuple = PyTuple_New(0);
 641     if (!empty_tuple ||
 642         PyDict_SetItemString(d, "_fields", empty_tuple) < 0 ||
 643         PyDict_SetItemString(d, "_attributes", empty_tuple) < 0) {
 644         Py_XDECREF(empty_tuple);
 645         return -1;
 646     }
 647     Py_DECREF(empty_tuple);
 648     return 0;
 649 }
 650
 651
 652 static int init_types(void)
 653 {
 654         static int initialized;
 655         if (initialized) return 1;
 656         if (add_ast_fields() < 0) return 0;
 657         mod_type = make_type("mod", &AST_type, NULL, 0);
 658         if (!mod_type) return 0;
 659         if (!add_attributes(mod_type, NULL, 0)) return 0;
 660         Module_type = make_type("Module", mod_type, Module_fields, 1);
 661         if (!Module_type) return 0;
 662         Interactive_type = make_type("Interactive", mod_type,
 663                                      Interactive_fields, 1);
 664         if (!Interactive_type) return 0;
 665         Expression_type = make_type("Expression", mod_type, Expression_fields,
 666                                     1);
 667         if (!Expression_type) return 0;
 668         Suite_type = make_type("Suite", mod_type, Suite_fields, 1);
 669         if (!Suite_type) return 0;
 670         stmt_type = make_type("stmt", &AST_type, NULL, 0);
 671         if (!stmt_type) return 0;
 672         if (!add_attributes(stmt_type, stmt_attributes, 2)) return 0;
 673         FunctionDef_type = make_type("FunctionDef", stmt_type,
 674                                      FunctionDef_fields, 4);
 675         if (!FunctionDef_type) return 0;
 676         ClassDef_type = make_type("ClassDef", stmt_type, ClassDef_fields, 4);
 677         if (!ClassDef_type) return 0;
 678         Return_type = make_type("Return", stmt_type, Return_fields, 1);
 679         if (!Return_type) return 0;
 680         Delete_type = make_type("Delete", stmt_type, Delete_fields, 1);
 681         if (!Delete_type) return 0;
 682         Assign_type = make_type("Assign", stmt_type, Assign_fields, 2);
 683         if (!Assign_type) return 0;
 684         AugAssign_type = make_type("AugAssign", stmt_type, AugAssign_fields, 3);
 685         if (!AugAssign_type) return 0;
 686         Print_type = make_type("Print", stmt_type, Print_fields, 3);
 687         if (!Print_type) return 0;
 688         For_type = make_type("For", stmt_type, For_fields, 4);
 689         if (!For_type) return 0;
 690         While_type = make_type("While", stmt_type, While_fields, 3);
 691         if (!While_type) return 0;
 692         If_type = make_type("If", stmt_type, If_fields, 3);
 693         if (!If_type) return 0;
 694         With_type = make_type("With", stmt_type, With_fields, 3);
 695         if (!With_type) return 0;
 696         Raise_type = make_type("Raise", stmt_type, Raise_fields, 3);
 697         if (!Raise_type) return 0;
 698         TryExcept_type = make_type("TryExcept", stmt_type, TryExcept_fields, 3);
 699         if (!TryExcept_type) return 0;
 700         TryFinally_type = make_type("TryFinally", stmt_type, TryFinally_fields,
 701                                     2);
 702         if (!TryFinally_type) return 0;
 703         Assert_type = make_type("Assert", stmt_type, Assert_fields, 2);
 704         if (!Assert_type) return 0;
 705         Import_type = make_type("Import", stmt_type, Import_fields, 1);
 706         if (!Import_type) return 0;
 707         ImportFrom_type = make_type("ImportFrom", stmt_type, ImportFrom_fields,
 708                                     3);
 709         if (!ImportFrom_type) return 0;
 710         Exec_type = make_type("Exec", stmt_type, Exec_fields, 3);
 711         if (!Exec_type) return 0;
 712         Global_type = make_type("Global", stmt_type, Global_fields, 1);
 713         if (!Global_type) return 0;
 714         Expr_type = make_type("Expr", stmt_type, Expr_fields, 1);
 715         if (!Expr_type) return 0;
 716         Pass_type = make_type("Pass", stmt_type, NULL, 0);
 717         if (!Pass_type) return 0;
 718         Break_type = make_type("Break", stmt_type, NULL, 0);
 719         if (!Break_type) return 0;
 720         Continue_type = make_type("Continue", stmt_type, NULL, 0);
 721         if (!Continue_type) return 0;
 722         expr_type = make_type("expr", &AST_type, NULL, 0);
 723         if (!expr_type) return 0;
 724         if (!add_attributes(expr_type, expr_attributes, 2)) return 0;
 725         BoolOp_type = make_type("BoolOp", expr_type, BoolOp_fields, 2);
 726         if (!BoolOp_type) return 0;
 727         BinOp_type = make_type("BinOp", expr_type, BinOp_fields, 3);
 728         if (!BinOp_type) return 0;
 729         UnaryOp_type = make_type("UnaryOp", expr_type, UnaryOp_fields, 2);
 730         if (!UnaryOp_type) return 0;
 731         Lambda_type = make_type("Lambda", expr_type, Lambda_fields, 2);
 732         if (!Lambda_type) return 0;
 733         IfExp_type = make_type("IfExp", expr_type, IfExp_fields, 3);
 734         if (!IfExp_type) return 0;
 735         Dict_type = make_type("Dict", expr_type, Dict_fields, 2);
 736         if (!Dict_type) return 0;
 737         Set_type = make_type("Set", expr_type, Set_fields, 1);
 738         if (!Set_type) return 0;
 739         ListComp_type = make_type("ListComp", expr_type, ListComp_fields, 2);
 740         if (!ListComp_type) return 0;
 741         SetComp_type = make_type("SetComp", expr_type, SetComp_fields, 2);
 742         if (!SetComp_type) return 0;
 743         DictComp_type = make_type("DictComp", expr_type, DictComp_fields, 3);
 744         if (!DictComp_type) return 0;
 745         GeneratorExp_type = make_type("GeneratorExp", expr_type,
 746                                       GeneratorExp_fields, 2);
 747         if (!GeneratorExp_type) return 0;
 748         Yield_type = make_type("Yield", expr_type, Yield_fields, 1);
 749         if (!Yield_type) return 0;
 750         Compare_type = make_type("Compare", expr_type, Compare_fields, 3);
 751         if (!Compare_type) return 0;
 752         Call_type = make_type("Call", expr_type, Call_fields, 5);
 753         if (!Call_type) return 0;
 754         Repr_type = make_type("Repr", expr_type, Repr_fields, 1);
 755         if (!Repr_type) return 0;
 756         Num_type = make_type("Num", expr_type, Num_fields, 1);
 757         if (!Num_type) return 0;
 758         Str_type = make_type("Str", expr_type, Str_fields, 1);
 759         if (!Str_type) return 0;
 760         Attribute_type = make_type("Attribute", expr_type, Attribute_fields, 3);
 761         if (!Attribute_type) return 0;
 762         Subscript_type = make_type("Subscript", expr_type, Subscript_fields, 3);
 763         if (!Subscript_type) return 0;
 764         Name_type = make_type("Name", expr_type, Name_fields, 2);
 765         if (!Name_type) return 0;
 766         List_type = make_type("List", expr_type, List_fields, 2);
 767         if (!List_type) return 0;
 768         Tuple_type = make_type("Tuple", expr_type, Tuple_fields, 2);
 769         if (!Tuple_type) return 0;
 770         expr_context_type = make_type("expr_context", &AST_type, NULL, 0);
 771         if (!expr_context_type) return 0;
 772         if (!add_attributes(expr_context_type, NULL, 0)) return 0;
 773         Load_type = make_type("Load", expr_context_type, NULL, 0);
 774         if (!Load_type) return 0;
 775         Load_singleton = PyType_GenericNew(Load_type, NULL, NULL);
 776         if (!Load_singleton) return 0;
 777         Store_type = make_type("Store", expr_context_type, NULL, 0);
 778         if (!Store_type) return 0;
 779         Store_singleton = PyType_GenericNew(Store_type, NULL, NULL);
 780         if (!Store_singleton) return 0;
 781         Del_type = make_type("Del", expr_context_type, NULL, 0);
 782         if (!Del_type) return 0;
 783         Del_singleton = PyType_GenericNew(Del_type, NULL, NULL);
 784         if (!Del_singleton) return 0;
 785         AugLoad_type = make_type("AugLoad", expr_context_type, NULL, 0);
 786         if (!AugLoad_type) return 0;
 787         AugLoad_singleton = PyType_GenericNew(AugLoad_type, NULL, NULL);
 788         if (!AugLoad_singleton) return 0;
 789         AugStore_type = make_type("AugStore", expr_context_type, NULL, 0);
 790         if (!AugStore_type) return 0;
 791         AugStore_singleton = PyType_GenericNew(AugStore_type, NULL, NULL);
 792         if (!AugStore_singleton) return 0;
 793         Param_type = make_type("Param", expr_context_type, NULL, 0);
 794         if (!Param_type) return 0;
 795         Param_singleton = PyType_GenericNew(Param_type, NULL, NULL);
 796         if (!Param_singleton) return 0;
 797         slice_type = make_type("slice", &AST_type, NULL, 0);
 798         if (!slice_type) return 0;
 799         if (!add_attributes(slice_type, NULL, 0)) return 0;
 800         Ellipsis_type = make_type("Ellipsis", slice_type, NULL, 0);
 801         if (!Ellipsis_type) return 0;
 802         Slice_type = make_type("Slice", slice_type, Slice_fields, 3);
 803         if (!Slice_type) return 0;
 804         ExtSlice_type = make_type("ExtSlice", slice_type, ExtSlice_fields, 1);
 805         if (!ExtSlice_type) return 0;
 806         Index_type = make_type("Index", slice_type, Index_fields, 1);
 807         if (!Index_type) return 0;
 808         boolop_type = make_type("boolop", &AST_type, NULL, 0);
 809         if (!boolop_type) return 0;
 810         if (!add_attributes(boolop_type, NULL, 0)) return 0;
 811         And_type = make_type("And", boolop_type, NULL, 0);
 812         if (!And_type) return 0;
 813         And_singleton = PyType_GenericNew(And_type, NULL, NULL);
 814         if (!And_singleton) return 0;
 815         Or_type = make_type("Or", boolop_type, NULL, 0);
 816         if (!Or_type) return 0;
 817         Or_singleton = PyType_GenericNew(Or_type, NULL, NULL);
 818         if (!Or_singleton) return 0;
 819         operator_type = make_type("operator", &AST_type, NULL, 0);
 820         if (!operator_type) return 0;
 821         if (!add_attributes(operator_type, NULL, 0)) return 0;
 822         Add_type = make_type("Add", operator_type, NULL, 0);
 823         if (!Add_type) return 0;
 824         Add_singleton = PyType_GenericNew(Add_type, NULL, NULL);
 825         if (!Add_singleton) return 0;
 826         Sub_type = make_type("Sub", operator_type, NULL, 0);
 827         if (!Sub_type) return 0;
 828         Sub_singleton = PyType_GenericNew(Sub_type, NULL, NULL);
 829         if (!Sub_singleton) return 0;
 830         Mult_type = make_type("Mult", operator_type, NULL, 0);
 831         if (!Mult_type) return 0;
 832         Mult_singleton = PyType_GenericNew(Mult_type, NULL, NULL);
 833         if (!Mult_singleton) return 0;
 834         Div_type = make_type("Div", operator_type, NULL, 0);
 835         if (!Div_type) return 0;
 836         Div_singleton = PyType_GenericNew(Div_type, NULL, NULL);
 837         if (!Div_singleton) return 0;
 838         Mod_type = make_type("Mod", operator_type, NULL, 0);
 839         if (!Mod_type) return 0;
 840         Mod_singleton = PyType_GenericNew(Mod_type, NULL, NULL);
 841         if (!Mod_singleton) return 0;
 842         Pow_type = make_type("Pow", operator_type, NULL, 0);
 843         if (!Pow_type) return 0;
 844         Pow_singleton = PyType_GenericNew(Pow_type, NULL, NULL);
 845         if (!Pow_singleton) return 0;
 846         LShift_type = make_type("LShift", operator_type, NULL, 0);
 847         if (!LShift_type) return 0;
 848         LShift_singleton = PyType_GenericNew(LShift_type, NULL, NULL);
 849         if (!LShift_singleton) return 0;
 850         RShift_type = make_type("RShift", operator_type, NULL, 0);
 851         if (!RShift_type) return 0;
 852         RShift_singleton = PyType_GenericNew(RShift_type, NULL, NULL);
 853         if (!RShift_singleton) return 0;
 854         BitOr_type = make_type("BitOr", operator_type, NULL, 0);
 855         if (!BitOr_type) return 0;
 856         BitOr_singleton = PyType_GenericNew(BitOr_type, NULL, NULL);
 857         if (!BitOr_singleton) return 0;
 858         BitXor_type = make_type("BitXor", operator_type, NULL, 0);
 859         if (!BitXor_type) return 0;
 860         BitXor_singleton = PyType_GenericNew(BitXor_type, NULL, NULL);
 861         if (!BitXor_singleton) return 0;
 862         BitAnd_type = make_type("BitAnd", operator_type, NULL, 0);
 863         if (!BitAnd_type) return 0;
 864         BitAnd_singleton = PyType_GenericNew(BitAnd_type, NULL, NULL);
 865         if (!BitAnd_singleton) return 0;
 866         FloorDiv_type = make_type("FloorDiv", operator_type, NULL, 0);
 867         if (!FloorDiv_type) return 0;
 868         FloorDiv_singleton = PyType_GenericNew(FloorDiv_type, NULL, NULL);
 869         if (!FloorDiv_singleton) return 0;
 870         unaryop_type = make_type("unaryop", &AST_type, NULL, 0);
 871         if (!unaryop_type) return 0;
 872         if (!add_attributes(unaryop_type, NULL, 0)) return 0;
 873         Invert_type = make_type("Invert", unaryop_type, NULL, 0);
 874         if (!Invert_type) return 0;
 875         Invert_singleton = PyType_GenericNew(Invert_type, NULL, NULL);
 876         if (!Invert_singleton) return 0;
 877         Not_type = make_type("Not", unaryop_type, NULL, 0);
 878         if (!Not_type) return 0;
 879         Not_singleton = PyType_GenericNew(Not_type, NULL, NULL);
 880         if (!Not_singleton) return 0;
 881         UAdd_type = make_type("UAdd", unaryop_type, NULL, 0);
 882         if (!UAdd_type) return 0;
 883         UAdd_singleton = PyType_GenericNew(UAdd_type, NULL, NULL);
 884         if (!UAdd_singleton) return 0;
 885         USub_type = make_type("USub", unaryop_type, NULL, 0);
 886         if (!USub_type) return 0;
 887         USub_singleton = PyType_GenericNew(USub_type, NULL, NULL);
 888         if (!USub_singleton) return 0;
 889         cmpop_type = make_type("cmpop", &AST_type, NULL, 0);
 890         if (!cmpop_type) return 0;
 891         if (!add_attributes(cmpop_type, NULL, 0)) return 0;
 892         Eq_type = make_type("Eq", cmpop_type, NULL, 0);
 893         if (!Eq_type) return 0;
 894         Eq_singleton = PyType_GenericNew(Eq_type, NULL, NULL);
 895         if (!Eq_singleton) return 0;
 896         NotEq_type = make_type("NotEq", cmpop_type, NULL, 0);
 897         if (!NotEq_type) return 0;
 898         NotEq_singleton = PyType_GenericNew(NotEq_type, NULL, NULL);
 899         if (!NotEq_singleton) return 0;
 900         Lt_type = make_type("Lt", cmpop_type, NULL, 0);
 901         if (!Lt_type) return 0;
 902         Lt_singleton = PyType_GenericNew(Lt_type, NULL, NULL);
 903         if (!Lt_singleton) return 0;
 904         LtE_type = make_type("LtE", cmpop_type, NULL, 0);
 905         if (!LtE_type) return 0;
 906         LtE_singleton = PyType_GenericNew(LtE_type, NULL, NULL);
 907         if (!LtE_singleton) return 0;
 908         Gt_type = make_type("Gt", cmpop_type, NULL, 0);
 909         if (!Gt_type) return 0;
 910         Gt_singleton = PyType_GenericNew(Gt_type, NULL, NULL);
 911         if (!Gt_singleton) return 0;
 912         GtE_type = make_type("GtE", cmpop_type, NULL, 0);
 913         if (!GtE_type) return 0;
 914         GtE_singleton = PyType_GenericNew(GtE_type, NULL, NULL);
 915         if (!GtE_singleton) return 0;
 916         Is_type = make_type("Is", cmpop_type, NULL, 0);
 917         if (!Is_type) return 0;
 918         Is_singleton = PyType_GenericNew(Is_type, NULL, NULL);
 919         if (!Is_singleton) return 0;
 920         IsNot_type = make_type("IsNot", cmpop_type, NULL, 0);
 921         if (!IsNot_type) return 0;
 922         IsNot_singleton = PyType_GenericNew(IsNot_type, NULL, NULL);
 923         if (!IsNot_singleton) return 0;
 924         In_type = make_type("In", cmpop_type, NULL, 0);
 925         if (!In_type) return 0;
 926         In_singleton = PyType_GenericNew(In_type, NULL, NULL);
 927         if (!In_singleton) return 0;
 928         NotIn_type = make_type("NotIn", cmpop_type, NULL, 0);
 929         if (!NotIn_type) return 0;
 930         NotIn_singleton = PyType_GenericNew(NotIn_type, NULL, NULL);
 931         if (!NotIn_singleton) return 0;
 932         comprehension_type = make_type("comprehension", &AST_type,
 933                                        comprehension_fields, 3);
 934         if (!comprehension_type) return 0;
 935         excepthandler_type = make_type("excepthandler", &AST_type, NULL, 0);
 936         if (!excepthandler_type) return 0;
 937         if (!add_attributes(excepthandler_type, excepthandler_attributes, 2))
 938             return 0;
 939         ExceptHandler_type = make_type("ExceptHandler", excepthandler_type,
 940                                        ExceptHandler_fields, 3);
 941         if (!ExceptHandler_type) return 0;
 942         arguments_type = make_type("arguments", &AST_type, arguments_fields, 4);
 943         if (!arguments_type) return 0;
 944         keyword_type = make_type("keyword", &AST_type, keyword_fields, 2);
 945         if (!keyword_type) return 0;
 946         alias_type = make_type("alias", &AST_type, alias_fields, 2);
 947         if (!alias_type) return 0;
 948         initialized = 1;
 949         return 1;
 950 }
 951
 952 static int obj2ast_mod(PyObject* obj, mod_ty* out, PyArena* arena);
 953 static int obj2ast_stmt(PyObject* obj, stmt_ty* out, PyArena* arena);
 954 static int obj2ast_expr(PyObject* obj, expr_ty* out, PyArena* arena);
 955 static int obj2ast_expr_context(PyObject* obj, expr_context_ty* out, PyArena*
 956                                 arena);
 957 static int obj2ast_slice(PyObject* obj, slice_ty* out, PyArena* arena);
 958 static int obj2ast_boolop(PyObject* obj, boolop_ty* out, PyArena* arena);
 959 static int obj2ast_operator(PyObject* obj, operator_ty* out, PyArena* arena);
 960 static int obj2ast_unaryop(PyObject* obj, unaryop_ty* out, PyArena* arena);
 961 static int obj2ast_cmpop(PyObject* obj, cmpop_ty* out, PyArena* arena);
 962 static int obj2ast_comprehension(PyObject* obj, comprehension_ty* out, PyArena*
 963                                  arena);
 964 static int obj2ast_excepthandler(PyObject* obj, excepthandler_ty* out, PyArena*
 965                                  arena);
 966 static int obj2ast_arguments(PyObject* obj, arguments_ty* out, PyArena* arena);
 967 static int obj2ast_keyword(PyObject* obj, keyword_ty* out, PyArena* arena);
 968 static int obj2ast_alias(PyObject* obj, alias_ty* out, PyArena* arena);
 969
 970 mod_ty
 971 Module(asdl_seq * body, PyArena *arena)
 972 {
 973         mod_ty p;
 974         p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
 975         if (!p)
 976                 return NULL;
 977         p->kind = Module_kind;
 978         p->v.Module.body = body;
 979         return p;
 980 }
 981
 982 mod_ty
 983 Interactive(asdl_seq * body, PyArena *arena)
 984 {
 985         mod_ty p;
 986         p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
 987         if (!p)
 988                 return NULL;
 989         p->kind = Interactive_kind;
 990         p->v.Interactive.body = body;
 991         return p;
 992 }
 993
 994 mod_ty
 995 Expression(expr_ty body, PyArena *arena)
 996 {
 997         mod_ty p;
 998         if (!body) {
 999                 PyErr_SetString(PyExc_ValueError,
1000                                 "field body is required for Expression");
1001                 return NULL;
1002         }
1003         p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
1004         if (!p)
1005                 return NULL;
1006         p->kind = Expression_kind;
1007         p->v.Expression.body = body;
1008         return p;
1009 }
1010
1011 mod_ty
1012 Suite(asdl_seq * body, PyArena *arena)
1013 {
1014         mod_ty p;
1015         p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
1016         if (!p)
1017                 return NULL;
1018         p->kind = Suite_kind;
1019         p->v.Suite.body = body;
1020         return p;
1021 }
1022
1023 stmt_ty
1024 FunctionDef(identifier name, arguments_ty args, asdl_seq * body, asdl_seq *
1025             decorator_list, int lineno, int col_offset, PyArena *arena)
1026 {
1027         stmt_ty p;
1028         if (!name) {
1029                 PyErr_SetString(PyExc_ValueError,
1030                                 "field name is required for FunctionDef");
1031                 return NULL;
1032         }
1033         if (!args) {
1034                 PyErr_SetString(PyExc_ValueError,
1035                                 "field args is required for FunctionDef");
1036                 return NULL;
1037         }
1038         p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1039         if (!p)
1040                 return NULL;
1041         p->kind = FunctionDef_kind;
1042         p->v.FunctionDef.name = name;
1043         p->v.FunctionDef.args = args;
1044         p->v.FunctionDef.body = body;
1045         p->v.FunctionDef.decorator_list = decorator_list;
1046         p->lineno = lineno;
1047         p->col_offset = col_offset;
1048         return p;
1049 }
1050
1051 stmt_ty
1052 ClassDef(identifier name, asdl_seq * bases, asdl_seq * body, asdl_seq *
1053          decorator_list, int lineno, int col_offset, PyArena *arena)
1054 {
1055         stmt_ty p;
1056         if (!name) {
1057                 PyErr_SetString(PyExc_ValueError,
1058                                 "field name is required for ClassDef");
1059                 return NULL;
1060         }
1061         p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1062         if (!p)
1063                 return NULL;
1064         p->kind = ClassDef_kind;
1065         p->v.ClassDef.name = name;
1066         p->v.ClassDef.bases = bases;
1067         p->v.ClassDef.body = body;
1068         p->v.ClassDef.decorator_list = decorator_list;
1069         p->lineno = lineno;
1070         p->col_offset = col_offset;
1071         return p;
1072 }
1073
1074 stmt_ty
1075 Return(expr_ty value, int lineno, int col_offset, PyArena *arena)
1076 {
1077         stmt_ty p;
1078         p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1079         if (!p)
1080                 return NULL;
1081         p->kind = Return_kind;
1082         p->v.Return.value = value;
1083         p->lineno = lineno;
1084         p->col_offset = col_offset;
1085         return p;
1086 }
1087
1088 stmt_ty
1089 Delete(asdl_seq * targets, int lineno, int col_offset, PyArena *arena)
1090 {
1091         stmt_ty p;
1092         p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1093         if (!p)
1094                 return NULL;
1095         p->kind = Delete_kind;
1096         p->v.Delete.targets = targets;
1097         p->lineno = lineno;
1098         p->col_offset = col_offset;
1099         return p;
1100 }
1101
1102 stmt_ty
1103 Assign(asdl_seq * targets, expr_ty value, int lineno, int col_offset, PyArena
1104        *arena)
1105 {
1106         stmt_ty p;
1107         if (!value) {
1108                 PyErr_SetString(PyExc_ValueError,
1109                                 "field value is required for Assign");
1110                 return NULL;
1111         }
1112         p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1113         if (!p)
1114                 return NULL;
1115         p->kind = Assign_kind;
1116         p->v.Assign.targets = targets;
1117         p->v.Assign.value = value;
1118         p->lineno = lineno;
1119         p->col_offset = col_offset;
1120         return p;
1121 }
1122
1123 stmt_ty
1124 AugAssign(expr_ty target, operator_ty op, expr_ty value, int lineno, int
1125           col_offset, PyArena *arena)
1126 {
1127         stmt_ty p;
1128         if (!target) {
1129                 PyErr_SetString(PyExc_ValueError,
1130                                 "field target is required for AugAssign");
1131                 return NULL;
1132         }
1133         if (!op) {
1134                 PyErr_SetString(PyExc_ValueError,
1135                                 "field op is required for AugAssign");
1136                 return NULL;
1137         }
1138         if (!value) {
1139                 PyErr_SetString(PyExc_ValueError,
1140                                 "field value is required for AugAssign");
1141                 return NULL;
1142         }
1143         p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1144         if (!p)
1145                 return NULL;
1146         p->kind = AugAssign_kind;
1147         p->v.AugAssign.target = target;
1148         p->v.AugAssign.op = op;
1149         p->v.AugAssign.value = value;
1150         p->lineno = lineno;
1151         p->col_offset = col_offset;
1152         return p;
1153 }
1154
1155 stmt_ty
1156 Print(expr_ty dest, asdl_seq * values, bool nl, int lineno, int col_offset,
1157       PyArena *arena)
1158 {
1159         stmt_ty p;
1160         p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1161         if (!p)
1162                 return NULL;
1163         p->kind = Print_kind;
1164         p->v.Print.dest = dest;
1165         p->v.Print.values = values;
1166         p->v.Print.nl = nl;
1167         p->lineno = lineno;
1168         p->col_offset = col_offset;
1169         return p;
1170 }
1171
1172 stmt_ty
1173 For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * orelse, int
1174     lineno, int col_offset, PyArena *arena)
1175 {
1176         stmt_ty p;
1177         if (!target) {
1178                 PyErr_SetString(PyExc_ValueError,
1179                                 "field target is required for For");
1180                 return NULL;
1181         }
1182         if (!iter) {
1183                 PyErr_SetString(PyExc_ValueError,
1184                                 "field iter is required for For");
1185                 return NULL;
1186         }
1187         p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1188         if (!p)
1189                 return NULL;
1190         p->kind = For_kind;
1191         p->v.For.target = target;
1192         p->v.For.iter = iter;
1193         p->v.For.body = body;
1194         p->v.For.orelse = orelse;
1195         p->lineno = lineno;
1196         p->col_offset = col_offset;
1197         return p;
1198 }
1199
1200 stmt_ty
1201 While(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, int
1202       col_offset, PyArena *arena)
1203 {
1204         stmt_ty p;
1205         if (!test) {
1206                 PyErr_SetString(PyExc_ValueError,
1207                                 "field test is required for While");
1208                 return NULL;
1209         }
1210         p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1211         if (!p)
1212                 return NULL;
1213         p->kind = While_kind;
1214         p->v.While.test = test;
1215         p->v.While.body = body;
1216         p->v.While.orelse = orelse;
1217         p->lineno = lineno;
1218         p->col_offset = col_offset;
1219         return p;
1220 }
1221
1222 stmt_ty
1223 If(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, int
1224    col_offset, PyArena *arena)
1225 {
1226         stmt_ty p;
1227         if (!test) {
1228                 PyErr_SetString(PyExc_ValueError,
1229                                 "field test is required for If");
1230                 return NULL;
1231         }
1232         p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1233         if (!p)
1234                 return NULL;
1235         p->kind = If_kind;
1236         p->v.If.test = test;
1237         p->v.If.body = body;
1238         p->v.If.orelse = orelse;
1239         p->lineno = lineno;
1240         p->col_offset = col_offset;
1241         return p;
1242 }
1243
1244 stmt_ty
1245 With(expr_ty context_expr, expr_ty optional_vars, asdl_seq * body, int lineno,
1246      int col_offset, PyArena *arena)
1247 {
1248         stmt_ty p;
1249         if (!context_expr) {
1250                 PyErr_SetString(PyExc_ValueError,
1251                                 "field context_expr is required for With");
1252                 return NULL;
1253         }
1254         p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1255         if (!p)
1256                 return NULL;
1257         p->kind = With_kind;
1258         p->v.With.context_expr = context_expr;
1259         p->v.With.optional_vars = optional_vars;
1260         p->v.With.body = body;
1261         p->lineno = lineno;
1262         p->col_offset = col_offset;
1263         return p;
1264 }
1265
1266 stmt_ty
1267 Raise(expr_ty type, expr_ty inst, expr_ty tback, int lineno, int col_offset,
1268       PyArena *arena)
1269 {
1270         stmt_ty p;
1271         p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1272         if (!p)
1273                 return NULL;
1274         p->kind = Raise_kind;
1275         p->v.Raise.type = type;
1276         p->v.Raise.inst = inst;
1277         p->v.Raise.tback = tback;
1278         p->lineno = lineno;
1279         p->col_offset = col_offset;
1280         return p;
1281 }
1282
1283 stmt_ty
1284 TryExcept(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse, int lineno,
1285           int col_offset, PyArena *arena)
1286 {
1287         stmt_ty p;
1288         p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1289         if (!p)
1290                 return NULL;
1291         p->kind = TryExcept_kind;
1292         p->v.TryExcept.body = body;
1293         p->v.TryExcept.handlers = handlers;
1294         p->v.TryExcept.orelse = orelse;
1295         p->lineno = lineno;
1296         p->col_offset = col_offset;
1297         return p;
1298 }
1299
1300 stmt_ty
1301 TryFinally(asdl_seq * body, asdl_seq * finalbody, int lineno, int col_offset,
1302            PyArena *arena)
1303 {
1304         stmt_ty p;
1305         p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1306         if (!p)
1307                 return NULL;
1308         p->kind = TryFinally_kind;
1309         p->v.TryFinally.body = body;
1310         p->v.TryFinally.finalbody = finalbody;
1311         p->lineno = lineno;
1312         p->col_offset = col_offset;
1313         return p;
1314 }
1315
1316 stmt_ty
1317 Assert(expr_ty test, expr_ty msg, int lineno, int col_offset, PyArena *arena)
1318 {
1319         stmt_ty p;
1320         if (!test) {
1321                 PyErr_SetString(PyExc_ValueError,
1322                                 "field test is required for Assert");
1323                 return NULL;
1324         }
1325         p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1326         if (!p)
1327                 return NULL;
1328         p->kind = Assert_kind;
1329         p->v.Assert.test = test;
1330         p->v.Assert.msg = msg;
1331         p->lineno = lineno;
1332         p->col_offset = col_offset;
1333         return p;
1334 }
1335
1336 stmt_ty
1337 Import(asdl_seq * names, int lineno, int col_offset, PyArena *arena)
1338 {
1339         stmt_ty p;
1340         p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1341         if (!p)
1342                 return NULL;
1343         p->kind = Import_kind;
1344         p->v.Import.names = names;
1345         p->lineno = lineno;
1346         p->col_offset = col_offset;
1347         return p;
1348 }
1349
1350 stmt_ty
1351 ImportFrom(identifier module, asdl_seq * names, int level, int lineno, int
1352            col_offset, PyArena *arena)
1353 {
1354         stmt_ty p;
1355         p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1356         if (!p)
1357                 return NULL;
1358         p->kind = ImportFrom_kind;
1359         p->v.ImportFrom.module = module;
1360         p->v.ImportFrom.names = names;
1361         p->v.ImportFrom.level = level;
1362         p->lineno = lineno;
1363         p->col_offset = col_offset;
1364         return p;
1365 }
1366
1367 stmt_ty
1368 Exec(expr_ty body, expr_ty globals, expr_ty locals, int lineno, int col_offset,
1369      PyArena *arena)
1370 {
1371         stmt_ty p;
1372         if (!body) {
1373                 PyErr_SetString(PyExc_ValueError,
1374                                 "field body is required for Exec");
1375                 return NULL;
1376         }
1377         p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1378         if (!p)
1379                 return NULL;
1380         p->kind = Exec_kind;
1381         p->v.Exec.body = body;
1382         p->v.Exec.globals = globals;
1383         p->v.Exec.locals = locals;
1384         p->lineno = lineno;
1385         p->col_offset = col_offset;
1386         return p;
1387 }
1388
1389 stmt_ty
1390 Global(asdl_seq * names, int lineno, int col_offset, PyArena *arena)
1391 {
1392         stmt_ty p;
1393         p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1394         if (!p)
1395                 return NULL;
1396         p->kind = Global_kind;
1397         p->v.Global.names = names;
1398         p->lineno = lineno;
1399         p->col_offset = col_offset;
1400         return p;
1401 }
1402
1403 stmt_ty
1404 Expr(expr_ty value, int lineno, int col_offset, PyArena *arena)
1405 {
1406         stmt_ty p;
1407         if (!value) {
1408                 PyErr_SetString(PyExc_ValueError,
1409                                 "field value is required for Expr");
1410                 return NULL;
1411         }
1412         p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1413         if (!p)
1414                 return NULL;
1415         p->kind = Expr_kind;
1416         p->v.Expr.value = value;
1417         p->lineno = lineno;
1418         p->col_offset = col_offset;
1419         return p;
1420 }
1421
1422 stmt_ty
1423 Pass(int lineno, int col_offset, PyArena *arena)
1424 {
1425         stmt_ty p;
1426         p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1427         if (!p)
1428                 return NULL;
1429         p->kind = Pass_kind;
1430         p->lineno = lineno;
1431         p->col_offset = col_offset;
1432         return p;
1433 }
1434
1435 stmt_ty
1436 Break(int lineno, int col_offset, PyArena *arena)
1437 {
1438         stmt_ty p;
1439         p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1440         if (!p)
1441                 return NULL;
1442         p->kind = Break_kind;
1443         p->lineno = lineno;
1444         p->col_offset = col_offset;
1445         return p;
1446 }
1447
1448 stmt_ty
1449 Continue(int lineno, int col_offset, PyArena *arena)
1450 {
1451         stmt_ty p;
1452         p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
1453         if (!p)
1454                 return NULL;
1455         p->kind = Continue_kind;
1456         p->lineno = lineno;
1457         p->col_offset = col_offset;
1458         return p;
1459 }
1460
1461 expr_ty
1462 BoolOp(boolop_ty op, asdl_seq * values, int lineno, int col_offset, PyArena
1463        *arena)
1464 {
1465         expr_ty p;
1466         if (!op) {
1467                 PyErr_SetString(PyExc_ValueError,
1468                                 "field op is required for BoolOp");
1469                 return NULL;
1470         }
1471         p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1472         if (!p)
1473                 return NULL;
1474         p->kind = BoolOp_kind;
1475         p->v.BoolOp.op = op;
1476         p->v.BoolOp.values = values;
1477         p->lineno = lineno;
1478         p->col_offset = col_offset;
1479         return p;
1480 }
1481
1482 expr_ty
1483 BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno, int col_offset,
1484       PyArena *arena)
1485 {
1486         expr_ty p;
1487         if (!left) {
1488                 PyErr_SetString(PyExc_ValueError,
1489                                 "field left is required for BinOp");
1490                 return NULL;
1491         }
1492         if (!op) {
1493                 PyErr_SetString(PyExc_ValueError,
1494                                 "field op is required for BinOp");
1495                 return NULL;
1496         }
1497         if (!right) {
1498                 PyErr_SetString(PyExc_ValueError,
1499                                 "field right is required for BinOp");
1500                 return NULL;
1501         }
1502         p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1503         if (!p)
1504                 return NULL;
1505         p->kind = BinOp_kind;
1506         p->v.BinOp.left = left;
1507         p->v.BinOp.op = op;
1508         p->v.BinOp.right = right;
1509         p->lineno = lineno;
1510         p->col_offset = col_offset;
1511         return p;
1512 }
1513
1514 expr_ty
1515 UnaryOp(unaryop_ty op, expr_ty operand, int lineno, int col_offset, PyArena
1516         *arena)
1517 {
1518         expr_ty p;
1519         if (!op) {
1520                 PyErr_SetString(PyExc_ValueError,
1521                                 "field op is required for UnaryOp");
1522                 return NULL;
1523         }
1524         if (!operand) {
1525                 PyErr_SetString(PyExc_ValueError,
1526                                 "field operand is required for UnaryOp");
1527                 return NULL;
1528         }
1529         p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1530         if (!p)
1531                 return NULL;
1532         p->kind = UnaryOp_kind;
1533         p->v.UnaryOp.op = op;
1534         p->v.UnaryOp.operand = operand;
1535         p->lineno = lineno;
1536         p->col_offset = col_offset;
1537         return p;
1538 }
1539
1540 expr_ty
1541 Lambda(arguments_ty args, expr_ty body, int lineno, int col_offset, PyArena
1542        *arena)
1543 {
1544         expr_ty p;
1545         if (!args) {
1546                 PyErr_SetString(PyExc_ValueError,
1547                                 "field args is required for Lambda");
1548                 return NULL;
1549         }
1550         if (!body) {
1551                 PyErr_SetString(PyExc_ValueError,
1552                                 "field body is required for Lambda");
1553                 return NULL;
1554         }
1555         p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1556         if (!p)
1557                 return NULL;
1558         p->kind = Lambda_kind;
1559         p->v.Lambda.args = args;
1560         p->v.Lambda.body = body;
1561         p->lineno = lineno;
1562         p->col_offset = col_offset;
1563         return p;
1564 }
1565
1566 expr_ty
1567 IfExp(expr_ty test, expr_ty body, expr_ty orelse, int lineno, int col_offset,
1568       PyArena *arena)
1569 {
1570         expr_ty p;
1571         if (!test) {
1572                 PyErr_SetString(PyExc_ValueError,
1573                                 "field test is required for IfExp");
1574                 return NULL;
1575         }
1576         if (!body) {
1577                 PyErr_SetString(PyExc_ValueError,
1578                                 "field body is required for IfExp");
1579                 return NULL;
1580         }
1581         if (!orelse) {
1582                 PyErr_SetString(PyExc_ValueError,
1583                                 "field orelse is required for IfExp");
1584                 return NULL;
1585         }
1586         p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1587         if (!p)
1588                 return NULL;
1589         p->kind = IfExp_kind;
1590         p->v.IfExp.test = test;
1591         p->v.IfExp.body = body;
1592         p->v.IfExp.orelse = orelse;
1593         p->lineno = lineno;
1594         p->col_offset = col_offset;
1595         return p;
1596 }
1597
1598 expr_ty
1599 Dict(asdl_seq * keys, asdl_seq * values, int lineno, int col_offset, PyArena
1600      *arena)
1601 {
1602         expr_ty p;
1603         p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1604         if (!p)
1605                 return NULL;
1606         p->kind = Dict_kind;
1607         p->v.Dict.keys = keys;
1608         p->v.Dict.values = values;
1609         p->lineno = lineno;
1610         p->col_offset = col_offset;
1611         return p;
1612 }
1613
1614 expr_ty
1615 Set(asdl_seq * elts, int lineno, int col_offset, PyArena *arena)
1616 {
1617         expr_ty p;
1618         p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1619         if (!p)
1620                 return NULL;
1621         p->kind = Set_kind;
1622         p->v.Set.elts = elts;
1623         p->lineno = lineno;
1624         p->col_offset = col_offset;
1625         return p;
1626 }
1627
1628 expr_ty
1629 ListComp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset,
1630          PyArena *arena)
1631 {
1632         expr_ty p;
1633         if (!elt) {
1634                 PyErr_SetString(PyExc_ValueError,
1635                                 "field elt is required for ListComp");
1636                 return NULL;
1637         }
1638         p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1639         if (!p)
1640                 return NULL;
1641         p->kind = ListComp_kind;
1642         p->v.ListComp.elt = elt;
1643         p->v.ListComp.generators = generators;
1644         p->lineno = lineno;
1645         p->col_offset = col_offset;
1646         return p;
1647 }
1648
1649 expr_ty
1650 SetComp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset, PyArena
1651         *arena)
1652 {
1653         expr_ty p;
1654         if (!elt) {
1655                 PyErr_SetString(PyExc_ValueError,
1656                                 "field elt is required for SetComp");
1657                 return NULL;
1658         }
1659         p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1660         if (!p)
1661                 return NULL;
1662         p->kind = SetComp_kind;
1663         p->v.SetComp.elt = elt;
1664         p->v.SetComp.generators = generators;
1665         p->lineno = lineno;
1666         p->col_offset = col_offset;
1667         return p;
1668 }
1669
1670 expr_ty
1671 DictComp(expr_ty key, expr_ty value, asdl_seq * generators, int lineno, int
1672          col_offset, PyArena *arena)
1673 {
1674         expr_ty p;
1675         if (!key) {
1676                 PyErr_SetString(PyExc_ValueError,
1677                                 "field key is required for DictComp");
1678                 return NULL;
1679         }
1680         if (!value) {
1681                 PyErr_SetString(PyExc_ValueError,
1682                                 "field value is required for DictComp");
1683                 return NULL;
1684         }
1685         p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1686         if (!p)
1687                 return NULL;
1688         p->kind = DictComp_kind;
1689         p->v.DictComp.key = key;
1690         p->v.DictComp.value = value;
1691         p->v.DictComp.generators = generators;
1692         p->lineno = lineno;
1693         p->col_offset = col_offset;
1694         return p;
1695 }
1696
1697 expr_ty
1698 GeneratorExp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset,
1699              PyArena *arena)
1700 {
1701         expr_ty p;
1702         if (!elt) {
1703                 PyErr_SetString(PyExc_ValueError,
1704                                 "field elt is required for GeneratorExp");
1705                 return NULL;
1706         }
1707         p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1708         if (!p)
1709                 return NULL;
1710         p->kind = GeneratorExp_kind;
1711         p->v.GeneratorExp.elt = elt;
1712         p->v.GeneratorExp.generators = generators;
1713         p->lineno = lineno;
1714         p->col_offset = col_offset;
1715         return p;
1716 }
1717
1718 expr_ty
1719 Yield(expr_ty value, int lineno, int col_offset, PyArena *arena)
1720 {
1721         expr_ty p;
1722         p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1723         if (!p)
1724                 return NULL;
1725         p->kind = Yield_kind;
1726         p->v.Yield.value = value;
1727         p->lineno = lineno;
1728         p->col_offset = col_offset;
1729         return p;
1730 }
1731
1732 expr_ty
1733 Compare(expr_ty left, asdl_int_seq * ops, asdl_seq * comparators, int lineno,
1734         int col_offset, PyArena *arena)
1735 {
1736         expr_ty p;
1737         if (!left) {
1738                 PyErr_SetString(PyExc_ValueError,
1739                                 "field left is required for Compare");
1740                 return NULL;
1741         }
1742         p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1743         if (!p)
1744                 return NULL;
1745         p->kind = Compare_kind;
1746         p->v.Compare.left = left;
1747         p->v.Compare.ops = ops;
1748         p->v.Compare.comparators = comparators;
1749         p->lineno = lineno;
1750         p->col_offset = col_offset;
1751         return p;
1752 }
1753
1754 expr_ty
1755 Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, expr_ty starargs,
1756      expr_ty kwargs, int lineno, int col_offset, PyArena *arena)
1757 {
1758         expr_ty p;
1759         if (!func) {
1760                 PyErr_SetString(PyExc_ValueError,
1761                                 "field func is required for Call");
1762                 return NULL;
1763         }
1764         p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1765         if (!p)
1766                 return NULL;
1767         p->kind = Call_kind;
1768         p->v.Call.func = func;
1769         p->v.Call.args = args;
1770         p->v.Call.keywords = keywords;
1771         p->v.Call.starargs = starargs;
1772         p->v.Call.kwargs = kwargs;
1773         p->lineno = lineno;
1774         p->col_offset = col_offset;
1775         return p;
1776 }
1777
1778 expr_ty
1779 Repr(expr_ty value, int lineno, int col_offset, PyArena *arena)
1780 {
1781         expr_ty p;
1782         if (!value) {
1783                 PyErr_SetString(PyExc_ValueError,
1784                                 "field value is required for Repr");
1785                 return NULL;
1786         }
1787         p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1788         if (!p)
1789                 return NULL;
1790         p->kind = Repr_kind;
1791         p->v.Repr.value = value;
1792         p->lineno = lineno;
1793         p->col_offset = col_offset;
1794         return p;
1795 }
1796
1797 expr_ty
1798 Num(object n, int lineno, int col_offset, PyArena *arena)
1799 {
1800         expr_ty p;
1801         if (!n) {
1802                 PyErr_SetString(PyExc_ValueError,
1803                                 "field n is required for Num");
1804                 return NULL;
1805         }
1806         p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1807         if (!p)
1808                 return NULL;
1809         p->kind = Num_kind;
1810         p->v.Num.n = n;
1811         p->lineno = lineno;
1812         p->col_offset = col_offset;
1813         return p;
1814 }
1815
1816 expr_ty
1817 Str(string s, int lineno, int col_offset, PyArena *arena)
1818 {
1819         expr_ty p;
1820         if (!s) {
1821                 PyErr_SetString(PyExc_ValueError,
1822                                 "field s is required for Str");
1823                 return NULL;
1824         }
1825         p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1826         if (!p)
1827                 return NULL;
1828         p->kind = Str_kind;
1829         p->v.Str.s = s;
1830         p->lineno = lineno;
1831         p->col_offset = col_offset;
1832         return p;
1833 }
1834
1835 expr_ty
1836 Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int lineno, int
1837           col_offset, PyArena *arena)
1838 {
1839         expr_ty p;
1840         if (!value) {
1841                 PyErr_SetString(PyExc_ValueError,
1842                                 "field value is required for Attribute");
1843                 return NULL;
1844         }
1845         if (!attr) {
1846                 PyErr_SetString(PyExc_ValueError,
1847                                 "field attr is required for Attribute");
1848                 return NULL;
1849         }
1850         if (!ctx) {
1851                 PyErr_SetString(PyExc_ValueError,
1852                                 "field ctx is required for Attribute");
1853                 return NULL;
1854         }
1855         p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1856         if (!p)
1857                 return NULL;
1858         p->kind = Attribute_kind;
1859         p->v.Attribute.value = value;
1860         p->v.Attribute.attr = attr;
1861         p->v.Attribute.ctx = ctx;
1862         p->lineno = lineno;
1863         p->col_offset = col_offset;
1864         return p;
1865 }
1866
1867 expr_ty
1868 Subscript(expr_ty value, slice_ty slice, expr_context_ty ctx, int lineno, int
1869           col_offset, PyArena *arena)
1870 {
1871         expr_ty p;
1872         if (!value) {
1873                 PyErr_SetString(PyExc_ValueError,
1874                                 "field value is required for Subscript");
1875                 return NULL;
1876         }
1877         if (!slice) {
1878                 PyErr_SetString(PyExc_ValueError,
1879                                 "field slice is required for Subscript");
1880                 return NULL;
1881         }
1882         if (!ctx) {
1883                 PyErr_SetString(PyExc_ValueError,
1884                                 "field ctx is required for Subscript");
1885                 return NULL;
1886         }
1887         p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1888         if (!p)
1889                 return NULL;
1890         p->kind = Subscript_kind;
1891         p->v.Subscript.value = value;
1892         p->v.Subscript.slice = slice;
1893         p->v.Subscript.ctx = ctx;
1894         p->lineno = lineno;
1895         p->col_offset = col_offset;
1896         return p;
1897 }
1898
1899 expr_ty
1900 Name(identifier id, expr_context_ty ctx, int lineno, int col_offset, PyArena
1901      *arena)
1902 {
1903         expr_ty p;
1904         if (!id) {
1905                 PyErr_SetString(PyExc_ValueError,
1906                                 "field id is required for Name");
1907                 return NULL;
1908         }
1909         if (!ctx) {
1910                 PyErr_SetString(PyExc_ValueError,
1911                                 "field ctx is required for Name");
1912                 return NULL;
1913         }
1914         p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1915         if (!p)
1916                 return NULL;
1917         p->kind = Name_kind;
1918         p->v.Name.id = id;
1919         p->v.Name.ctx = ctx;
1920         p->lineno = lineno;
1921         p->col_offset = col_offset;
1922         return p;
1923 }
1924
1925 expr_ty
1926 List(asdl_seq * elts, expr_context_ty ctx, int lineno, int col_offset, PyArena
1927      *arena)
1928 {
1929         expr_ty p;
1930         if (!ctx) {
1931                 PyErr_SetString(PyExc_ValueError,
1932                                 "field ctx is required for List");
1933                 return NULL;
1934         }
1935         p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1936         if (!p)
1937                 return NULL;
1938         p->kind = List_kind;
1939         p->v.List.elts = elts;
1940         p->v.List.ctx = ctx;
1941         p->lineno = lineno;
1942         p->col_offset = col_offset;
1943         return p;
1944 }
1945
1946 expr_ty
1947 Tuple(asdl_seq * elts, expr_context_ty ctx, int lineno, int col_offset, PyArena
1948       *arena)
1949 {
1950         expr_ty p;
1951         if (!ctx) {
1952                 PyErr_SetString(PyExc_ValueError,
1953                                 "field ctx is required for Tuple");
1954                 return NULL;
1955         }
1956         p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
1957         if (!p)
1958                 return NULL;
1959         p->kind = Tuple_kind;
1960         p->v.Tuple.elts = elts;
1961         p->v.Tuple.ctx = ctx;
1962         p->lineno = lineno;
1963         p->col_offset = col_offset;
1964         return p;
1965 }
1966
1967 slice_ty
1968 Ellipsis(PyArena *arena)
1969 {
1970         slice_ty p;
1971         p = (slice_ty)PyArena_Malloc(arena, sizeof(*p));
1972         if (!p)
1973                 return NULL;
1974         p->kind = Ellipsis_kind;
1975         return p;
1976 }
1977
1978 slice_ty
1979 Slice(expr_ty lower, expr_ty upper, expr_ty step, PyArena *arena)
1980 {
1981         slice_ty p;
1982         p = (slice_ty)PyArena_Malloc(arena, sizeof(*p));
1983         if (!p)
1984                 return NULL;
1985         p->kind = Slice_kind;
1986         p->v.Slice.lower = lower;
1987         p->v.Slice.upper = upper;
1988         p->v.Slice.step = step;
1989         return p;
1990 }
1991
1992 slice_ty
1993 ExtSlice(asdl_seq * dims, PyArena *arena)
1994 {
1995         slice_ty p;
1996         p = (slice_ty)PyArena_Malloc(arena, sizeof(*p));
1997         if (!p)
1998                 return NULL;
1999         p->kind = ExtSlice_kind;
2000         p->v.ExtSlice.dims = dims;
2001         return p;
2002 }
2003
2004 slice_ty
2005 Index(expr_ty value, PyArena *arena)
2006 {
2007         slice_ty p;
2008         if (!value) {
2009                 PyErr_SetString(PyExc_ValueError,
2010                                 "field value is required for Index");
2011                 return NULL;
2012         }
2013         p = (slice_ty)PyArena_Malloc(arena, sizeof(*p));
2014         if (!p)
2015                 return NULL;
2016         p->kind = Index_kind;
2017         p->v.Index.value = value;
2018         return p;
2019 }
2020
2021 comprehension_ty
2022 comprehension(expr_ty target, expr_ty iter, asdl_seq * ifs, PyArena *arena)
2023 {
2024         comprehension_ty p;
2025         if (!target) {
2026                 PyErr_SetString(PyExc_ValueError,
2027                                 "field target is required for comprehension");
2028                 return NULL;
2029         }
2030         if (!iter) {
2031                 PyErr_SetString(PyExc_ValueError,
2032                                 "field iter is required for comprehension");
2033                 return NULL;
2034         }
2035         p = (comprehension_ty)PyArena_Malloc(arena, sizeof(*p));
2036         if (!p)
2037                 return NULL;
2038         p->target = target;
2039         p->iter = iter;
2040         p->ifs = ifs;
2041         return p;
2042 }
2043
2044 excepthandler_ty
2045 ExceptHandler(expr_ty type, expr_ty name, asdl_seq * body, int lineno, int
2046               col_offset, PyArena *arena)
2047 {
2048         excepthandler_ty p;
2049         p = (excepthandler_ty)PyArena_Malloc(arena, sizeof(*p));
2050         if (!p)
2051                 return NULL;
2052         p->kind = ExceptHandler_kind;
2053         p->v.ExceptHandler.type = type;
2054         p->v.ExceptHandler.name = name;
2055         p->v.ExceptHandler.body = body;
2056         p->lineno = lineno;
2057         p->col_offset = col_offset;
2058         return p;
2059 }
2060
2061 arguments_ty
2062 arguments(asdl_seq * args, identifier vararg, identifier kwarg, asdl_seq *
2063           defaults, PyArena *arena)
2064 {
2065         arguments_ty p;
2066         p = (arguments_ty)PyArena_Malloc(arena, sizeof(*p));
2067         if (!p)
2068                 return NULL;
2069         p->args = args;
2070         p->vararg = vararg;
2071         p->kwarg = kwarg;
2072         p->defaults = defaults;
2073         return p;
2074 }
2075
2076 keyword_ty
2077 keyword(identifier arg, expr_ty value, PyArena *arena)
2078 {
2079         keyword_ty p;
2080         if (!arg) {
2081                 PyErr_SetString(PyExc_ValueError,
2082                                 "field arg is required for keyword");
2083                 return NULL;
2084         }
2085         if (!value) {
2086                 PyErr_SetString(PyExc_ValueError,
2087                                 "field value is required for keyword");
2088                 return NULL;
2089         }
2090         p = (keyword_ty)PyArena_Malloc(arena, sizeof(*p));
2091         if (!p)
2092                 return NULL;
2093         p->arg = arg;
2094         p->value = value;
2095         return p;
2096 }
2097
2098 alias_ty
2099 alias(identifier name, identifier asname, PyArena *arena)
2100 {
2101         alias_ty p;
2102         if (!name) {
2103                 PyErr_SetString(PyExc_ValueError,
2104                                 "field name is required for alias");
2105                 return NULL;
2106         }
2107         p = (alias_ty)PyArena_Malloc(arena, sizeof(*p));
2108         if (!p)
2109                 return NULL;
2110         p->name = name;
2111         p->asname = asname;
2112         return p;
2113 }
2114
2115
2116 PyObject*
2117 ast2obj_mod(void* _o)
2118 {
2119         mod_ty o = (mod_ty)_o;
2120         PyObject *result = NULL, *value = NULL;
2121         if (!o) {
2122                 Py_INCREF(Py_None);
2123                 return Py_None;
2124         }
2125
2126         switch (o->kind) {
2127         case Module_kind:
2128                 result = PyType_GenericNew(Module_type, NULL, NULL);
2129                 if (!result) goto failed;
2130                 value = ast2obj_list(o->v.Module.body, ast2obj_stmt);
2131                 if (!value) goto failed;
2132                 if (PyObject_SetAttrString(result, "body", value) == -1)
2133                         goto failed;
2134                 Py_DECREF(value);
2135                 break;
2136         case Interactive_kind:
2137                 result = PyType_GenericNew(Interactive_type, NULL, NULL);
2138                 if (!result) goto failed;
2139                 value = ast2obj_list(o->v.Interactive.body, ast2obj_stmt);
2140                 if (!value) goto failed;
2141                 if (PyObject_SetAttrString(result, "body", value) == -1)
2142                         goto failed;
2143                 Py_DECREF(value);
2144                 break;
2145         case Expression_kind:
2146                 result = PyType_GenericNew(Expression_type, NULL, NULL);
2147                 if (!result) goto failed;
2148                 value = ast2obj_expr(o->v.Expression.body);
2149                 if (!value) goto failed;
2150                 if (PyObject_SetAttrString(result, "body", value) == -1)
2151                         goto failed;
2152                 Py_DECREF(value);
2153                 break;
2154         case Suite_kind:
2155                 result = PyType_GenericNew(Suite_type, NULL, NULL);
2156                 if (!result) goto failed;
2157                 value = ast2obj_list(o->v.Suite.body, ast2obj_stmt);
2158                 if (!value) goto failed;
2159                 if (PyObject_SetAttrString(result, "body", value) == -1)
2160                         goto failed;
2161                 Py_DECREF(value);
2162                 break;
2163         }
2164         return result;
2165 failed:
2166         Py_XDECREF(value);
2167         Py_XDECREF(result);
2168         return NULL;
2169 }
2170
2171 PyObject*
2172 ast2obj_stmt(void* _o)
2173 {
2174         stmt_ty o = (stmt_ty)_o;
2175         PyObject *result = NULL, *value = NULL;
2176         if (!o) {
2177                 Py_INCREF(Py_None);
2178                 return Py_None;
2179         }
2180
2181         switch (o->kind) {
2182         case FunctionDef_kind:
2183                 result = PyType_GenericNew(FunctionDef_type, NULL, NULL);
2184                 if (!result) goto failed;
2185                 value = ast2obj_identifier(o->v.FunctionDef.name);
2186                 if (!value) goto failed;
2187                 if (PyObject_SetAttrString(result, "name", value) == -1)
2188                         goto failed;
2189                 Py_DECREF(value);
2190                 value = ast2obj_arguments(o->v.FunctionDef.args);
2191                 if (!value) goto failed;
2192                 if (PyObject_SetAttrString(result, "args", value) == -1)
2193                         goto failed;
2194                 Py_DECREF(value);
2195                 value = ast2obj_list(o->v.FunctionDef.body, ast2obj_stmt);
2196                 if (!value) goto failed;
2197                 if (PyObject_SetAttrString(result, "body", value) == -1)
2198                         goto failed;
2199                 Py_DECREF(value);
2200                 value = ast2obj_list(o->v.FunctionDef.decorator_list,
2201                                      ast2obj_expr);
2202                 if (!value) goto failed;
2203                 if (PyObject_SetAttrString(result, "decorator_list", value) ==
2204                     -1)
2205                         goto failed;
2206                 Py_DECREF(value);
2207                 break;
2208         case ClassDef_kind:
2209                 result = PyType_GenericNew(ClassDef_type, NULL, NULL);
2210                 if (!result) goto failed;
2211                 value = ast2obj_identifier(o->v.ClassDef.name);
2212                 if (!value) goto failed;
2213                 if (PyObject_SetAttrString(result, "name", value) == -1)
2214                         goto failed;
2215                 Py_DECREF(value);
2216                 value = ast2obj_list(o->v.ClassDef.bases, ast2obj_expr);
2217                 if (!value) goto failed;
2218                 if (PyObject_SetAttrString(result, "bases", value) == -1)
2219                         goto failed;
2220                 Py_DECREF(value);
2221                 value = ast2obj_list(o->v.ClassDef.body, ast2obj_stmt);
2222                 if (!value) goto failed;
2223                 if (PyObject_SetAttrString(result, "body", value) == -1)
2224                         goto failed;
2225                 Py_DECREF(value);
2226                 value = ast2obj_list(o->v.ClassDef.decorator_list,
2227                                      ast2obj_expr);
2228                 if (!value) goto failed;
2229                 if (PyObject_SetAttrString(result, "decorator_list", value) ==
2230                     -1)
2231                         goto failed;
2232                 Py_DECREF(value);
2233                 break;
2234         case Return_kind:
2235                 result = PyType_GenericNew(Return_type, NULL, NULL);
2236                 if (!result) goto failed;
2237                 value = ast2obj_expr(o->v.Return.value);
2238                 if (!value) goto failed;
2239                 if (PyObject_SetAttrString(result, "value", value) == -1)
2240                         goto failed;
2241                 Py_DECREF(value);
2242                 break;
2243         case Delete_kind:
2244                 result = PyType_GenericNew(Delete_type, NULL, NULL);
2245                 if (!result) goto failed;
2246                 value = ast2obj_list(o->v.Delete.targets, ast2obj_expr);
2247                 if (!value) goto failed;
2248                 if (PyObject_SetAttrString(result, "targets", value) == -1)
2249                         goto failed;
2250                 Py_DECREF(value);
2251                 break;
2252         case Assign_kind:
2253                 result = PyType_GenericNew(Assign_type, NULL, NULL);
2254                 if (!result) goto failed;
2255                 value = ast2obj_list(o->v.Assign.targets, ast2obj_expr);
2256                 if (!value) goto failed;
2257                 if (PyObject_SetAttrString(result, "targets", value) == -1)
2258                         goto failed;
2259                 Py_DECREF(value);
2260                 value = ast2obj_expr(o->v.Assign.value);
2261                 if (!value) goto failed;
2262                 if (PyObject_SetAttrString(result, "value", value) == -1)
2263                         goto failed;
2264                 Py_DECREF(value);
2265                 break;
2266         case AugAssign_kind:
2267                 result = PyType_GenericNew(AugAssign_type, NULL, NULL);
2268                 if (!result) goto failed;
2269                 value = ast2obj_expr(o->v.AugAssign.target);
2270                 if (!value) goto failed;
2271                 if (PyObject_SetAttrString(result, "target", value) == -1)
2272                         goto failed;
2273                 Py_DECREF(value);
2274                 value = ast2obj_operator(o->v.AugAssign.op);
2275                 if (!value) goto failed;
2276                 if (PyObject_SetAttrString(result, "op", value) == -1)
2277                         goto failed;
2278                 Py_DECREF(value);
2279                 value = ast2obj_expr(o->v.AugAssign.value);
2280                 if (!value) goto failed;
2281                 if (PyObject_SetAttrString(result, "value", value) == -1)
2282                         goto failed;
2283                 Py_DECREF(value);
2284                 break;
2285         case Print_kind:
2286                 result = PyType_GenericNew(Print_type, NULL, NULL);
2287                 if (!result) goto failed;
2288                 value = ast2obj_expr(o->v.Print.dest);
2289                 if (!value) goto failed;
2290                 if (PyObject_SetAttrString(result, "dest", value) == -1)
2291                         goto failed;
2292                 Py_DECREF(value);
2293                 value = ast2obj_list(o->v.Print.values, ast2obj_expr);
2294                 if (!value) goto failed;
2295                 if (PyObject_SetAttrString(result, "values", value) == -1)
2296                         goto failed;
2297                 Py_DECREF(value);
2298                 value = ast2obj_bool(o->v.Print.nl);
2299                 if (!value) goto failed;
2300                 if (PyObject_SetAttrString(result, "nl", value) == -1)
2301                         goto failed;
2302                 Py_DECREF(value);
2303                 break;
2304         case For_kind:
2305                 result = PyType_GenericNew(For_type, NULL, NULL);
2306                 if (!result) goto failed;
2307                 value = ast2obj_expr(o->v.For.target);
2308                 if (!value) goto failed;
2309                 if (PyObject_SetAttrString(result, "target", value) == -1)
2310                         goto failed;
2311                 Py_DECREF(value);
2312                 value = ast2obj_expr(o->v.For.iter);
2313                 if (!value) goto failed;
2314                 if (PyObject_SetAttrString(result, "iter", value) == -1)
2315                         goto failed;
2316                 Py_DECREF(value);
2317                 value = ast2obj_list(o->v.For.body, ast2obj_stmt);
2318                 if (!value) goto failed;
2319                 if (PyObject_SetAttrString(result, "body", value) == -1)
2320                         goto failed;
2321                 Py_DECREF(value);
2322                 value = ast2obj_list(o->v.For.orelse, ast2obj_stmt);
2323                 if (!value) goto failed;
2324                 if (PyObject_SetAttrString(result, "orelse", value) == -1)
2325                         goto failed;
2326                 Py_DECREF(value);
2327                 break;
2328         case While_kind:
2329                 result = PyType_GenericNew(While_type, NULL, NULL);
2330                 if (!result) goto failed;
2331                 value = ast2obj_expr(o->v.While.test);
2332                 if (!value) goto failed;
2333                 if (PyObject_SetAttrString(result, "test", value) == -1)
2334                         goto failed;
2335                 Py_DECREF(value);
2336                 value = ast2obj_list(o->v.While.body, ast2obj_stmt);
2337                 if (!value) goto failed;
2338                 if (PyObject_SetAttrString(result, "body", value) == -1)
2339                         goto failed;
2340                 Py_DECREF(value);
2341                 value = ast2obj_list(o->v.While.orelse, ast2obj_stmt);
2342                 if (!value) goto failed;
2343                 if (PyObject_SetAttrString(result, "orelse", value) == -1)
2344                         goto failed;
2345                 Py_DECREF(value);
2346                 break;
2347         case If_kind:
2348                 result = PyType_GenericNew(If_type, NULL, NULL);
2349                 if (!result) goto failed;
2350                 value = ast2obj_expr(o->v.If.test);
2351                 if (!value) goto failed;
2352                 if (PyObject_SetAttrString(result, "test", value) == -1)
2353                         goto failed;
2354                 Py_DECREF(value);
2355                 value = ast2obj_list(o->v.If.body, ast2obj_stmt);
2356                 if (!value) goto failed;
2357                 if (PyObject_SetAttrString(result, "body", value) == -1)
2358                         goto failed;
2359                 Py_DECREF(value);
2360                 value = ast2obj_list(o->v.If.orelse, ast2obj_stmt);
2361                 if (!value) goto failed;
2362                 if (PyObject_SetAttrString(result, "orelse", value) == -1)
2363                         goto failed;
2364                 Py_DECREF(value);
2365                 break;
2366         case With_kind:
2367                 result = PyType_GenericNew(With_type, NULL, NULL);
2368                 if (!result) goto failed;
2369                 value = ast2obj_expr(o->v.With.context_expr);
2370                 if (!value) goto failed;
2371                 if (PyObject_SetAttrString(result, "context_expr", value) == -1)
2372                         goto failed;
2373                 Py_DECREF(value);
2374                 value = ast2obj_expr(o->v.With.optional_vars);
2375                 if (!value) goto failed;
2376                 if (PyObject_SetAttrString(result, "optional_vars", value) ==
2377                     -1)
2378                         goto failed;
2379                 Py_DECREF(value);
2380                 value = ast2obj_list(o->v.With.body, ast2obj_stmt);
2381                 if (!value) goto failed;
2382                 if (PyObject_SetAttrString(result, "body", value) == -1)
2383                         goto failed;
2384                 Py_DECREF(value);
2385                 break;
2386         case Raise_kind:
2387                 result = PyType_GenericNew(Raise_type, NULL, NULL);
2388                 if (!result) goto failed;
2389                 value = ast2obj_expr(o->v.Raise.type);
2390                 if (!value) goto failed;
2391                 if (PyObject_SetAttrString(result, "type", value) == -1)
2392                         goto failed;
2393                 Py_DECREF(value);
2394                 value = ast2obj_expr(o->v.Raise.inst);
2395                 if (!value) goto failed;
2396                 if (PyObject_SetAttrString(result, "inst", value) == -1)
2397                         goto failed;
2398                 Py_DECREF(value);
2399                 value = ast2obj_expr(o->v.Raise.tback);
2400                 if (!value) goto failed;
2401                 if (PyObject_SetAttrString(result, "tback", value) == -1)
2402                         goto failed;
2403                 Py_DECREF(value);
2404                 break;
2405         case TryExcept_kind:
2406                 result = PyType_GenericNew(TryExcept_type, NULL, NULL);
2407                 if (!result) goto failed;
2408                 value = ast2obj_list(o->v.TryExcept.body, ast2obj_stmt);
2409                 if (!value) goto failed;
2410                 if (PyObject_SetAttrString(result, "body", value) == -1)
2411                         goto failed;
2412                 Py_DECREF(value);
2413                 value = ast2obj_list(o->v.TryExcept.handlers,
2414                                      ast2obj_excepthandler);
2415                 if (!value) goto failed;
2416                 if (PyObject_SetAttrString(result, "handlers", value) == -1)
2417                         goto failed;
2418                 Py_DECREF(value);
2419                 value = ast2obj_list(o->v.TryExcept.orelse, ast2obj_stmt);
2420                 if (!value) goto failed;
2421                 if (PyObject_SetAttrString(result, "orelse", value) == -1)
2422                         goto failed;
2423                 Py_DECREF(value);
2424                 break;
2425         case TryFinally_kind:
2426                 result = PyType_GenericNew(TryFinally_type, NULL, NULL);
2427                 if (!result) goto failed;
2428                 value = ast2obj_list(o->v.TryFinally.body, ast2obj_stmt);
2429                 if (!value) goto failed;
2430                 if (PyObject_SetAttrString(result, "body", value) == -1)
2431                         goto failed;
2432                 Py_DECREF(value);
2433                 value = ast2obj_list(o->v.TryFinally.finalbody, ast2obj_stmt);
2434                 if (!value) goto failed;
2435                 if (PyObject_SetAttrString(result, "finalbody", value) == -1)
2436                         goto failed;
2437                 Py_DECREF(value);
2438                 break;
2439         case Assert_kind:
2440                 result = PyType_GenericNew(Assert_type, NULL, NULL);
2441                 if (!result) goto failed;
2442                 value = ast2obj_expr(o->v.Assert.test);
2443                 if (!value) goto failed;
2444                 if (PyObject_SetAttrString(result, "test", value) == -1)
2445                         goto failed;
2446                 Py_DECREF(value);
2447                 value = ast2obj_expr(o->v.Assert.msg);
2448                 if (!value) goto failed;
2449                 if (PyObject_SetAttrString(result, "msg", value) == -1)
2450                         goto failed;
2451                 Py_DECREF(value);
2452                 break;
2453         case Import_kind:
2454                 result = PyType_GenericNew(Import_type, NULL, NULL);
2455                 if (!result) goto failed;
2456                 value = ast2obj_list(o->v.Import.names, ast2obj_alias);
2457                 if (!value) goto failed;
2458                 if (PyObject_SetAttrString(result, "names", value) == -1)
2459                         goto failed;
2460                 Py_DECREF(value);
2461                 break;
2462         case ImportFrom_kind:
2463                 result = PyType_GenericNew(ImportFrom_type, NULL, NULL);
2464                 if (!result) goto failed;
2465                 value = ast2obj_identifier(o->v.ImportFrom.module);
2466                 if (!value) goto failed;
2467                 if (PyObject_SetAttrString(result, "module", value) == -1)
2468                         goto failed;
2469                 Py_DECREF(value);
2470                 value = ast2obj_list(o->v.ImportFrom.names, ast2obj_alias);
2471                 if (!value) goto failed;
2472                 if (PyObject_SetAttrString(result, "names", value) == -1)
2473                         goto failed;
2474                 Py_DECREF(value);
2475                 value = ast2obj_int(o->v.ImportFrom.level);
2476                 if (!value) goto failed;
2477                 if (PyObject_SetAttrString(result, "level", value) == -1)
2478                         goto failed;
2479                 Py_DECREF(value);
2480                 break;
2481         case Exec_kind:
2482                 result = PyType_GenericNew(Exec_type, NULL, NULL);
2483                 if (!result) goto failed;
2484                 value = ast2obj_expr(o->v.Exec.body);
2485                 if (!value) goto failed;
2486                 if (PyObject_SetAttrString(result, "body", value) == -1)
2487                         goto failed;
2488                 Py_DECREF(value);
2489                 value = ast2obj_expr(o->v.Exec.globals);
2490                 if (!value) goto failed;
2491                 if (PyObject_SetAttrString(result, "globals", value) == -1)
2492                         goto failed;
2493                 Py_DECREF(value);
2494                 value = ast2obj_expr(o->v.Exec.locals);
2495                 if (!value) goto failed;
2496                 if (PyObject_SetAttrString(result, "locals", value) == -1)
2497                         goto failed;
2498                 Py_DECREF(value);
2499                 break;
2500         case Global_kind:
2501                 result = PyType_GenericNew(Global_type, NULL, NULL);
2502                 if (!result) goto failed;
2503                 value = ast2obj_list(o->v.Global.names, ast2obj_identifier);
2504                 if (!value) goto failed;
2505                 if (PyObject_SetAttrString(result, "names", value) == -1)
2506                         goto failed;
2507                 Py_DECREF(value);
2508                 break;
2509         case Expr_kind:
2510                 result = PyType_GenericNew(Expr_type, NULL, NULL);
2511                 if (!result) goto failed;
2512                 value = ast2obj_expr(o->v.Expr.value);
2513                 if (!value) goto failed;
2514                 if (PyObject_SetAttrString(result, "value", value) == -1)
2515                         goto failed;
2516                 Py_DECREF(value);
2517                 break;
2518         case Pass_kind:
2519                 result = PyType_GenericNew(Pass_type, NULL, NULL);
2520                 if (!result) goto failed;
2521                 break;
2522         case Break_kind:
2523                 result = PyType_GenericNew(Break_type, NULL, NULL);
2524                 if (!result) goto failed;
2525                 break;
2526         case Continue_kind:
2527                 result = PyType_GenericNew(Continue_type, NULL, NULL);
2528                 if (!result) goto failed;
2529                 break;
2530         }
2531         value = ast2obj_int(o->lineno);
2532         if (!value) goto failed;
2533         if (PyObject_SetAttrString(result, "lineno", value) < 0)
2534                 goto failed;
2535         Py_DECREF(value);
2536         value = ast2obj_int(o->col_offset);
2537         if (!value) goto failed;
2538         if (PyObject_SetAttrString(result, "col_offset", value) < 0)
2539                 goto failed;
2540         Py_DECREF(value);
2541         return result;
2542 failed:
2543         Py_XDECREF(value);
2544         Py_XDECREF(result);
2545         return NULL;
2546 }
2547
2548 PyObject*
2549 ast2obj_expr(void* _o)
2550 {
2551         expr_ty o = (expr_ty)_o;
2552         PyObject *result = NULL, *value = NULL;
2553         if (!o) {
2554                 Py_INCREF(Py_None);
2555                 return Py_None;
2556         }
2557
2558         switch (o->kind) {
2559         case BoolOp_kind:
2560                 result = PyType_GenericNew(BoolOp_type, NULL, NULL);
2561                 if (!result) goto failed;
2562                 value = ast2obj_boolop(o->v.BoolOp.op);
2563                 if (!value) goto failed;
2564                 if (PyObject_SetAttrString(result, "op", value) == -1)
2565                         goto failed;
2566                 Py_DECREF(value);
2567                 value = ast2obj_list(o->v.BoolOp.values, ast2obj_expr);
2568                 if (!value) goto failed;
2569                 if (PyObject_SetAttrString(result, "values", value) == -1)
2570                         goto failed;
2571                 Py_DECREF(value);
2572                 break;
2573         case BinOp_kind:
2574                 result = PyType_GenericNew(BinOp_type, NULL, NULL);
2575                 if (!result) goto failed;
2576                 value = ast2obj_expr(o->v.BinOp.left);
2577                 if (!value) goto failed;
2578                 if (PyObject_SetAttrString(result, "left", value) == -1)
2579                         goto failed;
2580                 Py_DECREF(value);
2581                 value = ast2obj_operator(o->v.BinOp.op);
2582                 if (!value) goto failed;
2583                 if (PyObject_SetAttrString(result, "op", value) == -1)
2584                         goto failed;
2585                 Py_DECREF(value);
2586                 value = ast2obj_expr(o->v.BinOp.right);
2587                 if (!value) goto failed;
2588                 if (PyObject_SetAttrString(result, "right", value) == -1)
2589                         goto failed;
2590                 Py_DECREF(value);
2591                 break;
2592         case UnaryOp_kind:
2593                 result = PyType_GenericNew(UnaryOp_type, NULL, NULL);
2594                 if (!result) goto failed;
2595                 value = ast2obj_unaryop(o->v.UnaryOp.op);
2596                 if (!value) goto failed;
2597                 if (PyObject_SetAttrString(result, "op", value) == -1)
2598                         goto failed;
2599                 Py_DECREF(value);
2600                 value = ast2obj_expr(o->v.UnaryOp.operand);
2601                 if (!value) goto failed;
2602                 if (PyObject_SetAttrString(result, "operand", value) == -1)
2603                         goto failed;
2604                 Py_DECREF(value);
2605                 break;
2606         case Lambda_kind:
2607                 result = PyType_GenericNew(Lambda_type, NULL, NULL);
2608                 if (!result) goto failed;
2609                 value = ast2obj_arguments(o->v.Lambda.args);
2610                 if (!value) goto failed;
2611                 if (PyObject_SetAttrString(result, "args", value) == -1)
2612                         goto failed;
2613                 Py_DECREF(value);
2614                 value = ast2obj_expr(o->v.Lambda.body);
2615                 if (!value) goto failed;
2616                 if (PyObject_SetAttrString(result, "body", value) == -1)
2617                         goto failed;
2618                 Py_DECREF(value);
2619                 break;
2620         case IfExp_kind:
2621                 result = PyType_GenericNew(IfExp_type, NULL, NULL);
2622                 if (!result) goto failed;
2623                 value = ast2obj_expr(o->v.IfExp.test);
2624                 if (!value) goto failed;
2625                 if (PyObject_SetAttrString(result, "test", value) == -1)
2626                         goto failed;
2627                 Py_DECREF(value);
2628                 value = ast2obj_expr(o->v.IfExp.body);
2629                 if (!value) goto failed;
2630                 if (PyObject_SetAttrString(result, "body", value) == -1)
2631                         goto failed;
2632                 Py_DECREF(value);
2633                 value = ast2obj_expr(o->v.IfExp.orelse);
2634                 if (!value) goto failed;
2635                 if (PyObject_SetAttrString(result, "orelse", value) == -1)
2636                         goto failed;
2637                 Py_DECREF(value);
2638                 break;
2639         case Dict_kind:
2640                 result = PyType_GenericNew(Dict_type, NULL, NULL);
2641                 if (!result) goto failed;
2642                 value = ast2obj_list(o->v.Dict.keys, ast2obj_expr);
2643                 if (!value) goto failed;
2644                 if (PyObject_SetAttrString(result, "keys", value) == -1)
2645                         goto failed;
2646                 Py_DECREF(value);
2647                 value = ast2obj_list(o->v.Dict.values, ast2obj_expr);
2648                 if (!value) goto failed;
2649                 if (PyObject_SetAttrString(result, "values", value) == -1)
2650                         goto failed;
2651                 Py_DECREF(value);
2652                 break;
2653         case Set_kind:
2654                 result = PyType_GenericNew(Set_type, NULL, NULL);
2655                 if (!result) goto failed;
2656                 value = ast2obj_list(o->v.Set.elts, ast2obj_expr);
2657                 if (!value) goto failed;
2658                 if (PyObject_SetAttrString(result, "elts", value) == -1)
2659                         goto failed;
2660                 Py_DECREF(value);
2661                 break;
2662         case ListComp_kind:
2663                 result = PyType_GenericNew(ListComp_type, NULL, NULL);
2664                 if (!result) goto failed;
2665                 value = ast2obj_expr(o->v.ListComp.elt);
2666                 if (!value) goto failed;
2667                 if (PyObject_SetAttrString(result, "elt", value) == -1)
2668                         goto failed;
2669                 Py_DECREF(value);
2670                 value = ast2obj_list(o->v.ListComp.generators,
2671                                      ast2obj_comprehension);
2672                 if (!value) goto failed;
2673                 if (PyObject_SetAttrString(result, "generators", value) == -1)
2674                         goto failed;
2675                 Py_DECREF(value);
2676                 break;
2677         case SetComp_kind:
2678                 result = PyType_GenericNew(SetComp_type, NULL, NULL);
2679                 if (!result) goto failed;
2680                 value = ast2obj_expr(o->v.SetComp.elt);
2681                 if (!value) goto failed;
2682                 if (PyObject_SetAttrString(result, "elt", value) == -1)
2683                         goto failed;
2684                 Py_DECREF(value);
2685                 value = ast2obj_list(o->v.SetComp.generators,
2686                                      ast2obj_comprehension);
2687                 if (!value) goto failed;
2688                 if (PyObject_SetAttrString(result, "generators", value) == -1)
2689                         goto failed;
2690                 Py_DECREF(value);
2691                 break;
2692         case DictComp_kind:
2693                 result = PyType_GenericNew(DictComp_type, NULL, NULL);
2694                 if (!result) goto failed;
2695                 value = ast2obj_expr(o->v.DictComp.key);
2696                 if (!value) goto failed;
2697                 if (PyObject_SetAttrString(result, "key", value) == -1)
2698                         goto failed;
2699                 Py_DECREF(value);
2700                 value = ast2obj_expr(o->v.DictComp.value);
2701                 if (!value) goto failed;
2702                 if (PyObject_SetAttrString(result, "value", value) == -1)
2703                         goto failed;
2704                 Py_DECREF(value);
2705                 value = ast2obj_list(o->v.DictComp.generators,
2706                                      ast2obj_comprehension);
2707                 if (!value) goto failed;
2708                 if (PyObject_SetAttrString(result, "generators", value) == -1)
2709                         goto failed;
2710                 Py_DECREF(value);
2711                 break;
2712         case GeneratorExp_kind:
2713                 result = PyType_GenericNew(GeneratorExp_type, NULL, NULL);
2714                 if (!result) goto failed;
2715                 value = ast2obj_expr(o->v.GeneratorExp.elt);
2716                 if (!value) goto failed;
2717                 if (PyObject_SetAttrString(result, "elt", value) == -1)
2718                         goto failed;
2719                 Py_DECREF(value);
2720                 value = ast2obj_list(o->v.GeneratorExp.generators,
2721                                      ast2obj_comprehension);
2722                 if (!value) goto failed;
2723                 if (PyObject_SetAttrString(result, "generators", value) == -1)
2724                         goto failed;
2725                 Py_DECREF(value);
2726                 break;
2727         case Yield_kind:
2728                 result = PyType_GenericNew(Yield_type, NULL, NULL);
2729                 if (!result) goto failed;
2730                 value = ast2obj_expr(o->v.Yield.value);
2731                 if (!value) goto failed;
2732                 if (PyObject_SetAttrString(result, "value", value) == -1)
2733                         goto failed;
2734                 Py_DECREF(value);
2735                 break;
2736         case Compare_kind:
2737                 result = PyType_GenericNew(Compare_type, NULL, NULL);
2738                 if (!result) goto failed;
2739                 value = ast2obj_expr(o->v.Compare.left);
2740                 if (!value) goto failed;
2741                 if (PyObject_SetAttrString(result, "left", value) == -1)
2742                         goto failed;
2743                 Py_DECREF(value);
2744                 {
2745                         int i, n = asdl_seq_LEN(o->v.Compare.ops);
2746                         value = PyList_New(n);
2747                         if (!value) goto failed;
2748                         for(i = 0; i < n; i++)
2749                                 PyList_SET_ITEM(value, i, ast2obj_cmpop((cmpop_ty)asdl_seq_GET(o->v.Compare.ops, i)));
2750                 }
2751                 if (!value) goto failed;
2752                 if (PyObject_SetAttrString(result, "ops", value) == -1)
2753                         goto failed;
2754                 Py_DECREF(value);
2755                 value = ast2obj_list(o->v.Compare.comparators, ast2obj_expr);
2756                 if (!value) goto failed;
2757                 if (PyObject_SetAttrString(result, "comparators", value) == -1)
2758                         goto failed;
2759                 Py_DECREF(value);
2760                 break;
2761         case Call_kind:
2762                 result = PyType_GenericNew(Call_type, NULL, NULL);
2763                 if (!result) goto failed;
2764                 value = ast2obj_expr(o->v.Call.func);
2765                 if (!value) goto failed;
2766                 if (PyObject_SetAttrString(result, "func", value) == -1)
2767                         goto failed;
2768                 Py_DECREF(value);
2769                 value = ast2obj_list(o->v.Call.args, ast2obj_expr);
2770                 if (!value) goto failed;
2771                 if (PyObject_SetAttrString(result, "args", value) == -1)
2772                         goto failed;
2773                 Py_DECREF(value);
2774                 value = ast2obj_list(o->v.Call.keywords, ast2obj_keyword);
2775                 if (!value) goto failed;
2776                 if (PyObject_SetAttrString(result, "keywords", value) == -1)
2777                         goto failed;
2778                 Py_DECREF(value);
2779                 value = ast2obj_expr(o->v.Call.starargs);
2780                 if (!value) goto failed;
2781                 if (PyObject_SetAttrString(result, "starargs", value) == -1)
2782                         goto failed;
2783                 Py_DECREF(value);
2784                 value = ast2obj_expr(o->v.Call.kwargs);
2785                 if (!value) goto failed;
2786                 if (PyObject_SetAttrString(result, "kwargs", value) == -1)
2787                         goto failed;
2788                 Py_DECREF(value);
2789                 break;
2790         case Repr_kind:
2791                 result = PyType_GenericNew(Repr_type, NULL, NULL);
2792                 if (!result) goto failed;
2793                 value = ast2obj_expr(o->v.Repr.value);
2794                 if (!value) goto failed;
2795                 if (PyObject_SetAttrString(result, "value", value) == -1)
2796                         goto failed;
2797                 Py_DECREF(value);
2798                 break;
2799         case Num_kind:
2800                 result = PyType_GenericNew(Num_type, NULL, NULL);
2801                 if (!result) goto failed;
2802                 value = ast2obj_object(o->v.Num.n);
2803                 if (!value) goto failed;
2804                 if (PyObject_SetAttrString(result, "n", value) == -1)
2805                         goto failed;
2806                 Py_DECREF(value);
2807                 break;
2808         case Str_kind:
2809                 result = PyType_GenericNew(Str_type, NULL, NULL);
2810                 if (!result) goto failed;
2811                 value = ast2obj_string(o->v.Str.s);
2812                 if (!value) goto failed;
2813                 if (PyObject_SetAttrString(result, "s", value) == -1)
2814                         goto failed;
2815                 Py_DECREF(value);
2816                 break;
2817         case Attribute_kind:
2818                 result = PyType_GenericNew(Attribute_type, NULL, NULL);
2819                 if (!result) goto failed;
2820                 value = ast2obj_expr(o->v.Attribute.value);
2821                 if (!value) goto failed;
2822                 if (PyObject_SetAttrString(result, "value", value) == -1)
2823                         goto failed;
2824                 Py_DECREF(value);
2825                 value = ast2obj_identifier(o->v.Attribute.attr);
2826                 if (!value) goto failed;
2827                 if (PyObject_SetAttrString(result, "attr", value) == -1)
2828                         goto failed;
2829                 Py_DECREF(value);
2830                 value = ast2obj_expr_context(o->v.Attribute.ctx);
2831                 if (!value) goto failed;
2832                 if (PyObject_SetAttrString(result, "ctx", value) == -1)
2833                         goto failed;
2834                 Py_DECREF(value);
2835                 break;
2836         case Subscript_kind:
2837                 result = PyType_GenericNew(Subscript_type, NULL, NULL);
2838                 if (!result) goto failed;
2839                 value = ast2obj_expr(o->v.Subscript.value);
2840                 if (!value) goto failed;
2841                 if (PyObject_SetAttrString(result, "value", value) == -1)
2842                         goto failed;
2843                 Py_DECREF(value);
2844                 value = ast2obj_slice(o->v.Subscript.slice);
2845                 if (!value) goto failed;
2846                 if (PyObject_SetAttrString(result, "slice", value) == -1)
2847                         goto failed;
2848                 Py_DECREF(value);
2849                 value = ast2obj_expr_context(o->v.Subscript.ctx);
2850                 if (!value) goto failed;
2851                 if (PyObject_SetAttrString(result, "ctx", value) == -1)
2852                         goto failed;
2853                 Py_DECREF(value);
2854                 break;
2855         case Name_kind:
2856                 result = PyType_GenericNew(Name_type, NULL, NULL);
2857                 if (!result) goto failed;
2858                 value = ast2obj_identifier(o->v.Name.id);
2859                 if (!value) goto failed;
2860                 if (PyObject_SetAttrString(result, "id", value) == -1)
2861                         goto failed;
2862                 Py_DECREF(value);
2863                 value = ast2obj_expr_context(o->v.Name.ctx);
2864                 if (!value) goto failed;
2865                 if (PyObject_SetAttrString(result, "ctx", value) == -1)
2866                         goto failed;
2867                 Py_DECREF(value);
2868                 break;
2869         case List_kind:
2870                 result = PyType_GenericNew(List_type, NULL, NULL);
2871                 if (!result) goto failed;
2872                 value = ast2obj_list(o->v.List.elts, ast2obj_expr);
2873                 if (!value) goto failed;
2874                 if (PyObject_SetAttrString(result, "elts", value) == -1)
2875                         goto failed;
2876                 Py_DECREF(value);
2877                 value = ast2obj_expr_context(o->v.List.ctx);
2878                 if (!value) goto failed;
2879                 if (PyObject_SetAttrString(result, "ctx", value) == -1)
2880                         goto failed;
2881                 Py_DECREF(value);
2882                 break;
2883         case Tuple_kind:
2884                 result = PyType_GenericNew(Tuple_type, NULL, NULL);
2885                 if (!result) goto failed;
2886                 value = ast2obj_list(o->v.Tuple.elts, ast2obj_expr);
2887                 if (!value) goto failed;
2888                 if (PyObject_SetAttrString(result, "elts", value) == -1)
2889                         goto failed;
2890                 Py_DECREF(value);
2891                 value = ast2obj_expr_context(o->v.Tuple.ctx);
2892                 if (!value) goto failed;
2893                 if (PyObject_SetAttrString(result, "ctx", value) == -1)
2894                         goto failed;
2895                 Py_DECREF(value);
2896                 break;
2897         }
2898         value = ast2obj_int(o->lineno);
2899         if (!value) goto failed;
2900         if (PyObject_SetAttrString(result, "lineno", value) < 0)
2901                 goto failed;
2902         Py_DECREF(value);
2903         value = ast2obj_int(o->col_offset);
2904         if (!value) goto failed;
2905         if (PyObject_SetAttrString(result, "col_offset", value) < 0)
2906                 goto failed;
2907         Py_DECREF(value);
2908         return result;
2909 failed:
2910         Py_XDECREF(value);
2911         Py_XDECREF(result);
2912         return NULL;
2913 }
2914
2915 PyObject* ast2obj_expr_context(expr_context_ty o)
2916 {
2917         switch(o) {
2918                 case Load:
2919                         Py_INCREF(Load_singleton);
2920                         return Load_singleton;
2921                 case Store:
2922                         Py_INCREF(Store_singleton);
2923                         return Store_singleton;
2924                 case Del:
2925                         Py_INCREF(Del_singleton);
2926                         return Del_singleton;
2927                 case AugLoad:
2928                         Py_INCREF(AugLoad_singleton);
2929                         return AugLoad_singleton;
2930                 case AugStore:
2931                         Py_INCREF(AugStore_singleton);
2932                         return AugStore_singleton;
2933                 case Param:
2934                         Py_INCREF(Param_singleton);
2935                         return Param_singleton;
2936                 default:
2937                         /* should never happen, but just in case ... */
2938                         PyErr_Format(PyExc_SystemError, "unknown expr_context found");
2939                         return NULL;
2940         }
2941 }
2942 PyObject*
2943 ast2obj_slice(void* _o)
2944 {
2945         slice_ty o = (slice_ty)_o;
2946         PyObject *result = NULL, *value = NULL;
2947         if (!o) {
2948                 Py_INCREF(Py_None);
2949                 return Py_None;
2950         }
2951
2952         switch (o->kind) {
2953         case Ellipsis_kind:
2954                 result = PyType_GenericNew(Ellipsis_type, NULL, NULL);
2955                 if (!result) goto failed;
2956                 break;
2957         case Slice_kind:
2958                 result = PyType_GenericNew(Slice_type, NULL, NULL);
2959                 if (!result) goto failed;
2960                 value = ast2obj_expr(o->v.Slice.lower);
2961                 if (!value) goto failed;
2962                 if (PyObject_SetAttrString(result, "lower", value) == -1)
2963                         goto failed;
2964                 Py_DECREF(value);
2965                 value = ast2obj_expr(o->v.Slice.upper);
2966                 if (!value) goto failed;
2967                 if (PyObject_SetAttrString(result, "upper", value) == -1)
2968                         goto failed;
2969                 Py_DECREF(value);
2970                 value = ast2obj_expr(o->v.Slice.step);
2971                 if (!value) goto failed;
2972                 if (PyObject_SetAttrString(result, "step", value) == -1)
2973                         goto failed;
2974                 Py_DECREF(value);
2975                 break;
2976         case ExtSlice_kind:
2977                 result = PyType_GenericNew(ExtSlice_type, NULL, NULL);
2978                 if (!result) goto failed;
2979                 value = ast2obj_list(o->v.ExtSlice.dims, ast2obj_slice);
2980                 if (!value) goto failed;
2981                 if (PyObject_SetAttrString(result, "dims", value) == -1)
2982                         goto failed;
2983                 Py_DECREF(value);
2984                 break;
2985         case Index_kind:
2986                 result = PyType_GenericNew(Index_type, NULL, NULL);
2987                 if (!result) goto failed;
2988                 value = ast2obj_expr(o->v.Index.value);
2989                 if (!value) goto failed;
2990                 if (PyObject_SetAttrString(result, "value", value) == -1)
2991                         goto failed;
2992                 Py_DECREF(value);
2993                 break;
2994         }
2995         return result;
2996 failed:
2997         Py_XDECREF(value);
2998         Py_XDECREF(result);
2999         return NULL;
3000 }
3001
3002 PyObject* ast2obj_boolop(boolop_ty o)
3003 {
3004         switch(o) {
3005                 case And:
3006                         Py_INCREF(And_singleton);
3007                         return And_singleton;
3008                 case Or:
3009                         Py_INCREF(Or_singleton);
3010                         return Or_singleton;
3011                 default:
3012                         /* should never happen, but just in case ... */
3013                         PyErr_Format(PyExc_SystemError, "unknown boolop found");
3014                         return NULL;
3015         }
3016 }
3017 PyObject* ast2obj_operator(operator_ty o)
3018 {
3019         switch(o) {
3020                 case Add:
3021                         Py_INCREF(Add_singleton);
3022                         return Add_singleton;
3023                 case Sub:
3024                         Py_INCREF(Sub_singleton);
3025                         return Sub_singleton;
3026                 case Mult:
3027                         Py_INCREF(Mult_singleton);
3028                         return Mult_singleton;
3029                 case Div:
3030                         Py_INCREF(Div_singleton);
3031                         return Div_singleton;
3032                 case Mod:
3033                         Py_INCREF(Mod_singleton);
3034                         return Mod_singleton;
3035                 case Pow:
3036                         Py_INCREF(Pow_singleton);
3037                         return Pow_singleton;
3038                 case LShift:
3039                         Py_INCREF(LShift_singleton);
3040                         return LShift_singleton;
3041                 case RShift:
3042                         Py_INCREF(RShift_singleton);
3043                         return RShift_singleton;
3044                 case BitOr:
3045                         Py_INCREF(BitOr_singleton);
3046                         return BitOr_singleton;
3047                 case BitXor:
3048                         Py_INCREF(BitXor_singleton);
3049                         return BitXor_singleton;
3050                 case BitAnd:
3051                         Py_INCREF(BitAnd_singleton);
3052                         return BitAnd_singleton;
3053                 case FloorDiv:
3054                         Py_INCREF(FloorDiv_singleton);
3055                         return FloorDiv_singleton;
3056                 default:
3057                         /* should never happen, but just in case ... */
3058                         PyErr_Format(PyExc_SystemError, "unknown operator found");
3059                         return NULL;
3060         }
3061 }
3062 PyObject* ast2obj_unaryop(unaryop_ty o)
3063 {
3064         switch(o) {
3065                 case Invert:
3066                         Py_INCREF(Invert_singleton);
3067                         return Invert_singleton;
3068                 case Not:
3069                         Py_INCREF(Not_singleton);
3070                         return Not_singleton;
3071                 case UAdd:
3072                         Py_INCREF(UAdd_singleton);
3073                         return UAdd_singleton;
3074                 case USub:
3075                         Py_INCREF(USub_singleton);
3076                         return USub_singleton;
3077                 default:
3078                         /* should never happen, but just in case ... */
3079                         PyErr_Format(PyExc_SystemError, "unknown unaryop found");
3080                         return NULL;
3081         }
3082 }
3083 PyObject* ast2obj_cmpop(cmpop_ty o)
3084 {
3085         switch(o) {
3086                 case Eq:
3087                         Py_INCREF(Eq_singleton);
3088                         return Eq_singleton;
3089                 case NotEq:
3090                         Py_INCREF(NotEq_singleton);
3091                         return NotEq_singleton;
3092                 case Lt:
3093                         Py_INCREF(Lt_singleton);
3094                         return Lt_singleton;
3095                 case LtE:
3096                         Py_INCREF(LtE_singleton);
3097                         return LtE_singleton;
3098                 case Gt:
3099                         Py_INCREF(Gt_singleton);
3100                         return Gt_singleton;
3101                 case GtE:
3102                         Py_INCREF(GtE_singleton);
3103                         return GtE_singleton;
3104                 case Is:
3105                         Py_INCREF(Is_singleton);
3106                         return Is_singleton;
3107                 case IsNot:
3108                         Py_INCREF(IsNot_singleton);
3109                         return IsNot_singleton;
3110                 case In:
3111                         Py_INCREF(In_singleton);
3112                         return In_singleton;
3113                 case NotIn:
3114                         Py_INCREF(NotIn_singleton);
3115                         return NotIn_singleton;
3116                 default:
3117                         /* should never happen, but just in case ... */
3118                         PyErr_Format(PyExc_SystemError, "unknown cmpop found");
3119                         return NULL;
3120         }
3121 }
3122 PyObject*
3123 ast2obj_comprehension(void* _o)
3124 {
3125         comprehension_ty o = (comprehension_ty)_o;
3126         PyObject *result = NULL, *value = NULL;
3127         if (!o) {
3128                 Py_INCREF(Py_None);
3129                 return Py_None;
3130         }
3131
3132         result = PyType_GenericNew(comprehension_type, NULL, NULL);
3133         if (!result) return NULL;
3134         value = ast2obj_expr(o->target);
3135         if (!value) goto failed;
3136         if (PyObject_SetAttrString(result, "target", value) == -1)
3137                 goto failed;
3138         Py_DECREF(value);
3139         value = ast2obj_expr(o->iter);
3140         if (!value) goto failed;
3141         if (PyObject_SetAttrString(result, "iter", value) == -1)
3142                 goto failed;
3143         Py_DECREF(value);
3144         value = ast2obj_list(o->ifs, ast2obj_expr);
3145         if (!value) goto failed;
3146         if (PyObject_SetAttrString(result, "ifs", value) == -1)
3147                 goto failed;
3148         Py_DECREF(value);
3149         return result;
3150 failed:
3151         Py_XDECREF(value);
3152         Py_XDECREF(result);
3153         return NULL;
3154 }
3155
3156 PyObject*
3157 ast2obj_excepthandler(void* _o)
3158 {
3159         excepthandler_ty o = (excepthandler_ty)_o;
3160         PyObject *result = NULL, *value = NULL;
3161         if (!o) {
3162                 Py_INCREF(Py_None);
3163                 return Py_None;
3164         }
3165
3166         switch (o->kind) {
3167         case ExceptHandler_kind:
3168                 result = PyType_GenericNew(ExceptHandler_type, NULL, NULL);
3169                 if (!result) goto failed;
3170                 value = ast2obj_expr(o->v.ExceptHandler.type);
3171                 if (!value) goto failed;
3172                 if (PyObject_SetAttrString(result, "type", value) == -1)
3173                         goto failed;
3174                 Py_DECREF(value);
3175                 value = ast2obj_expr(o->v.ExceptHandler.name);
3176                 if (!value) goto failed;
3177                 if (PyObject_SetAttrString(result, "name", value) == -1)
3178                         goto failed;
3179                 Py_DECREF(value);
3180                 value = ast2obj_list(o->v.ExceptHandler.body, ast2obj_stmt);
3181                 if (!value) goto failed;
3182                 if (PyObject_SetAttrString(result, "body", value) == -1)
3183                         goto failed;
3184                 Py_DECREF(value);
3185                 break;
3186         }
3187         value = ast2obj_int(o->lineno);
3188         if (!value) goto failed;
3189         if (PyObject_SetAttrString(result, "lineno", value) < 0)
3190                 goto failed;
3191         Py_DECREF(value);
3192         value = ast2obj_int(o->col_offset);
3193         if (!value) goto failed;
3194         if (PyObject_SetAttrString(result, "col_offset", value) < 0)
3195                 goto failed;
3196         Py_DECREF(value);
3197         return result;
3198 failed:
3199         Py_XDECREF(value);
3200         Py_XDECREF(result);
3201         return NULL;
3202 }
3203
3204 PyObject*
3205 ast2obj_arguments(void* _o)
3206 {
3207         arguments_ty o = (arguments_ty)_o;
3208         PyObject *result = NULL, *value = NULL;
3209         if (!o) {
3210                 Py_INCREF(Py_None);
3211                 return Py_None;
3212         }
3213
3214         result = PyType_GenericNew(arguments_type, NULL, NULL);
3215         if (!result) return NULL;
3216         value = ast2obj_list(o->args, ast2obj_expr);
3217         if (!value) goto failed;
3218         if (PyObject_SetAttrString(result, "args", value) == -1)
3219                 goto failed;
3220         Py_DECREF(value);
3221         value = ast2obj_identifier(o->vararg);
3222         if (!value) goto failed;
3223         if (PyObject_SetAttrString(result, "vararg", value) == -1)
3224                 goto failed;
3225         Py_DECREF(value);
3226         value = ast2obj_identifier(o->kwarg);
3227         if (!value) goto failed;
3228         if (PyObject_SetAttrString(result, "kwarg", value) == -1)
3229                 goto failed;
3230         Py_DECREF(value);
3231         value = ast2obj_list(o->defaults, ast2obj_expr);
3232         if (!value) goto failed;
3233         if (PyObject_SetAttrString(result, "defaults", value) == -1)
3234                 goto failed;
3235         Py_DECREF(value);
3236         return result;
3237 failed:
3238         Py_XDECREF(value);
3239         Py_XDECREF(result);
3240         return NULL;
3241 }
3242
3243 PyObject*
3244 ast2obj_keyword(void* _o)
3245 {
3246         keyword_ty o = (keyword_ty)_o;
3247         PyObject *result = NULL, *value = NULL;
3248         if (!o) {
3249                 Py_INCREF(Py_None);
3250                 return Py_None;
3251         }
3252
3253         result = PyType_GenericNew(keyword_type, NULL, NULL);
3254         if (!result) return NULL;
3255         value = ast2obj_identifier(o->arg);
3256         if (!value) goto failed;
3257         if (PyObject_SetAttrString(result, "arg", value) == -1)
3258                 goto failed;
3259         Py_DECREF(value);
3260         value = ast2obj_expr(o->value);
3261         if (!value) goto failed;
3262         if (PyObject_SetAttrString(result, "value", value) == -1)
3263                 goto failed;
3264         Py_DECREF(value);
3265         return result;
3266 failed:
3267         Py_XDECREF(value);
3268         Py_XDECREF(result);
3269         return NULL;
3270 }
3271
3272 PyObject*
3273 ast2obj_alias(void* _o)
3274 {
3275         alias_ty o = (alias_ty)_o;
3276         PyObject *result = NULL, *value = NULL;
3277         if (!o) {
3278                 Py_INCREF(Py_None);
3279                 return Py_None;
3280         }
3281
3282         result = PyType_GenericNew(alias_type, NULL, NULL);
3283         if (!result) return NULL;
3284         value = ast2obj_identifier(o->name);
3285         if (!value) goto failed;
3286         if (PyObject_SetAttrString(result, "name", value) == -1)
3287                 goto failed;
3288         Py_DECREF(value);
3289         value = ast2obj_identifier(o->asname);
3290         if (!value) goto failed;
3291         if (PyObject_SetAttrString(result, "asname", value) == -1)
3292                 goto failed;
3293         Py_DECREF(value);
3294         return result;
3295 failed:
3296         Py_XDECREF(value);
3297         Py_XDECREF(result);
3298         return NULL;
3299 }
3300
3301
3302 int
3303 obj2ast_mod(PyObject* obj, mod_ty* out, PyArena* arena)
3304 {
3305         PyObject* tmp = NULL;
3306         int isinstance;
3307
3308
3309         if (obj == Py_None) {
3310                 *out = NULL;
3311                 return 0;
3312         }
3313         isinstance = PyObject_IsInstance(obj, (PyObject*)Module_type);
3314         if (isinstance == -1) {
3315                 return 1;
3316         }
3317         if (isinstance) {
3318                 asdl_seq* body;
3319
3320                 if (PyObject_HasAttrString(obj, "body")) {
3321                         int res;
3322                         Py_ssize_t len;
3323                         Py_ssize_t i;
3324                         tmp = PyObject_GetAttrString(obj, "body");
3325                         if (tmp == NULL) goto failed;
3326                         if (!PyList_Check(tmp)) {
3327                                 PyErr_Format(PyExc_TypeError, "Module field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name);
3328                                 goto failed;
3329                         }
3330                         len = PyList_GET_SIZE(tmp);
3331                         body = asdl_seq_new(len, arena);
3332                         if (body == NULL) goto failed;
3333                         for (i = 0; i < len; i++) {
3334                                 stmt_ty value;
3335                                 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
3336                                 if (res != 0) goto failed;
3337                                 asdl_seq_SET(body, i, value);
3338                         }
3339                         Py_XDECREF(tmp);
3340                         tmp = NULL;
3341                 } else {
3342                         PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Module");
3343                         return 1;
3344                 }
3345                 *out = Module(body, arena);
3346                 if (*out == NULL) goto failed;
3347                 return 0;
3348         }
3349         isinstance = PyObject_IsInstance(obj, (PyObject*)Interactive_type);
3350         if (isinstance == -1) {
3351                 return 1;
3352         }
3353         if (isinstance) {
3354                 asdl_seq* body;
3355
3356                 if (PyObject_HasAttrString(obj, "body")) {
3357                         int res;
3358                         Py_ssize_t len;
3359                         Py_ssize_t i;
3360                         tmp = PyObject_GetAttrString(obj, "body");
3361                         if (tmp == NULL) goto failed;
3362                         if (!PyList_Check(tmp)) {
3363                                 PyErr_Format(PyExc_TypeError, "Interactive field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name);
3364                                 goto failed;
3365                         }
3366                         len = PyList_GET_SIZE(tmp);
3367                         body = asdl_seq_new(len, arena);
3368                         if (body == NULL) goto failed;
3369                         for (i = 0; i < len; i++) {
3370                                 stmt_ty value;
3371                                 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
3372                                 if (res != 0) goto failed;
3373                                 asdl_seq_SET(body, i, value);
3374                         }
3375                         Py_XDECREF(tmp);
3376                         tmp = NULL;
3377                 } else {
3378                         PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Interactive");
3379                         return 1;
3380                 }
3381                 *out = Interactive(body, arena);
3382                 if (*out == NULL) goto failed;
3383                 return 0;
3384         }
3385         isinstance = PyObject_IsInstance(obj, (PyObject*)Expression_type);
3386         if (isinstance == -1) {
3387                 return 1;
3388         }
3389         if (isinstance) {
3390                 expr_ty body;
3391
3392                 if (PyObject_HasAttrString(obj, "body")) {
3393                         int res;
3394                         tmp = PyObject_GetAttrString(obj, "body");
3395                         if (tmp == NULL) goto failed;
3396                         res = obj2ast_expr(tmp, &body, arena);
3397                         if (res != 0) goto failed;
3398                         Py_XDECREF(tmp);
3399                         tmp = NULL;
3400                 } else {
3401                         PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Expression");
3402                         return 1;
3403                 }
3404                 *out = Expression(body, arena);
3405                 if (*out == NULL) goto failed;
3406                 return 0;
3407         }
3408         isinstance = PyObject_IsInstance(obj, (PyObject*)Suite_type);
3409         if (isinstance == -1) {
3410                 return 1;
3411         }
3412         if (isinstance) {
3413                 asdl_seq* body;
3414
3415                 if (PyObject_HasAttrString(obj, "body")) {
3416                         int res;
3417                         Py_ssize_t len;
3418                         Py_ssize_t i;
3419                         tmp = PyObject_GetAttrString(obj, "body");
3420                         if (tmp == NULL) goto failed;
3421                         if (!PyList_Check(tmp)) {
3422                                 PyErr_Format(PyExc_TypeError, "Suite field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name);
3423                                 goto failed;
3424                         }
3425                         len = PyList_GET_SIZE(tmp);
3426                         body = asdl_seq_new(len, arena);
3427                         if (body == NULL) goto failed;
3428                         for (i = 0; i < len; i++) {
3429                                 stmt_ty value;
3430                                 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
3431                                 if (res != 0) goto failed;
3432                                 asdl_seq_SET(body, i, value);
3433                         }
3434                         Py_XDECREF(tmp);
3435                         tmp = NULL;
3436                 } else {
3437                         PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Suite");
3438                         return 1;
3439                 }
3440                 *out = Suite(body, arena);
3441                 if (*out == NULL) goto failed;
3442                 return 0;
3443         }
3444
3445         tmp = PyObject_Repr(obj);
3446         if (tmp == NULL) goto failed;
3447         PyErr_Format(PyExc_TypeError, "expected some sort of mod, but got %.400s", PyString_AS_STRING(tmp));
3448 failed:
3449         Py_XDECREF(tmp);
3450         return 1;
3451 }
3452
3453 int
3454 obj2ast_stmt(PyObject* obj, stmt_ty* out, PyArena* arena)
3455 {
3456         PyObject* tmp = NULL;
3457         int isinstance;
3458
3459         int lineno;
3460         int col_offset;
3461
3462         if (obj == Py_None) {
3463                 *out = NULL;
3464                 return 0;
3465         }
3466         if (PyObject_HasAttrString(obj, "lineno")) {
3467                 int res;
3468                 tmp = PyObject_GetAttrString(obj, "lineno");
3469                 if (tmp == NULL) goto failed;
3470                 res = obj2ast_int(tmp, &lineno, arena);
3471                 if (res != 0) goto failed;
3472                 Py_XDECREF(tmp);
3473                 tmp = NULL;
3474         } else {
3475                 PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from stmt");
3476                 return 1;
3477         }
3478         if (PyObject_HasAttrString(obj, "col_offset")) {
3479                 int res;
3480                 tmp = PyObject_GetAttrString(obj, "col_offset");
3481                 if (tmp == NULL) goto failed;
3482                 res = obj2ast_int(tmp, &col_offset, arena);
3483                 if (res != 0) goto failed;
3484                 Py_XDECREF(tmp);
3485                 tmp = NULL;
3486         } else {
3487                 PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from stmt");
3488                 return 1;
3489         }
3490         isinstance = PyObject_IsInstance(obj, (PyObject*)FunctionDef_type);
3491         if (isinstance == -1) {
3492                 return 1;
3493         }
3494         if (isinstance) {
3495                 identifier name;
3496                 arguments_ty args;
3497                 asdl_seq* body;
3498                 asdl_seq* decorator_list;
3499
3500                 if (PyObject_HasAttrString(obj, "name")) {
3501                         int res;
3502                         tmp = PyObject_GetAttrString(obj, "name");
3503                         if (tmp == NULL) goto failed;
3504                         res = obj2ast_identifier(tmp, &name, arena);
3505                         if (res != 0) goto failed;
3506                         Py_XDECREF(tmp);
3507                         tmp = NULL;
3508                 } else {
3509                         PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from FunctionDef");
3510                         return 1;
3511                 }
3512                 if (PyObject_HasAttrString(obj, "args")) {
3513                         int res;
3514                         tmp = PyObject_GetAttrString(obj, "args");
3515                         if (tmp == NULL) goto failed;
3516                         res = obj2ast_arguments(tmp, &args, arena);
3517                         if (res != 0) goto failed;
3518                         Py_XDECREF(tmp);
3519                         tmp = NULL;
3520                 } else {
3521                         PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from FunctionDef");
3522                         return 1;
3523                 }
3524                 if (PyObject_HasAttrString(obj, "body")) {
3525                         int res;
3526                         Py_ssize_t len;
3527                         Py_ssize_t i;
3528                         tmp = PyObject_GetAttrString(obj, "body");
3529                         if (tmp == NULL) goto failed;
3530                         if (!PyList_Check(tmp)) {
3531                                 PyErr_Format(PyExc_TypeError, "FunctionDef field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name);
3532                                 goto failed;
3533                         }
3534                         len = PyList_GET_SIZE(tmp);
3535                         body = asdl_seq_new(len, arena);
3536                         if (body == NULL) goto failed;
3537                         for (i = 0; i < len; i++) {
3538                                 stmt_ty value;
3539                                 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
3540                                 if (res != 0) goto failed;
3541                                 asdl_seq_SET(body, i, value);
3542                         }
3543                         Py_XDECREF(tmp);
3544                         tmp = NULL;
3545                 } else {
3546                         PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from FunctionDef");
3547                         return 1;
3548                 }
3549                 if (PyObject_HasAttrString(obj, "decorator_list")) {
3550                         int res;
3551                         Py_ssize_t len;
3552                         Py_ssize_t i;
3553                         tmp = PyObject_GetAttrString(obj, "decorator_list");
3554                         if (tmp == NULL) goto failed;
3555                         if (!PyList_Check(tmp)) {
3556                                 PyErr_Format(PyExc_TypeError, "FunctionDef field \"decorator_list\" must be a list, not a %.200s", tmp->ob_type->tp_name);
3557                                 goto failed;
3558                         }
3559                         len = PyList_GET_SIZE(tmp);
3560                         decorator_list = asdl_seq_new(len, arena);
3561                         if (decorator_list == NULL) goto failed;
3562                         for (i = 0; i < len; i++) {
3563                                 expr_ty value;
3564                                 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
3565                                 if (res != 0) goto failed;
3566                                 asdl_seq_SET(decorator_list, i, value);
3567                         }
3568                         Py_XDECREF(tmp);
3569                         tmp = NULL;
3570                 } else {
3571                         PyErr_SetString(PyExc_TypeError, "required field \"decorator_list\" missing from FunctionDef");
3572                         return 1;
3573                 }
3574                 *out = FunctionDef(name, args, body, decorator_list, lineno,
3575                                    col_offset, arena);
3576                 if (*out == NULL) goto failed;
3577                 return 0;
3578         }
3579         isinstance = PyObject_IsInstance(obj, (PyObject*)ClassDef_type);
3580         if (isinstance == -1) {
3581                 return 1;
3582         }
3583         if (isinstance) {
3584                 identifier name;
3585                 asdl_seq* bases;
3586                 asdl_seq* body;
3587                 asdl_seq* decorator_list;
3588
3589                 if (PyObject_HasAttrString(obj, "name")) {
3590                         int res;
3591                         tmp = PyObject_GetAttrString(obj, "name");
3592                         if (tmp == NULL) goto failed;
3593                         res = obj2ast_identifier(tmp, &name, arena);
3594                         if (res != 0) goto failed;
3595                         Py_XDECREF(tmp);
3596                         tmp = NULL;
3597                 } else {
3598                         PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from ClassDef");
3599                         return 1;
3600                 }
3601                 if (PyObject_HasAttrString(obj, "bases")) {
3602                         int res;
3603                         Py_ssize_t len;
3604                         Py_ssize_t i;
3605                         tmp = PyObject_GetAttrString(obj, "bases");
3606                         if (tmp == NULL) goto failed;
3607                         if (!PyList_Check(tmp)) {
3608                                 PyErr_Format(PyExc_TypeError, "ClassDef field \"bases\" must be a list, not a %.200s", tmp->ob_type->tp_name);
3609                                 goto failed;
3610                         }
3611                         len = PyList_GET_SIZE(tmp);
3612                         bases = asdl_seq_new(len, arena);
3613                         if (bases == NULL) goto failed;
3614                         for (i = 0; i < len; i++) {
3615                                 expr_ty value;
3616                                 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
3617                                 if (res != 0) goto failed;
3618                                 asdl_seq_SET(bases, i, value);
3619                         }
3620                         Py_XDECREF(tmp);
3621                         tmp = NULL;
3622                 } else {
3623                         PyErr_SetString(PyExc_TypeError, "required field \"bases\" missing from ClassDef");
3624                         return 1;
3625                 }
3626                 if (PyObject_HasAttrString(obj, "body")) {
3627                         int res;
3628                         Py_ssize_t len;
3629                         Py_ssize_t i;
3630                         tmp = PyObject_GetAttrString(obj, "body");
3631                         if (tmp == NULL) goto failed;
3632                         if (!PyList_Check(tmp)) {
3633                                 PyErr_Format(PyExc_TypeError, "ClassDef field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name);
3634                                 goto failed;
3635                         }
3636                         len = PyList_GET_SIZE(tmp);
3637                         body = asdl_seq_new(len, arena);
3638                         if (body == NULL) goto failed;
3639                         for (i = 0; i < len; i++) {
3640                                 stmt_ty value;
3641                                 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
3642                                 if (res != 0) goto failed;
3643                                 asdl_seq_SET(body, i, value);
3644                         }
3645                         Py_XDECREF(tmp);
3646                         tmp = NULL;
3647                 } else {
3648                         PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from ClassDef");
3649                         return 1;
3650                 }
3651                 if (PyObject_HasAttrString(obj, "decorator_list")) {
3652                         int res;
3653                         Py_ssize_t len;
3654                         Py_ssize_t i;
3655                         tmp = PyObject_GetAttrString(obj, "decorator_list");
3656                         if (tmp == NULL) goto failed;
3657                         if (!PyList_Check(tmp)) {
3658                                 PyErr_Format(PyExc_TypeError, "ClassDef field \"decorator_list\" must be a list, not a %.200s", tmp->ob_type->tp_name);
3659                                 goto failed;
3660                         }
3661                         len = PyList_GET_SIZE(tmp);
3662                         decorator_list = asdl_seq_new(len, arena);
3663                         if (decorator_list == NULL) goto failed;
3664                         for (i = 0; i < len; i++) {
3665                                 expr_ty value;
3666                                 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
3667                                 if (res != 0) goto failed;
3668                                 asdl_seq_SET(decorator_list, i, value);
3669                         }
3670                         Py_XDECREF(tmp);
3671                         tmp = NULL;
3672                 } else {
3673                         PyErr_SetString(PyExc_TypeError, "required field \"decorator_list\" missing from ClassDef");
3674                         return 1;
3675                 }
3676                 *out = ClassDef(name, bases, body, decorator_list, lineno,
3677                                 col_offset, arena);
3678                 if (*out == NULL) goto failed;
3679                 return 0;
3680         }
3681         isinstance = PyObject_IsInstance(obj, (PyObject*)Return_type);
3682         if (isinstance == -1) {
3683                 return 1;
3684         }
3685         if (isinstance) {
3686                 expr_ty value;
3687
3688                 if (PyObject_HasAttrString(obj, "value")) {
3689                         int res;
3690                         tmp = PyObject_GetAttrString(obj, "value");
3691                         if (tmp == NULL) goto failed;
3692                         res = obj2ast_expr(tmp, &value, arena);
3693                         if (res != 0) goto failed;
3694                         Py_XDECREF(tmp);
3695                         tmp = NULL;
3696                 } else {
3697                         value = NULL;
3698                 }
3699                 *out = Return(value, lineno, col_offset, arena);
3700                 if (*out == NULL) goto failed;
3701                 return 0;
3702         }
3703         isinstance = PyObject_IsInstance(obj, (PyObject*)Delete_type);
3704         if (isinstance == -1) {
3705                 return 1;
3706         }
3707         if (isinstance) {
3708                 asdl_seq* targets;
3709
3710                 if (PyObject_HasAttrString(obj, "targets")) {
3711                         int res;
3712                         Py_ssize_t len;
3713                         Py_ssize_t i;
3714                         tmp = PyObject_GetAttrString(obj, "targets");
3715                         if (tmp == NULL) goto failed;
3716                         if (!PyList_Check(tmp)) {
3717                                 PyErr_Format(PyExc_TypeError, "Delete field \"targets\" must be a list, not a %.200s", tmp->ob_type->tp_name);
3718                                 goto failed;
3719                         }
3720                         len = PyList_GET_SIZE(tmp);
3721                         targets = asdl_seq_new(len, arena);
3722                         if (targets == NULL) goto failed;
3723                         for (i = 0; i < len; i++) {
3724                                 expr_ty value;
3725                                 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
3726                                 if (res != 0) goto failed;
3727                                 asdl_seq_SET(targets, i, value);
3728                         }
3729                         Py_XDECREF(tmp);
3730                         tmp = NULL;
3731                 } else {
3732                         PyErr_SetString(PyExc_TypeError, "required field \"targets\" missing from Delete");
3733                         return 1;
3734                 }
3735                 *out = Delete(targets, lineno, col_offset, arena);
3736                 if (*out == NULL) goto failed;
3737                 return 0;
3738         }
3739         isinstance = PyObject_IsInstance(obj, (PyObject*)Assign_type);
3740         if (isinstance == -1) {
3741                 return 1;
3742         }
3743         if (isinstance) {
3744                 asdl_seq* targets;
3745                 expr_ty value;
3746
3747                 if (PyObject_HasAttrString(obj, "targets")) {
3748                         int res;
3749                         Py_ssize_t len;
3750                         Py_ssize_t i;
3751                         tmp = PyObject_GetAttrString(obj, "targets");
3752                         if (tmp == NULL) goto failed;
3753                         if (!PyList_Check(tmp)) {
3754                                 PyErr_Format(PyExc_TypeError, "Assign field \"targets\" must be a list, not a %.200s", tmp->ob_type->tp_name);
3755                                 goto failed;
3756                         }
3757                         len = PyList_GET_SIZE(tmp);
3758                         targets = asdl_seq_new(len, arena);
3759                         if (targets == NULL) goto failed;
3760                         for (i = 0; i < len; i++) {
3761                                 expr_ty value;
3762                                 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
3763                                 if (res != 0) goto failed;
3764                                 asdl_seq_SET(targets, i, value);
3765                         }
3766                         Py_XDECREF(tmp);
3767                         tmp = NULL;
3768                 } else {
3769                         PyErr_SetString(PyExc_TypeError, "required field \"targets\" missing from Assign");
3770                         return 1;
3771                 }
3772                 if (PyObject_HasAttrString(obj, "value")) {
3773                         int res;
3774                         tmp = PyObject_GetAttrString(obj, "value");
3775                         if (tmp == NULL) goto failed;
3776                         res = obj2ast_expr(tmp, &value, arena);
3777                         if (res != 0) goto failed;
3778                         Py_XDECREF(tmp);
3779                         tmp = NULL;
3780                 } else {
3781                         PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Assign");
3782                         return 1;
3783                 }
3784                 *out = Assign(targets, value, lineno, col_offset, arena);
3785                 if (*out == NULL) goto failed;
3786                 return 0;
3787         }
3788         isinstance = PyObject_IsInstance(obj, (PyObject*)AugAssign_type);
3789         if (isinstance == -1) {
3790                 return 1;
3791         }
3792         if (isinstance) {
3793                 expr_ty target;
3794                 operator_ty op;
3795                 expr_ty value;
3796
3797                 if (PyObject_HasAttrString(obj, "target")) {
3798                         int res;
3799                         tmp = PyObject_GetAttrString(obj, "target");
3800                         if (tmp == NULL) goto failed;
3801                         res = obj2ast_expr(tmp, &target, arena);
3802                         if (res != 0) goto failed;
3803                         Py_XDECREF(tmp);
3804                         tmp = NULL;
3805                 } else {
3806                         PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from AugAssign");
3807                         return 1;
3808                 }
3809                 if (PyObject_HasAttrString(obj, "op")) {
3810                         int res;
3811                         tmp = PyObject_GetAttrString(obj, "op");
3812                         if (tmp == NULL) goto failed;
3813                         res = obj2ast_operator(tmp, &op, arena);
3814                         if (res != 0) goto failed;
3815                         Py_XDECREF(tmp);
3816                         tmp = NULL;
3817                 } else {
3818                         PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from AugAssign");
3819                         return 1;
3820                 }
3821                 if (PyObject_HasAttrString(obj, "value")) {
3822                         int res;
3823                         tmp = PyObject_GetAttrString(obj, "value");
3824                         if (tmp == NULL) goto failed;
3825                         res = obj2ast_expr(tmp, &value, arena);
3826                         if (res != 0) goto failed;
3827                         Py_XDECREF(tmp);
3828                         tmp = NULL;
3829                 } else {
3830                         PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from AugAssign");
3831                         return 1;
3832                 }
3833                 *out = AugAssign(target, op, value, lineno, col_offset, arena);
3834                 if (*out == NULL) goto failed;
3835                 return 0;
3836         }
3837         isinstance = PyObject_IsInstance(obj, (PyObject*)Print_type);
3838         if (isinstance == -1) {
3839                 return 1;
3840         }
3841         if (isinstance) {
3842                 expr_ty dest;
3843                 asdl_seq* values;
3844                 bool nl;
3845
3846                 if (PyObject_HasAttrString(obj, "dest")) {
3847                         int res;
3848                         tmp = PyObject_GetAttrString(obj, "dest");
3849                         if (tmp == NULL) goto failed;
3850                         res = obj2ast_expr(tmp, &dest, arena);
3851                         if (res != 0) goto failed;
3852                         Py_XDECREF(tmp);
3853                         tmp = NULL;
3854                 } else {
3855                         dest = NULL;
3856                 }
3857                 if (PyObject_HasAttrString(obj, "values")) {
3858                         int res;
3859                         Py_ssize_t len;
3860                         Py_ssize_t i;
3861                         tmp = PyObject_GetAttrString(obj, "values");
3862                         if (tmp == NULL) goto failed;
3863                         if (!PyList_Check(tmp)) {
3864                                 PyErr_Format(PyExc_TypeError, "Print field \"values\" must be a list, not a %.200s", tmp->ob_type->tp_name);
3865                                 goto failed;
3866                         }
3867                         len = PyList_GET_SIZE(tmp);
3868                         values = asdl_seq_new(len, arena);
3869                         if (values == NULL) goto failed;
3870                         for (i = 0; i < len; i++) {
3871                                 expr_ty value;
3872                                 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
3873                                 if (res != 0) goto failed;
3874                                 asdl_seq_SET(values, i, value);
3875                         }
3876                         Py_XDECREF(tmp);
3877                         tmp = NULL;
3878                 } else {
3879                         PyErr_SetString(PyExc_TypeError, "required field \"values\" missing from Print");
3880                         return 1;
3881                 }
3882                 if (PyObject_HasAttrString(obj, "nl")) {
3883                         int res;
3884                         tmp = PyObject_GetAttrString(obj, "nl");
3885                         if (tmp == NULL) goto failed;
3886                         res = obj2ast_bool(tmp, &nl, arena);
3887                         if (res != 0) goto failed;
3888                         Py_XDECREF(tmp);
3889                         tmp = NULL;
3890                 } else {
3891                         PyErr_SetString(PyExc_TypeError, "required field \"nl\" missing from Print");
3892                         return 1;
3893                 }
3894                 *out = Print(dest, values, nl, lineno, col_offset, arena);
3895                 if (*out == NULL) goto failed;
3896                 return 0;
3897         }
3898         isinstance = PyObject_IsInstance(obj, (PyObject*)For_type);
3899         if (isinstance == -1) {
3900                 return 1;
3901         }
3902         if (isinstance) {
3903                 expr_ty target;
3904                 expr_ty iter;
3905                 asdl_seq* body;
3906                 asdl_seq* orelse;
3907
3908                 if (PyObject_HasAttrString(obj, "target")) {
3909                         int res;
3910                         tmp = PyObject_GetAttrString(obj, "target");
3911                         if (tmp == NULL) goto failed;
3912                         res = obj2ast_expr(tmp, &target, arena);
3913                         if (res != 0) goto failed;
3914                         Py_XDECREF(tmp);
3915                         tmp = NULL;
3916                 } else {
3917                         PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from For");
3918                         return 1;
3919                 }
3920                 if (PyObject_HasAttrString(obj, "iter")) {
3921                         int res;
3922                         tmp = PyObject_GetAttrString(obj, "iter");
3923                         if (tmp == NULL) goto failed;
3924                         res = obj2ast_expr(tmp, &iter, arena);
3925                         if (res != 0) goto failed;
3926                         Py_XDECREF(tmp);
3927                         tmp = NULL;
3928                 } else {
3929                         PyErr_SetString(PyExc_TypeError, "required field \"iter\" missing from For");
3930                         return 1;
3931                 }
3932                 if (PyObject_HasAttrString(obj, "body")) {
3933                         int res;
3934                         Py_ssize_t len;
3935                         Py_ssize_t i;
3936                         tmp = PyObject_GetAttrString(obj, "body");
3937                         if (tmp == NULL) goto failed;
3938                         if (!PyList_Check(tmp)) {
3939                                 PyErr_Format(PyExc_TypeError, "For field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name);
3940                                 goto failed;
3941                         }
3942                         len = PyList_GET_SIZE(tmp);
3943                         body = asdl_seq_new(len, arena);
3944                         if (body == NULL) goto failed;
3945                         for (i = 0; i < len; i++) {
3946                                 stmt_ty value;
3947                                 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
3948                                 if (res != 0) goto failed;
3949                                 asdl_seq_SET(body, i, value);
3950                         }
3951                         Py_XDECREF(tmp);
3952                         tmp = NULL;
3953                 } else {
3954                         PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from For");
3955                         return 1;
3956                 }
3957                 if (PyObject_HasAttrString(obj, "orelse")) {
3958                         int res;
3959                         Py_ssize_t len;
3960                         Py_ssize_t i;
3961                         tmp = PyObject_GetAttrString(obj, "orelse");
3962                         if (tmp == NULL) goto failed;
3963                         if (!PyList_Check(tmp)) {
3964                                 PyErr_Format(PyExc_TypeError, "For field \"orelse\" must be a list, not a %.200s", tmp->ob_type->tp_name);
3965                                 goto failed;
3966                         }
3967                         len = PyList_GET_SIZE(tmp);
3968                         orelse = asdl_seq_new(len, arena);
3969                         if (orelse == NULL) goto failed;
3970                         for (i = 0; i < len; i++) {
3971                                 stmt_ty value;
3972                                 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
3973                                 if (res != 0) goto failed;
3974                                 asdl_seq_SET(orelse, i, value);
3975                         }
3976                         Py_XDECREF(tmp);
3977                         tmp = NULL;
3978                 } else {
3979                         PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from For");
3980                         return 1;
3981                 }
3982                 *out = For(target, iter, body, orelse, lineno, col_offset,
3983                            arena);
3984                 if (*out == NULL) goto failed;
3985                 return 0;
3986         }
3987         isinstance = PyObject_IsInstance(obj, (PyObject*)While_type);
3988         if (isinstance == -1) {
3989                 return 1;
3990         }
3991         if (isinstance) {
3992                 expr_ty test;
3993                 asdl_seq* body;
3994                 asdl_seq* orelse;
3995
3996                 if (PyObject_HasAttrString(obj, "test")) {
3997                         int res;
3998                         tmp = PyObject_GetAttrString(obj, "test");
3999                         if (tmp == NULL) goto failed;
4000                         res = obj2ast_expr(tmp, &test, arena);
4001                         if (res != 0) goto failed;
4002                         Py_XDECREF(tmp);
4003                         tmp = NULL;
4004                 } else {
4005                         PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from While");
4006                         return 1;
4007                 }
4008                 if (PyObject_HasAttrString(obj, "body")) {
4009                         int res;
4010                         Py_ssize_t len;
4011                         Py_ssize_t i;
4012                         tmp = PyObject_GetAttrString(obj, "body");
4013                         if (tmp == NULL) goto failed;
4014                         if (!PyList_Check(tmp)) {
4015                                 PyErr_Format(PyExc_TypeError, "While field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4016                                 goto failed;
4017                         }
4018                         len = PyList_GET_SIZE(tmp);
4019                         body = asdl_seq_new(len, arena);
4020                         if (body == NULL) goto failed;
4021                         for (i = 0; i < len; i++) {
4022                                 stmt_ty value;
4023                                 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
4024                                 if (res != 0) goto failed;
4025                                 asdl_seq_SET(body, i, value);
4026                         }
4027                         Py_XDECREF(tmp);
4028                         tmp = NULL;
4029                 } else {
4030                         PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from While");
4031                         return 1;
4032                 }
4033                 if (PyObject_HasAttrString(obj, "orelse")) {
4034                         int res;
4035                         Py_ssize_t len;
4036                         Py_ssize_t i;
4037                         tmp = PyObject_GetAttrString(obj, "orelse");
4038                         if (tmp == NULL) goto failed;
4039                         if (!PyList_Check(tmp)) {
4040                                 PyErr_Format(PyExc_TypeError, "While field \"orelse\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4041                                 goto failed;
4042                         }
4043                         len = PyList_GET_SIZE(tmp);
4044                         orelse = asdl_seq_new(len, arena);
4045                         if (orelse == NULL) goto failed;
4046                         for (i = 0; i < len; i++) {
4047                                 stmt_ty value;
4048                                 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
4049                                 if (res != 0) goto failed;
4050                                 asdl_seq_SET(orelse, i, value);
4051                         }
4052                         Py_XDECREF(tmp);
4053                         tmp = NULL;
4054                 } else {
4055                         PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from While");
4056                         return 1;
4057                 }
4058                 *out = While(test, body, orelse, lineno, col_offset, arena);
4059                 if (*out == NULL) goto failed;
4060                 return 0;
4061         }
4062         isinstance = PyObject_IsInstance(obj, (PyObject*)If_type);
4063         if (isinstance == -1) {
4064                 return 1;
4065         }
4066         if (isinstance) {
4067                 expr_ty test;
4068                 asdl_seq* body;
4069                 asdl_seq* orelse;
4070
4071                 if (PyObject_HasAttrString(obj, "test")) {
4072                         int res;
4073                         tmp = PyObject_GetAttrString(obj, "test");
4074                         if (tmp == NULL) goto failed;
4075                         res = obj2ast_expr(tmp, &test, arena);
4076                         if (res != 0) goto failed;
4077                         Py_XDECREF(tmp);
4078                         tmp = NULL;
4079                 } else {
4080                         PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from If");
4081                         return 1;
4082                 }
4083                 if (PyObject_HasAttrString(obj, "body")) {
4084                         int res;
4085                         Py_ssize_t len;
4086                         Py_ssize_t i;
4087                         tmp = PyObject_GetAttrString(obj, "body");
4088                         if (tmp == NULL) goto failed;
4089                         if (!PyList_Check(tmp)) {
4090                                 PyErr_Format(PyExc_TypeError, "If field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4091                                 goto failed;
4092                         }
4093                         len = PyList_GET_SIZE(tmp);
4094                         body = asdl_seq_new(len, arena);
4095                         if (body == NULL) goto failed;
4096                         for (i = 0; i < len; i++) {
4097                                 stmt_ty value;
4098                                 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
4099                                 if (res != 0) goto failed;
4100                                 asdl_seq_SET(body, i, value);
4101                         }
4102                         Py_XDECREF(tmp);
4103                         tmp = NULL;
4104                 } else {
4105                         PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from If");
4106                         return 1;
4107                 }
4108                 if (PyObject_HasAttrString(obj, "orelse")) {
4109                         int res;
4110                         Py_ssize_t len;
4111                         Py_ssize_t i;
4112                         tmp = PyObject_GetAttrString(obj, "orelse");
4113                         if (tmp == NULL) goto failed;
4114                         if (!PyList_Check(tmp)) {
4115                                 PyErr_Format(PyExc_TypeError, "If field \"orelse\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4116                                 goto failed;
4117                         }
4118                         len = PyList_GET_SIZE(tmp);
4119                         orelse = asdl_seq_new(len, arena);
4120                         if (orelse == NULL) goto failed;
4121                         for (i = 0; i < len; i++) {
4122                                 stmt_ty value;
4123                                 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
4124                                 if (res != 0) goto failed;
4125                                 asdl_seq_SET(orelse, i, value);
4126                         }
4127                         Py_XDECREF(tmp);
4128                         tmp = NULL;
4129                 } else {
4130                         PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from If");
4131                         return 1;
4132                 }
4133                 *out = If(test, body, orelse, lineno, col_offset, arena);
4134                 if (*out == NULL) goto failed;
4135                 return 0;
4136         }
4137         isinstance = PyObject_IsInstance(obj, (PyObject*)With_type);
4138         if (isinstance == -1) {
4139                 return 1;
4140         }
4141         if (isinstance) {
4142                 expr_ty context_expr;
4143                 expr_ty optional_vars;
4144                 asdl_seq* body;
4145
4146                 if (PyObject_HasAttrString(obj, "context_expr")) {
4147                         int res;
4148                         tmp = PyObject_GetAttrString(obj, "context_expr");
4149                         if (tmp == NULL) goto failed;
4150                         res = obj2ast_expr(tmp, &context_expr, arena);
4151                         if (res != 0) goto failed;
4152                         Py_XDECREF(tmp);
4153                         tmp = NULL;
4154                 } else {
4155                         PyErr_SetString(PyExc_TypeError, "required field \"context_expr\" missing from With");
4156                         return 1;
4157                 }
4158                 if (PyObject_HasAttrString(obj, "optional_vars")) {
4159                         int res;
4160                         tmp = PyObject_GetAttrString(obj, "optional_vars");
4161                         if (tmp == NULL) goto failed;
4162                         res = obj2ast_expr(tmp, &optional_vars, arena);
4163                         if (res != 0) goto failed;
4164                         Py_XDECREF(tmp);
4165                         tmp = NULL;
4166                 } else {
4167                         optional_vars = NULL;
4168                 }
4169                 if (PyObject_HasAttrString(obj, "body")) {
4170                         int res;
4171                         Py_ssize_t len;
4172                         Py_ssize_t i;
4173                         tmp = PyObject_GetAttrString(obj, "body");
4174                         if (tmp == NULL) goto failed;
4175                         if (!PyList_Check(tmp)) {
4176                                 PyErr_Format(PyExc_TypeError, "With field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4177                                 goto failed;
4178                         }
4179                         len = PyList_GET_SIZE(tmp);
4180                         body = asdl_seq_new(len, arena);
4181                         if (body == NULL) goto failed;
4182                         for (i = 0; i < len; i++) {
4183                                 stmt_ty value;
4184                                 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
4185                                 if (res != 0) goto failed;
4186                                 asdl_seq_SET(body, i, value);
4187                         }
4188                         Py_XDECREF(tmp);
4189                         tmp = NULL;
4190                 } else {
4191                         PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from With");
4192                         return 1;
4193                 }
4194                 *out = With(context_expr, optional_vars, body, lineno,
4195                             col_offset, arena);
4196                 if (*out == NULL) goto failed;
4197                 return 0;
4198         }
4199         isinstance = PyObject_IsInstance(obj, (PyObject*)Raise_type);
4200         if (isinstance == -1) {
4201                 return 1;
4202         }
4203         if (isinstance) {
4204                 expr_ty type;
4205                 expr_ty inst;
4206                 expr_ty tback;
4207
4208                 if (PyObject_HasAttrString(obj, "type")) {
4209                         int res;
4210                         tmp = PyObject_GetAttrString(obj, "type");
4211                         if (tmp == NULL) goto failed;
4212                         res = obj2ast_expr(tmp, &type, arena);
4213                         if (res != 0) goto failed;
4214                         Py_XDECREF(tmp);
4215                         tmp = NULL;
4216                 } else {
4217                         type = NULL;
4218                 }
4219                 if (PyObject_HasAttrString(obj, "inst")) {
4220                         int res;
4221                         tmp = PyObject_GetAttrString(obj, "inst");
4222                         if (tmp == NULL) goto failed;
4223                         res = obj2ast_expr(tmp, &inst, arena);
4224                         if (res != 0) goto failed;
4225                         Py_XDECREF(tmp);
4226                         tmp = NULL;
4227                 } else {
4228                         inst = NULL;
4229                 }
4230                 if (PyObject_HasAttrString(obj, "tback")) {
4231                         int res;
4232                         tmp = PyObject_GetAttrString(obj, "tback");
4233                         if (tmp == NULL) goto failed;
4234                         res = obj2ast_expr(tmp, &tback, arena);
4235                         if (res != 0) goto failed;
4236                         Py_XDECREF(tmp);
4237                         tmp = NULL;
4238                 } else {
4239                         tback = NULL;
4240                 }
4241                 *out = Raise(type, inst, tback, lineno, col_offset, arena);
4242                 if (*out == NULL) goto failed;
4243                 return 0;
4244         }
4245         isinstance = PyObject_IsInstance(obj, (PyObject*)TryExcept_type);
4246         if (isinstance == -1) {
4247                 return 1;
4248         }
4249         if (isinstance) {
4250                 asdl_seq* body;
4251                 asdl_seq* handlers;
4252                 asdl_seq* orelse;
4253
4254                 if (PyObject_HasAttrString(obj, "body")) {
4255                         int res;
4256                         Py_ssize_t len;
4257                         Py_ssize_t i;
4258                         tmp = PyObject_GetAttrString(obj, "body");
4259                         if (tmp == NULL) goto failed;
4260                         if (!PyList_Check(tmp)) {
4261                                 PyErr_Format(PyExc_TypeError, "TryExcept field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4262                                 goto failed;
4263                         }
4264                         len = PyList_GET_SIZE(tmp);
4265                         body = asdl_seq_new(len, arena);
4266                         if (body == NULL) goto failed;
4267                         for (i = 0; i < len; i++) {
4268                                 stmt_ty value;
4269                                 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
4270                                 if (res != 0) goto failed;
4271                                 asdl_seq_SET(body, i, value);
4272                         }
4273                         Py_XDECREF(tmp);
4274                         tmp = NULL;
4275                 } else {
4276                         PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from TryExcept");
4277                         return 1;
4278                 }
4279                 if (PyObject_HasAttrString(obj, "handlers")) {
4280                         int res;
4281                         Py_ssize_t len;
4282                         Py_ssize_t i;
4283                         tmp = PyObject_GetAttrString(obj, "handlers");
4284                         if (tmp == NULL) goto failed;
4285                         if (!PyList_Check(tmp)) {
4286                                 PyErr_Format(PyExc_TypeError, "TryExcept field \"handlers\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4287                                 goto failed;
4288                         }
4289                         len = PyList_GET_SIZE(tmp);
4290                         handlers = asdl_seq_new(len, arena);
4291                         if (handlers == NULL) goto failed;
4292                         for (i = 0; i < len; i++) {
4293                                 excepthandler_ty value;
4294                                 res = obj2ast_excepthandler(PyList_GET_ITEM(tmp, i), &value, arena);
4295                                 if (res != 0) goto failed;
4296                                 asdl_seq_SET(handlers, i, value);
4297                         }
4298                         Py_XDECREF(tmp);
4299                         tmp = NULL;
4300                 } else {
4301                         PyErr_SetString(PyExc_TypeError, "required field \"handlers\" missing from TryExcept");
4302                         return 1;
4303                 }
4304                 if (PyObject_HasAttrString(obj, "orelse")) {
4305                         int res;
4306                         Py_ssize_t len;
4307                         Py_ssize_t i;
4308                         tmp = PyObject_GetAttrString(obj, "orelse");
4309                         if (tmp == NULL) goto failed;
4310                         if (!PyList_Check(tmp)) {
4311                                 PyErr_Format(PyExc_TypeError, "TryExcept field \"orelse\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4312                                 goto failed;
4313                         }
4314                         len = PyList_GET_SIZE(tmp);
4315                         orelse = asdl_seq_new(len, arena);
4316                         if (orelse == NULL) goto failed;
4317                         for (i = 0; i < len; i++) {
4318                                 stmt_ty value;
4319                                 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
4320                                 if (res != 0) goto failed;
4321                                 asdl_seq_SET(orelse, i, value);
4322                         }
4323                         Py_XDECREF(tmp);
4324                         tmp = NULL;
4325                 } else {
4326                         PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from TryExcept");
4327                         return 1;
4328                 }
4329                 *out = TryExcept(body, handlers, orelse, lineno, col_offset,
4330                                  arena);
4331                 if (*out == NULL) goto failed;
4332                 return 0;
4333         }
4334         isinstance = PyObject_IsInstance(obj, (PyObject*)TryFinally_type);
4335         if (isinstance == -1) {
4336                 return 1;
4337         }
4338         if (isinstance) {
4339                 asdl_seq* body;
4340                 asdl_seq* finalbody;
4341
4342                 if (PyObject_HasAttrString(obj, "body")) {
4343                         int res;
4344                         Py_ssize_t len;
4345                         Py_ssize_t i;
4346                         tmp = PyObject_GetAttrString(obj, "body");
4347                         if (tmp == NULL) goto failed;
4348                         if (!PyList_Check(tmp)) {
4349                                 PyErr_Format(PyExc_TypeError, "TryFinally field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4350                                 goto failed;
4351                         }
4352                         len = PyList_GET_SIZE(tmp);
4353                         body = asdl_seq_new(len, arena);
4354                         if (body == NULL) goto failed;
4355                         for (i = 0; i < len; i++) {
4356                                 stmt_ty value;
4357                                 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
4358                                 if (res != 0) goto failed;
4359                                 asdl_seq_SET(body, i, value);
4360                         }
4361                         Py_XDECREF(tmp);
4362                         tmp = NULL;
4363                 } else {
4364                         PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from TryFinally");
4365                         return 1;
4366                 }
4367                 if (PyObject_HasAttrString(obj, "finalbody")) {
4368                         int res;
4369                         Py_ssize_t len;
4370                         Py_ssize_t i;
4371                         tmp = PyObject_GetAttrString(obj, "finalbody");
4372                         if (tmp == NULL) goto failed;
4373                         if (!PyList_Check(tmp)) {
4374                                 PyErr_Format(PyExc_TypeError, "TryFinally field \"finalbody\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4375                                 goto failed;
4376                         }
4377                         len = PyList_GET_SIZE(tmp);
4378                         finalbody = asdl_seq_new(len, arena);
4379                         if (finalbody == NULL) goto failed;
4380                         for (i = 0; i < len; i++) {
4381                                 stmt_ty value;
4382                                 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
4383                                 if (res != 0) goto failed;
4384                                 asdl_seq_SET(finalbody, i, value);
4385                         }
4386                         Py_XDECREF(tmp);
4387                         tmp = NULL;
4388                 } else {
4389                         PyErr_SetString(PyExc_TypeError, "required field \"finalbody\" missing from TryFinally");
4390                         return 1;
4391                 }
4392                 *out = TryFinally(body, finalbody, lineno, col_offset, arena);
4393                 if (*out == NULL) goto failed;
4394                 return 0;
4395         }
4396         isinstance = PyObject_IsInstance(obj, (PyObject*)Assert_type);
4397         if (isinstance == -1) {
4398                 return 1;
4399         }
4400         if (isinstance) {
4401                 expr_ty test;
4402                 expr_ty msg;
4403
4404                 if (PyObject_HasAttrString(obj, "test")) {
4405                         int res;
4406                         tmp = PyObject_GetAttrString(obj, "test");
4407                         if (tmp == NULL) goto failed;
4408                         res = obj2ast_expr(tmp, &test, arena);
4409                         if (res != 0) goto failed;
4410                         Py_XDECREF(tmp);
4411                         tmp = NULL;
4412                 } else {
4413                         PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from Assert");
4414                         return 1;
4415                 }
4416                 if (PyObject_HasAttrString(obj, "msg")) {
4417                         int res;
4418                         tmp = PyObject_GetAttrString(obj, "msg");
4419                         if (tmp == NULL) goto failed;
4420                         res = obj2ast_expr(tmp, &msg, arena);
4421                         if (res != 0) goto failed;
4422                         Py_XDECREF(tmp);
4423                         tmp = NULL;
4424                 } else {
4425                         msg = NULL;
4426                 }
4427                 *out = Assert(test, msg, lineno, col_offset, arena);
4428                 if (*out == NULL) goto failed;
4429                 return 0;
4430         }
4431         isinstance = PyObject_IsInstance(obj, (PyObject*)Import_type);
4432         if (isinstance == -1) {
4433                 return 1;
4434         }
4435         if (isinstance) {
4436                 asdl_seq* names;
4437
4438                 if (PyObject_HasAttrString(obj, "names")) {
4439                         int res;
4440                         Py_ssize_t len;
4441                         Py_ssize_t i;
4442                         tmp = PyObject_GetAttrString(obj, "names");
4443                         if (tmp == NULL) goto failed;
4444                         if (!PyList_Check(tmp)) {
4445                                 PyErr_Format(PyExc_TypeError, "Import field \"names\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4446                                 goto failed;
4447                         }
4448                         len = PyList_GET_SIZE(tmp);
4449                         names = asdl_seq_new(len, arena);
4450                         if (names == NULL) goto failed;
4451                         for (i = 0; i < len; i++) {
4452                                 alias_ty value;
4453                                 res = obj2ast_alias(PyList_GET_ITEM(tmp, i), &value, arena);
4454                                 if (res != 0) goto failed;
4455                                 asdl_seq_SET(names, i, value);
4456                         }
4457                         Py_XDECREF(tmp);
4458                         tmp = NULL;
4459                 } else {
4460                         PyErr_SetString(PyExc_TypeError, "required field \"names\" missing from Import");
4461                         return 1;
4462                 }
4463                 *out = Import(names, lineno, col_offset, arena);
4464                 if (*out == NULL) goto failed;
4465                 return 0;
4466         }
4467         isinstance = PyObject_IsInstance(obj, (PyObject*)ImportFrom_type);
4468         if (isinstance == -1) {
4469                 return 1;
4470         }
4471         if (isinstance) {
4472                 identifier module;
4473                 asdl_seq* names;
4474                 int level;
4475
4476                 if (PyObject_HasAttrString(obj, "module")) {
4477                         int res;
4478                         tmp = PyObject_GetAttrString(obj, "module");
4479                         if (tmp == NULL) goto failed;
4480                         res = obj2ast_identifier(tmp, &module, arena);
4481                         if (res != 0) goto failed;
4482                         Py_XDECREF(tmp);
4483                         tmp = NULL;
4484                 } else {
4485                         module = NULL;
4486                 }
4487                 if (PyObject_HasAttrString(obj, "names")) {
4488                         int res;
4489                         Py_ssize_t len;
4490                         Py_ssize_t i;
4491                         tmp = PyObject_GetAttrString(obj, "names");
4492                         if (tmp == NULL) goto failed;
4493                         if (!PyList_Check(tmp)) {
4494                                 PyErr_Format(PyExc_TypeError, "ImportFrom field \"names\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4495                                 goto failed;
4496                         }
4497                         len = PyList_GET_SIZE(tmp);
4498                         names = asdl_seq_new(len, arena);
4499                         if (names == NULL) goto failed;
4500                         for (i = 0; i < len; i++) {
4501                                 alias_ty value;
4502                                 res = obj2ast_alias(PyList_GET_ITEM(tmp, i), &value, arena);
4503                                 if (res != 0) goto failed;
4504                                 asdl_seq_SET(names, i, value);
4505                         }
4506                         Py_XDECREF(tmp);
4507                         tmp = NULL;
4508                 } else {
4509                         PyErr_SetString(PyExc_TypeError, "required field \"names\" missing from ImportFrom");
4510                         return 1;
4511                 }
4512                 if (PyObject_HasAttrString(obj, "level")) {
4513                         int res;
4514                         tmp = PyObject_GetAttrString(obj, "level");
4515                         if (tmp == NULL) goto failed;
4516                         res = obj2ast_int(tmp, &level, arena);
4517                         if (res != 0) goto failed;
4518                         Py_XDECREF(tmp);
4519                         tmp = NULL;
4520                 } else {
4521                         level = 0;
4522                 }
4523                 *out = ImportFrom(module, names, level, lineno, col_offset,
4524                                   arena);
4525                 if (*out == NULL) goto failed;
4526                 return 0;
4527         }
4528         isinstance = PyObject_IsInstance(obj, (PyObject*)Exec_type);
4529         if (isinstance == -1) {
4530                 return 1;
4531         }
4532         if (isinstance) {
4533                 expr_ty body;
4534                 expr_ty globals;
4535                 expr_ty locals;
4536
4537                 if (PyObject_HasAttrString(obj, "body")) {
4538                         int res;
4539                         tmp = PyObject_GetAttrString(obj, "body");
4540                         if (tmp == NULL) goto failed;
4541                         res = obj2ast_expr(tmp, &body, arena);
4542                         if (res != 0) goto failed;
4543                         Py_XDECREF(tmp);
4544                         tmp = NULL;
4545                 } else {
4546                         PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Exec");
4547                         return 1;
4548                 }
4549                 if (PyObject_HasAttrString(obj, "globals")) {
4550                         int res;
4551                         tmp = PyObject_GetAttrString(obj, "globals");
4552                         if (tmp == NULL) goto failed;
4553                         res = obj2ast_expr(tmp, &globals, arena);
4554                         if (res != 0) goto failed;
4555                         Py_XDECREF(tmp);
4556                         tmp = NULL;
4557                 } else {
4558                         globals = NULL;
4559                 }
4560                 if (PyObject_HasAttrString(obj, "locals")) {
4561                         int res;
4562                         tmp = PyObject_GetAttrString(obj, "locals");
4563                         if (tmp == NULL) goto failed;
4564                         res = obj2ast_expr(tmp, &locals, arena);
4565                         if (res != 0) goto failed;
4566                         Py_XDECREF(tmp);
4567                         tmp = NULL;
4568                 } else {
4569                         locals = NULL;
4570                 }
4571                 *out = Exec(body, globals, locals, lineno, col_offset, arena);
4572                 if (*out == NULL) goto failed;
4573                 return 0;
4574         }
4575         isinstance = PyObject_IsInstance(obj, (PyObject*)Global_type);
4576         if (isinstance == -1) {
4577                 return 1;
4578         }
4579         if (isinstance) {
4580                 asdl_seq* names;
4581
4582                 if (PyObject_HasAttrString(obj, "names")) {
4583                         int res;
4584                         Py_ssize_t len;
4585                         Py_ssize_t i;
4586                         tmp = PyObject_GetAttrString(obj, "names");
4587                         if (tmp == NULL) goto failed;
4588                         if (!PyList_Check(tmp)) {
4589                                 PyErr_Format(PyExc_TypeError, "Global field \"names\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4590                                 goto failed;
4591                         }
4592                         len = PyList_GET_SIZE(tmp);
4593                         names = asdl_seq_new(len, arena);
4594                         if (names == NULL) goto failed;
4595                         for (i = 0; i < len; i++) {
4596                                 identifier value;
4597                                 res = obj2ast_identifier(PyList_GET_ITEM(tmp, i), &value, arena);
4598                                 if (res != 0) goto failed;
4599                                 asdl_seq_SET(names, i, value);
4600                         }
4601                         Py_XDECREF(tmp);
4602                         tmp = NULL;
4603                 } else {
4604                         PyErr_SetString(PyExc_TypeError, "required field \"names\" missing from Global");
4605                         return 1;
4606                 }
4607                 *out = Global(names, lineno, col_offset, arena);
4608                 if (*out == NULL) goto failed;
4609                 return 0;
4610         }
4611         isinstance = PyObject_IsInstance(obj, (PyObject*)Expr_type);
4612         if (isinstance == -1) {
4613                 return 1;
4614         }
4615         if (isinstance) {
4616                 expr_ty value;
4617
4618                 if (PyObject_HasAttrString(obj, "value")) {
4619                         int res;
4620                         tmp = PyObject_GetAttrString(obj, "value");
4621                         if (tmp == NULL) goto failed;
4622                         res = obj2ast_expr(tmp, &value, arena);
4623                         if (res != 0) goto failed;
4624                         Py_XDECREF(tmp);
4625                         tmp = NULL;
4626                 } else {
4627                         PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Expr");
4628                         return 1;
4629                 }
4630                 *out = Expr(value, lineno, col_offset, arena);
4631                 if (*out == NULL) goto failed;
4632                 return 0;
4633         }
4634         isinstance = PyObject_IsInstance(obj, (PyObject*)Pass_type);
4635         if (isinstance == -1) {
4636                 return 1;
4637         }
4638         if (isinstance) {
4639
4640                 *out = Pass(lineno, col_offset, arena);
4641                 if (*out == NULL) goto failed;
4642                 return 0;
4643         }
4644         isinstance = PyObject_IsInstance(obj, (PyObject*)Break_type);
4645         if (isinstance == -1) {
4646                 return 1;
4647         }
4648         if (isinstance) {
4649
4650                 *out = Break(lineno, col_offset, arena);
4651                 if (*out == NULL) goto failed;
4652                 return 0;
4653         }
4654         isinstance = PyObject_IsInstance(obj, (PyObject*)Continue_type);
4655         if (isinstance == -1) {
4656                 return 1;
4657         }
4658         if (isinstance) {
4659
4660                 *out = Continue(lineno, col_offset, arena);
4661                 if (*out == NULL) goto failed;
4662                 return 0;
4663         }
4664
4665         tmp = PyObject_Repr(obj);
4666         if (tmp == NULL) goto failed;
4667         PyErr_Format(PyExc_TypeError, "expected some sort of stmt, but got %.400s", PyString_AS_STRING(tmp));
4668 failed:
4669         Py_XDECREF(tmp);
4670         return 1;
4671 }
4672
4673 int
4674 obj2ast_expr(PyObject* obj, expr_ty* out, PyArena* arena)
4675 {
4676         PyObject* tmp = NULL;
4677         int isinstance;
4678
4679         int lineno;
4680         int col_offset;
4681
4682         if (obj == Py_None) {
4683                 *out = NULL;
4684                 return 0;
4685         }
4686         if (PyObject_HasAttrString(obj, "lineno")) {
4687                 int res;
4688                 tmp = PyObject_GetAttrString(obj, "lineno");
4689                 if (tmp == NULL) goto failed;
4690                 res = obj2ast_int(tmp, &lineno, arena);
4691                 if (res != 0) goto failed;
4692                 Py_XDECREF(tmp);
4693                 tmp = NULL;
4694         } else {
4695                 PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from expr");
4696                 return 1;
4697         }
4698         if (PyObject_HasAttrString(obj, "col_offset")) {
4699                 int res;
4700                 tmp = PyObject_GetAttrString(obj, "col_offset");
4701                 if (tmp == NULL) goto failed;
4702                 res = obj2ast_int(tmp, &col_offset, arena);
4703                 if (res != 0) goto failed;
4704                 Py_XDECREF(tmp);
4705                 tmp = NULL;
4706         } else {
4707                 PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from expr");
4708                 return 1;
4709         }
4710         isinstance = PyObject_IsInstance(obj, (PyObject*)BoolOp_type);
4711         if (isinstance == -1) {
4712                 return 1;
4713         }
4714         if (isinstance) {
4715                 boolop_ty op;
4716                 asdl_seq* values;
4717
4718                 if (PyObject_HasAttrString(obj, "op")) {
4719                         int res;
4720                         tmp = PyObject_GetAttrString(obj, "op");
4721                         if (tmp == NULL) goto failed;
4722                         res = obj2ast_boolop(tmp, &op, arena);
4723                         if (res != 0) goto failed;
4724                         Py_XDECREF(tmp);
4725                         tmp = NULL;
4726                 } else {
4727                         PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from BoolOp");
4728                         return 1;
4729                 }
4730                 if (PyObject_HasAttrString(obj, "values")) {
4731                         int res;
4732                         Py_ssize_t len;
4733                         Py_ssize_t i;
4734                         tmp = PyObject_GetAttrString(obj, "values");
4735                         if (tmp == NULL) goto failed;
4736                         if (!PyList_Check(tmp)) {
4737                                 PyErr_Format(PyExc_TypeError, "BoolOp field \"values\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4738                                 goto failed;
4739                         }
4740                         len = PyList_GET_SIZE(tmp);
4741                         values = asdl_seq_new(len, arena);
4742                         if (values == NULL) goto failed;
4743                         for (i = 0; i < len; i++) {
4744                                 expr_ty value;
4745                                 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
4746                                 if (res != 0) goto failed;
4747                                 asdl_seq_SET(values, i, value);
4748                         }
4749                         Py_XDECREF(tmp);
4750                         tmp = NULL;
4751                 } else {
4752                         PyErr_SetString(PyExc_TypeError, "required field \"values\" missing from BoolOp");
4753                         return 1;
4754                 }
4755                 *out = BoolOp(op, values, lineno, col_offset, arena);
4756                 if (*out == NULL) goto failed;
4757                 return 0;
4758         }
4759         isinstance = PyObject_IsInstance(obj, (PyObject*)BinOp_type);
4760         if (isinstance == -1) {
4761                 return 1;
4762         }
4763         if (isinstance) {
4764                 expr_ty left;
4765                 operator_ty op;
4766                 expr_ty right;
4767
4768                 if (PyObject_HasAttrString(obj, "left")) {
4769                         int res;
4770                         tmp = PyObject_GetAttrString(obj, "left");
4771                         if (tmp == NULL) goto failed;
4772                         res = obj2ast_expr(tmp, &left, arena);
4773                         if (res != 0) goto failed;
4774                         Py_XDECREF(tmp);
4775                         tmp = NULL;
4776                 } else {
4777                         PyErr_SetString(PyExc_TypeError, "required field \"left\" missing from BinOp");
4778                         return 1;
4779                 }
4780                 if (PyObject_HasAttrString(obj, "op")) {
4781                         int res;
4782                         tmp = PyObject_GetAttrString(obj, "op");
4783                         if (tmp == NULL) goto failed;
4784                         res = obj2ast_operator(tmp, &op, arena);
4785                         if (res != 0) goto failed;
4786                         Py_XDECREF(tmp);
4787                         tmp = NULL;
4788                 } else {
4789                         PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from BinOp");
4790                         return 1;
4791                 }
4792                 if (PyObject_HasAttrString(obj, "right")) {
4793                         int res;
4794                         tmp = PyObject_GetAttrString(obj, "right");
4795                         if (tmp == NULL) goto failed;
4796                         res = obj2ast_expr(tmp, &right, arena);
4797                         if (res != 0) goto failed;
4798                         Py_XDECREF(tmp);
4799                         tmp = NULL;
4800                 } else {
4801                         PyErr_SetString(PyExc_TypeError, "required field \"right\" missing from BinOp");
4802                         return 1;
4803                 }
4804                 *out = BinOp(left, op, right, lineno, col_offset, arena);
4805                 if (*out == NULL) goto failed;
4806                 return 0;
4807         }
4808         isinstance = PyObject_IsInstance(obj, (PyObject*)UnaryOp_type);
4809         if (isinstance == -1) {
4810                 return 1;
4811         }
4812         if (isinstance) {
4813                 unaryop_ty op;
4814                 expr_ty operand;
4815
4816                 if (PyObject_HasAttrString(obj, "op")) {
4817                         int res;
4818                         tmp = PyObject_GetAttrString(obj, "op");
4819                         if (tmp == NULL) goto failed;
4820                         res = obj2ast_unaryop(tmp, &op, arena);
4821                         if (res != 0) goto failed;
4822                         Py_XDECREF(tmp);
4823                         tmp = NULL;
4824                 } else {
4825                         PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from UnaryOp");
4826                         return 1;
4827                 }
4828                 if (PyObject_HasAttrString(obj, "operand")) {
4829                         int res;
4830                         tmp = PyObject_GetAttrString(obj, "operand");
4831                         if (tmp == NULL) goto failed;
4832                         res = obj2ast_expr(tmp, &operand, arena);
4833                         if (res != 0) goto failed;
4834                         Py_XDECREF(tmp);
4835                         tmp = NULL;
4836                 } else {
4837                         PyErr_SetString(PyExc_TypeError, "required field \"operand\" missing from UnaryOp");
4838                         return 1;
4839                 }
4840                 *out = UnaryOp(op, operand, lineno, col_offset, arena);
4841                 if (*out == NULL) goto failed;
4842                 return 0;
4843         }
4844         isinstance = PyObject_IsInstance(obj, (PyObject*)Lambda_type);
4845         if (isinstance == -1) {
4846                 return 1;
4847         }
4848         if (isinstance) {
4849                 arguments_ty args;
4850                 expr_ty body;
4851
4852                 if (PyObject_HasAttrString(obj, "args")) {
4853                         int res;
4854                         tmp = PyObject_GetAttrString(obj, "args");
4855                         if (tmp == NULL) goto failed;
4856                         res = obj2ast_arguments(tmp, &args, arena);
4857                         if (res != 0) goto failed;
4858                         Py_XDECREF(tmp);
4859                         tmp = NULL;
4860                 } else {
4861                         PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from Lambda");
4862                         return 1;
4863                 }
4864                 if (PyObject_HasAttrString(obj, "body")) {
4865                         int res;
4866                         tmp = PyObject_GetAttrString(obj, "body");
4867                         if (tmp == NULL) goto failed;
4868                         res = obj2ast_expr(tmp, &body, arena);
4869                         if (res != 0) goto failed;
4870                         Py_XDECREF(tmp);
4871                         tmp = NULL;
4872                 } else {
4873                         PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Lambda");
4874                         return 1;
4875                 }
4876                 *out = Lambda(args, body, lineno, col_offset, arena);
4877                 if (*out == NULL) goto failed;
4878                 return 0;
4879         }
4880         isinstance = PyObject_IsInstance(obj, (PyObject*)IfExp_type);
4881         if (isinstance == -1) {
4882                 return 1;
4883         }
4884         if (isinstance) {
4885                 expr_ty test;
4886                 expr_ty body;
4887                 expr_ty orelse;
4888
4889                 if (PyObject_HasAttrString(obj, "test")) {
4890                         int res;
4891                         tmp = PyObject_GetAttrString(obj, "test");
4892                         if (tmp == NULL) goto failed;
4893                         res = obj2ast_expr(tmp, &test, arena);
4894                         if (res != 0) goto failed;
4895                         Py_XDECREF(tmp);
4896                         tmp = NULL;
4897                 } else {
4898                         PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from IfExp");
4899                         return 1;
4900                 }
4901                 if (PyObject_HasAttrString(obj, "body")) {
4902                         int res;
4903                         tmp = PyObject_GetAttrString(obj, "body");
4904                         if (tmp == NULL) goto failed;
4905                         res = obj2ast_expr(tmp, &body, arena);
4906                         if (res != 0) goto failed;
4907                         Py_XDECREF(tmp);
4908                         tmp = NULL;
4909                 } else {
4910                         PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from IfExp");
4911                         return 1;
4912                 }
4913                 if (PyObject_HasAttrString(obj, "orelse")) {
4914                         int res;
4915                         tmp = PyObject_GetAttrString(obj, "orelse");
4916                         if (tmp == NULL) goto failed;
4917                         res = obj2ast_expr(tmp, &orelse, arena);
4918                         if (res != 0) goto failed;
4919                         Py_XDECREF(tmp);
4920                         tmp = NULL;
4921                 } else {
4922                         PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from IfExp");
4923                         return 1;
4924                 }
4925                 *out = IfExp(test, body, orelse, lineno, col_offset, arena);
4926                 if (*out == NULL) goto failed;
4927                 return 0;
4928         }
4929         isinstance = PyObject_IsInstance(obj, (PyObject*)Dict_type);
4930         if (isinstance == -1) {
4931                 return 1;
4932         }
4933         if (isinstance) {
4934                 asdl_seq* keys;
4935                 asdl_seq* values;
4936
4937                 if (PyObject_HasAttrString(obj, "keys")) {
4938                         int res;
4939                         Py_ssize_t len;
4940                         Py_ssize_t i;
4941                         tmp = PyObject_GetAttrString(obj, "keys");
4942                         if (tmp == NULL) goto failed;
4943                         if (!PyList_Check(tmp)) {
4944                                 PyErr_Format(PyExc_TypeError, "Dict field \"keys\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4945                                 goto failed;
4946                         }
4947                         len = PyList_GET_SIZE(tmp);
4948                         keys = asdl_seq_new(len, arena);
4949                         if (keys == NULL) goto failed;
4950                         for (i = 0; i < len; i++) {
4951                                 expr_ty value;
4952                                 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
4953                                 if (res != 0) goto failed;
4954                                 asdl_seq_SET(keys, i, value);
4955                         }
4956                         Py_XDECREF(tmp);
4957                         tmp = NULL;
4958                 } else {
4959                         PyErr_SetString(PyExc_TypeError, "required field \"keys\" missing from Dict");
4960                         return 1;
4961                 }
4962                 if (PyObject_HasAttrString(obj, "values")) {
4963                         int res;
4964                         Py_ssize_t len;
4965                         Py_ssize_t i;
4966                         tmp = PyObject_GetAttrString(obj, "values");
4967                         if (tmp == NULL) goto failed;
4968                         if (!PyList_Check(tmp)) {
4969                                 PyErr_Format(PyExc_TypeError, "Dict field \"values\" must be a list, not a %.200s", tmp->ob_type->tp_name);
4970                                 goto failed;
4971                         }
4972                         len = PyList_GET_SIZE(tmp);
4973                         values = asdl_seq_new(len, arena);
4974                         if (values == NULL) goto failed;
4975                         for (i = 0; i < len; i++) {
4976                                 expr_ty value;
4977                                 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
4978                                 if (res != 0) goto failed;
4979                                 asdl_seq_SET(values, i, value);
4980                         }
4981                         Py_XDECREF(tmp);
4982                         tmp = NULL;
4983                 } else {
4984                         PyErr_SetString(PyExc_TypeError, "required field \"values\" missing from Dict");
4985                         return 1;
4986                 }
4987                 *out = Dict(keys, values, lineno, col_offset, arena);
4988                 if (*out == NULL) goto failed;
4989                 return 0;
4990         }
4991         isinstance = PyObject_IsInstance(obj, (PyObject*)Set_type);
4992         if (isinstance == -1) {
4993                 return 1;
4994         }
4995         if (isinstance) {
4996                 asdl_seq* elts;
4997
4998                 if (PyObject_HasAttrString(obj, "elts")) {
4999                         int res;
5000                         Py_ssize_t len;
5001                         Py_ssize_t i;
5002                         tmp = PyObject_GetAttrString(obj, "elts");
5003                         if (tmp == NULL) goto failed;
5004                         if (!PyList_Check(tmp)) {
5005                                 PyErr_Format(PyExc_TypeError, "Set field \"elts\" must be a list, not a %.200s", tmp->ob_type->tp_name);
5006                                 goto failed;
5007                         }
5008                         len = PyList_GET_SIZE(tmp);
5009                         elts = asdl_seq_new(len, arena);
5010                         if (elts == NULL) goto failed;
5011                         for (i = 0; i < len; i++) {
5012                                 expr_ty value;
5013                                 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
5014                                 if (res != 0) goto failed;
5015                                 asdl_seq_SET(elts, i, value);
5016                         }
5017                         Py_XDECREF(tmp);
5018                         tmp = NULL;
5019                 } else {
5020                         PyErr_SetString(PyExc_TypeError, "required field \"elts\" missing from Set");
5021                         return 1;
5022                 }
5023                 *out = Set(elts, lineno, col_offset, arena);
5024                 if (*out == NULL) goto failed;
5025                 return 0;
5026         }
5027         isinstance = PyObject_IsInstance(obj, (PyObject*)ListComp_type);
5028         if (isinstance == -1) {
5029                 return 1;
5030         }
5031         if (isinstance) {
5032                 expr_ty elt;
5033                 asdl_seq* generators;
5034
5035                 if (PyObject_HasAttrString(obj, "elt")) {
5036                         int res;
5037                         tmp = PyObject_GetAttrString(obj, "elt");
5038                         if (tmp == NULL) goto failed;
5039                         res = obj2ast_expr(tmp, &elt, arena);
5040                         if (res != 0) goto failed;
5041                         Py_XDECREF(tmp);
5042                         tmp = NULL;
5043                 } else {
5044                         PyErr_SetString(PyExc_TypeError, "required field \"elt\" missing from ListComp");
5045                         return 1;
5046                 }
5047                 if (PyObject_HasAttrString(obj, "generators")) {
5048                         int res;
5049                         Py_ssize_t len;
5050                         Py_ssize_t i;
5051                         tmp = PyObject_GetAttrString(obj, "generators");
5052                         if (tmp == NULL) goto failed;
5053                         if (!PyList_Check(tmp)) {
5054                                 PyErr_Format(PyExc_TypeError, "ListComp field \"generators\" must be a list, not a %.200s", tmp->ob_type->tp_name);
5055                                 goto failed;
5056                         }
5057                         len = PyList_GET_SIZE(tmp);
5058                         generators = asdl_seq_new(len, arena);
5059                         if (generators == NULL) goto failed;
5060                         for (i = 0; i < len; i++) {
5061                                 comprehension_ty value;
5062                                 res = obj2ast_comprehension(PyList_GET_ITEM(tmp, i), &value, arena);
5063                                 if (res != 0) goto failed;
5064                                 asdl_seq_SET(generators, i, value);
5065                         }
5066                         Py_XDECREF(tmp);
5067                         tmp = NULL;
5068                 } else {
5069                         PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from ListComp");
5070                         return 1;
5071                 }
5072                 *out = ListComp(elt, generators, lineno, col_offset, arena);
5073                 if (*out == NULL) goto failed;
5074                 return 0;
5075         }
5076         isinstance = PyObject_IsInstance(obj, (PyObject*)SetComp_type);
5077         if (isinstance == -1) {
5078                 return 1;
5079         }
5080         if (isinstance) {
5081                 expr_ty elt;
5082                 asdl_seq* generators;
5083
5084                 if (PyObject_HasAttrString(obj, "elt")) {
5085                         int res;
5086                         tmp = PyObject_GetAttrString(obj, "elt");
5087                         if (tmp == NULL) goto failed;
5088                         res = obj2ast_expr(tmp, &elt, arena);
5089                         if (res != 0) goto failed;
5090                         Py_XDECREF(tmp);
5091                         tmp = NULL;
5092                 } else {
5093                         PyErr_SetString(PyExc_TypeError, "required field \"elt\" missing from SetComp");
5094                         return 1;
5095                 }
5096                 if (PyObject_HasAttrString(obj, "generators")) {
5097                         int res;
5098                         Py_ssize_t len;
5099                         Py_ssize_t i;
5100                         tmp = PyObject_GetAttrString(obj, "generators");
5101                         if (tmp == NULL) goto failed;
5102                         if (!PyList_Check(tmp)) {
5103                                 PyErr_Format(PyExc_TypeError, "SetComp field \"generators\" must be a list, not a %.200s", tmp->ob_type->tp_name);
5104                                 goto failed;
5105                         }
5106                         len = PyList_GET_SIZE(tmp);
5107                         generators = asdl_seq_new(len, arena);
5108                         if (generators == NULL) goto failed;
5109                         for (i = 0; i < len; i++) {
5110                                 comprehension_ty value;
5111                                 res = obj2ast_comprehension(PyList_GET_ITEM(tmp, i), &value, arena);
5112                                 if (res != 0) goto failed;
5113                                 asdl_seq_SET(generators, i, value);
5114                         }
5115                         Py_XDECREF(tmp);
5116                         tmp = NULL;
5117                 } else {
5118                         PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from SetComp");
5119                         return 1;
5120                 }
5121                 *out = SetComp(elt, generators, lineno, col_offset, arena);
5122                 if (*out == NULL) goto failed;
5123                 return 0;
5124         }
5125         isinstance = PyObject_IsInstance(obj, (PyObject*)DictComp_type);
5126         if (isinstance == -1) {
5127                 return 1;
5128         }
5129         if (isinstance) {
5130                 expr_ty key;
5131                 expr_ty value;
5132                 asdl_seq* generators;
5133
5134                 if (PyObject_HasAttrString(obj, "key")) {
5135                         int res;
5136                         tmp = PyObject_GetAttrString(obj, "key");
5137                         if (tmp == NULL) goto failed;
5138                         res = obj2ast_expr(tmp, &key, arena);
5139                         if (res != 0) goto failed;
5140                         Py_XDECREF(tmp);
5141                         tmp = NULL;
5142                 } else {
5143                         PyErr_SetString(PyExc_TypeError, "required field \"key\" missing from DictComp");
5144                         return 1;
5145                 }
5146                 if (PyObject_HasAttrString(obj, "value")) {
5147                         int res;
5148                         tmp = PyObject_GetAttrString(obj, "value");
5149                         if (tmp == NULL) goto failed;
5150                         res = obj2ast_expr(tmp, &value, arena);
5151                         if (res != 0) goto failed;
5152                         Py_XDECREF(tmp);
5153                         tmp = NULL;
5154                 } else {
5155                         PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from DictComp");
5156                         return 1;
5157                 }
5158                 if (PyObject_HasAttrString(obj, "generators")) {
5159                         int res;
5160                         Py_ssize_t len;
5161                         Py_ssize_t i;
5162                         tmp = PyObject_GetAttrString(obj, "generators");
5163                         if (tmp == NULL) goto failed;
5164                         if (!PyList_Check(tmp)) {
5165                                 PyErr_Format(PyExc_TypeError, "DictComp field \"generators\" must be a list, not a %.200s", tmp->ob_type->tp_name);
5166                                 goto failed;
5167                         }
5168                         len = PyList_GET_SIZE(tmp);
5169                         generators = asdl_seq_new(len, arena);
5170                         if (generators == NULL) goto failed;
5171                         for (i = 0; i < len; i++) {
5172                                 comprehension_ty value;
5173                                 res = obj2ast_comprehension(PyList_GET_ITEM(tmp, i), &value, arena);
5174                                 if (res != 0) goto failed;
5175                                 asdl_seq_SET(generators, i, value);
5176                         }
5177                         Py_XDECREF(tmp);
5178                         tmp = NULL;
5179                 } else {
5180                         PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from DictComp");
5181                         return 1;
5182                 }
5183                 *out = DictComp(key, value, generators, lineno, col_offset,
5184                                 arena);
5185                 if (*out == NULL) goto failed;
5186                 return 0;
5187         }
5188         isinstance = PyObject_IsInstance(obj, (PyObject*)GeneratorExp_type);
5189         if (isinstance == -1) {
5190                 return 1;
5191         }
5192         if (isinstance) {
5193                 expr_ty elt;
5194                 asdl_seq* generators;
5195
5196                 if (PyObject_HasAttrString(obj, "elt")) {
5197                         int res;
5198                         tmp = PyObject_GetAttrString(obj, "elt");
5199                         if (tmp == NULL) goto failed;
5200                         res = obj2ast_expr(tmp, &elt, arena);
5201                         if (res != 0) goto failed;
5202                         Py_XDECREF(tmp);
5203                         tmp = NULL;
5204                 } else {
5205                         PyErr_SetString(PyExc_TypeError, "required field \"elt\" missing from GeneratorExp");
5206                         return 1;
5207                 }
5208                 if (PyObject_HasAttrString(obj, "generators")) {
5209                         int res;
5210                         Py_ssize_t len;
5211                         Py_ssize_t i;
5212                         tmp = PyObject_GetAttrString(obj, "generators");
5213                         if (tmp == NULL) goto failed;
5214                         if (!PyList_Check(tmp)) {
5215                                 PyErr_Format(PyExc_TypeError, "GeneratorExp field \"generators\" must be a list, not a %.200s", tmp->ob_type->tp_name);
5216                                 goto failed;
5217                         }
5218                         len = PyList_GET_SIZE(tmp);
5219                         generators = asdl_seq_new(len, arena);
5220                         if (generators == NULL) goto failed;
5221                         for (i = 0; i < len; i++) {
5222                                 comprehension_ty value;
5223                                 res = obj2ast_comprehension(PyList_GET_ITEM(tmp, i), &value, arena);
5224                                 if (res != 0) goto failed;
5225                                 asdl_seq_SET(generators, i, value);
5226                         }
5227                         Py_XDECREF(tmp);
5228                         tmp = NULL;
5229                 } else {
5230                         PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from GeneratorExp");
5231                         return 1;
5232                 }
5233                 *out = GeneratorExp(elt, generators, lineno, col_offset, arena);
5234                 if (*out == NULL) goto failed;
5235                 return 0;
5236         }
5237         isinstance = PyObject_IsInstance(obj, (PyObject*)Yield_type);
5238         if (isinstance == -1) {
5239                 return 1;
5240         }
5241         if (isinstance) {
5242                 expr_ty value;
5243
5244                 if (PyObject_HasAttrString(obj, "value")) {
5245                         int res;
5246                         tmp = PyObject_GetAttrString(obj, "value");
5247                         if (tmp == NULL) goto failed;
5248                         res = obj2ast_expr(tmp, &value, arena);
5249                         if (res != 0) goto failed;
5250                         Py_XDECREF(tmp);
5251                         tmp = NULL;
5252                 } else {
5253                         value = NULL;
5254                 }
5255                 *out = Yield(value, lineno, col_offset, arena);
5256                 if (*out == NULL) goto failed;
5257                 return 0;
5258         }
5259         isinstance = PyObject_IsInstance(obj, (PyObject*)Compare_type);
5260         if (isinstance == -1) {
5261                 return 1;
5262         }
5263         if (isinstance) {
5264                 expr_ty left;
5265                 asdl_int_seq* ops;
5266                 asdl_seq* comparators;
5267
5268                 if (PyObject_HasAttrString(obj, "left")) {
5269                         int res;
5270                         tmp = PyObject_GetAttrString(obj, "left");
5271                         if (tmp == NULL) goto failed;
5272                         res = obj2ast_expr(tmp, &left, arena);
5273                         if (res != 0) goto failed;
5274                         Py_XDECREF(tmp);
5275                         tmp = NULL;
5276                 } else {
5277                         PyErr_SetString(PyExc_TypeError, "required field \"left\" missing from Compare");
5278                         return 1;
5279                 }
5280                 if (PyObject_HasAttrString(obj, "ops")) {
5281                         int res;
5282                         Py_ssize_t len;
5283                         Py_ssize_t i;
5284                         tmp = PyObject_GetAttrString(obj, "ops");
5285                         if (tmp == NULL) goto failed;
5286                         if (!PyList_Check(tmp)) {
5287                                 PyErr_Format(PyExc_TypeError, "Compare field \"ops\" must be a list, not a %.200s", tmp->ob_type->tp_name);
5288                                 goto failed;
5289                         }
5290                         len = PyList_GET_SIZE(tmp);
5291                         ops = asdl_int_seq_new(len, arena);
5292                         if (ops == NULL) goto failed;
5293                         for (i = 0; i < len; i++) {
5294                                 cmpop_ty value;
5295                                 res = obj2ast_cmpop(PyList_GET_ITEM(tmp, i), &value, arena);
5296                                 if (res != 0) goto failed;
5297                                 asdl_seq_SET(ops, i, value);
5298                         }
5299                         Py_XDECREF(tmp);
5300                         tmp = NULL;
5301                 } else {
5302                         PyErr_SetString(PyExc_TypeError, "required field \"ops\" missing from Compare");
5303                         return 1;
5304                 }
5305                 if (PyObject_HasAttrString(obj, "comparators")) {
5306                         int res;
5307                         Py_ssize_t len;
5308                         Py_ssize_t i;
5309                         tmp = PyObject_GetAttrString(obj, "comparators");
5310                         if (tmp == NULL) goto failed;
5311                         if (!PyList_Check(tmp)) {
5312                                 PyErr_Format(PyExc_TypeError, "Compare field \"comparators\" must be a list, not a %.200s", tmp->ob_type->tp_name);
5313                                 goto failed;
5314                         }
5315                         len = PyList_GET_SIZE(tmp);
5316                         comparators = asdl_seq_new(len, arena);
5317                         if (comparators == NULL) goto failed;
5318                         for (i = 0; i < len; i++) {
5319                                 expr_ty value;
5320                                 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
5321                                 if (res != 0) goto failed;
5322                                 asdl_seq_SET(comparators, i, value);
5323                         }
5324                         Py_XDECREF(tmp);
5325                         tmp = NULL;
5326                 } else {
5327                         PyErr_SetString(PyExc_TypeError, "required field \"comparators\" missing from Compare");
5328                         return 1;
5329                 }
5330                 *out = Compare(left, ops, comparators, lineno, col_offset,
5331                                arena);
5332                 if (*out == NULL) goto failed;
5333                 return 0;
5334         }
5335         isinstance = PyObject_IsInstance(obj, (PyObject*)Call_type);
5336         if (isinstance == -1) {
5337                 return 1;
5338         }
5339         if (isinstance) {
5340                 expr_ty func;
5341                 asdl_seq* args;
5342                 asdl_seq* keywords;
5343                 expr_ty starargs;
5344                 expr_ty kwargs;
5345
5346                 if (PyObject_HasAttrString(obj, "func")) {
5347                         int res;
5348                         tmp = PyObject_GetAttrString(obj, "func");
5349                         if (tmp == NULL) goto failed;
5350                         res = obj2ast_expr(tmp, &func, arena);
5351                         if (res != 0) goto failed;
5352                         Py_XDECREF(tmp);
5353                         tmp = NULL;
5354                 } else {
5355                         PyErr_SetString(PyExc_TypeError, "required field \"func\" missing from Call");
5356                         return 1;
5357                 }
5358                 if (PyObject_HasAttrString(obj, "args")) {
5359                         int res;
5360                         Py_ssize_t len;
5361                         Py_ssize_t i;
5362                         tmp = PyObject_GetAttrString(obj, "args");
5363                         if (tmp == NULL) goto failed;
5364                         if (!PyList_Check(tmp)) {
5365                                 PyErr_Format(PyExc_TypeError, "Call field \"args\" must be a list, not a %.200s", tmp->ob_type->tp_name);
5366                                 goto failed;
5367                         }
5368                         len = PyList_GET_SIZE(tmp);
5369                         args = asdl_seq_new(len, arena);
5370                         if (args == NULL) goto failed;
5371                         for (i = 0; i < len; i++) {
5372                                 expr_ty value;
5373                                 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
5374                                 if (res != 0) goto failed;
5375                                 asdl_seq_SET(args, i, value);
5376                         }
5377                         Py_XDECREF(tmp);
5378                         tmp = NULL;
5379                 } else {
5380                         PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from Call");
5381                         return 1;
5382                 }
5383                 if (PyObject_HasAttrString(obj, "keywords")) {
5384                         int res;
5385                         Py_ssize_t len;
5386                         Py_ssize_t i;
5387                         tmp = PyObject_GetAttrString(obj, "keywords");
5388                         if (tmp == NULL) goto failed;
5389                         if (!PyList_Check(tmp)) {
5390                                 PyErr_Format(PyExc_TypeError, "Call field \"keywords\" must be a list, not a %.200s", tmp->ob_type->tp_name);
5391                                 goto failed;
5392                         }
5393                         len = PyList_GET_SIZE(tmp);
5394                         keywords = asdl_seq_new(len, arena);
5395                         if (keywords == NULL) goto failed;
5396                         for (i = 0; i < len; i++) {
5397                                 keyword_ty value;
5398                                 res = obj2ast_keyword(PyList_GET_ITEM(tmp, i), &value, arena);
5399                                 if (res != 0) goto failed;
5400                                 asdl_seq_SET(keywords, i, value);
5401                         }
5402                         Py_XDECREF(tmp);
5403                         tmp = NULL;
5404                 } else {
5405                         PyErr_SetString(PyExc_TypeError, "required field \"keywords\" missing from Call");
5406                         return 1;
5407                 }
5408                 if (PyObject_HasAttrString(obj, "starargs")) {
5409                         int res;
5410                         tmp = PyObject_GetAttrString(obj, "starargs");
5411                         if (tmp == NULL) goto failed;
5412                         res = obj2ast_expr(tmp, &starargs, arena);
5413                         if (res != 0) goto failed;
5414                         Py_XDECREF(tmp);
5415                         tmp = NULL;
5416                 } else {
5417                         starargs = NULL;
5418                 }
5419                 if (PyObject_HasAttrString(obj, "kwargs")) {
5420                         int res;
5421                         tmp = PyObject_GetAttrString(obj, "kwargs");
5422                         if (tmp == NULL) goto failed;
5423                         res = obj2ast_expr(tmp, &kwargs, arena);
5424                         if (res != 0) goto failed;
5425                         Py_XDECREF(tmp);
5426                         tmp = NULL;
5427                 } else {
5428                         kwargs = NULL;
5429                 }
5430                 *out = Call(func, args, keywords, starargs, kwargs, lineno,
5431                             col_offset, arena);
5432                 if (*out == NULL) goto failed;
5433                 return 0;
5434         }
5435         isinstance = PyObject_IsInstance(obj, (PyObject*)Repr_type);
5436         if (isinstance == -1) {
5437                 return 1;
5438         }
5439         if (isinstance) {
5440                 expr_ty value;
5441
5442                 if (PyObject_HasAttrString(obj, "value")) {
5443                         int res;
5444                         tmp = PyObject_GetAttrString(obj, "value");
5445                         if (tmp == NULL) goto failed;
5446                         res = obj2ast_expr(tmp, &value, arena);
5447                         if (res != 0) goto failed;
5448                         Py_XDECREF(tmp);
5449                         tmp = NULL;
5450                 } else {
5451                         PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Repr");
5452                         return 1;
5453                 }
5454                 *out = Repr(value, lineno, col_offset, arena);
5455                 if (*out == NULL) goto failed;
5456                 return 0;
5457         }
5458         isinstance = PyObject_IsInstance(obj, (PyObject*)Num_type);
5459         if (isinstance == -1) {
5460                 return 1;
5461         }
5462         if (isinstance) {
5463                 object n;
5464
5465                 if (PyObject_HasAttrString(obj, "n")) {
5466                         int res;
5467                         tmp = PyObject_GetAttrString(obj, "n");
5468                         if (tmp == NULL) goto failed;
5469                         res = obj2ast_object(tmp, &n, arena);
5470                         if (res != 0) goto failed;
5471                         Py_XDECREF(tmp);
5472                         tmp = NULL;
5473                 } else {
5474                         PyErr_SetString(PyExc_TypeError, "required field \"n\" missing from Num");
5475                         return 1;
5476                 }
5477                 *out = Num(n, lineno, col_offset, arena);
5478                 if (*out == NULL) goto failed;
5479                 return 0;
5480         }
5481         isinstance = PyObject_IsInstance(obj, (PyObject*)Str_type);
5482         if (isinstance == -1) {
5483                 return 1;
5484         }
5485         if (isinstance) {
5486                 string s;
5487
5488                 if (PyObject_HasAttrString(obj, "s")) {
5489                         int res;
5490                         tmp = PyObject_GetAttrString(obj, "s");
5491                         if (tmp == NULL) goto failed;
5492                         res = obj2ast_string(tmp, &s, arena);
5493                         if (res != 0) goto failed;
5494                         Py_XDECREF(tmp);
5495                         tmp = NULL;
5496                 } else {
5497                         PyErr_SetString(PyExc_TypeError, "required field \"s\" missing from Str");
5498                         return 1;
5499                 }
5500                 *out = Str(s, lineno, col_offset, arena);
5501                 if (*out == NULL) goto failed;
5502                 return 0;
5503         }
5504         isinstance = PyObject_IsInstance(obj, (PyObject*)Attribute_type);
5505         if (isinstance == -1) {
5506                 return 1;
5507         }
5508         if (isinstance) {
5509                 expr_ty value;
5510                 identifier attr;
5511                 expr_context_ty ctx;
5512
5513                 if (PyObject_HasAttrString(obj, "value")) {
5514                         int res;
5515                         tmp = PyObject_GetAttrString(obj, "value");
5516                         if (tmp == NULL) goto failed;
5517                         res = obj2ast_expr(tmp, &value, arena);
5518                         if (res != 0) goto failed;
5519                         Py_XDECREF(tmp);
5520                         tmp = NULL;
5521                 } else {
5522                         PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Attribute");
5523                         return 1;
5524                 }
5525                 if (PyObject_HasAttrString(obj, "attr")) {
5526                         int res;
5527                         tmp = PyObject_GetAttrString(obj, "attr");
5528                         if (tmp == NULL) goto failed;
5529                         res = obj2ast_identifier(tmp, &attr, arena);
5530                         if (res != 0) goto failed;
5531                         Py_XDECREF(tmp);
5532                         tmp = NULL;
5533                 } else {
5534                         PyErr_SetString(PyExc_TypeError, "required field \"attr\" missing from Attribute");
5535                         return 1;
5536                 }
5537                 if (PyObject_HasAttrString(obj, "ctx")) {
5538                         int res;
5539                         tmp = PyObject_GetAttrString(obj, "ctx");
5540                         if (tmp == NULL) goto failed;
5541                         res = obj2ast_expr_context(tmp, &ctx, arena);
5542                         if (res != 0) goto failed;
5543                         Py_XDECREF(tmp);
5544                         tmp = NULL;
5545                 } else {
5546                         PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Attribute");
5547                         return 1;
5548                 }
5549                 *out = Attribute(value, attr, ctx, lineno, col_offset, arena);
5550                 if (*out == NULL) goto failed;
5551                 return 0;
5552         }
5553         isinstance = PyObject_IsInstance(obj, (PyObject*)Subscript_type);
5554         if (isinstance == -1) {
5555                 return 1;
5556         }
5557         if (isinstance) {
5558                 expr_ty value;
5559                 slice_ty slice;
5560                 expr_context_ty ctx;
5561
5562                 if (PyObject_HasAttrString(obj, "value")) {
5563                         int res;
5564                         tmp = PyObject_GetAttrString(obj, "value");
5565                         if (tmp == NULL) goto failed;
5566                         res = obj2ast_expr(tmp, &value, arena);
5567                         if (res != 0) goto failed;
5568                         Py_XDECREF(tmp);
5569                         tmp = NULL;
5570                 } else {
5571                         PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Subscript");
5572                         return 1;
5573                 }
5574                 if (PyObject_HasAttrString(obj, "slice")) {
5575                         int res;
5576                         tmp = PyObject_GetAttrString(obj, "slice");
5577                         if (tmp == NULL) goto failed;
5578                         res = obj2ast_slice(tmp, &slice, arena);
5579                         if (res != 0) goto failed;
5580                         Py_XDECREF(tmp);
5581                         tmp = NULL;
5582                 } else {
5583                         PyErr_SetString(PyExc_TypeError, "required field \"slice\" missing from Subscript");
5584                         return 1;
5585                 }
5586                 if (PyObject_HasAttrString(obj, "ctx")) {
5587                         int res;
5588                         tmp = PyObject_GetAttrString(obj, "ctx");
5589                         if (tmp == NULL) goto failed;
5590                         res = obj2ast_expr_context(tmp, &ctx, arena);
5591                         if (res != 0) goto failed;
5592                         Py_XDECREF(tmp);
5593                         tmp = NULL;
5594                 } else {
5595                         PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Subscript");
5596                         return 1;
5597                 }
5598                 *out = Subscript(value, slice, ctx, lineno, col_offset, arena);
5599                 if (*out == NULL) goto failed;
5600                 return 0;
5601         }
5602         isinstance = PyObject_IsInstance(obj, (PyObject*)Name_type);
5603         if (isinstance == -1) {
5604                 return 1;
5605         }
5606         if (isinstance) {
5607                 identifier id;
5608                 expr_context_ty ctx;
5609
5610                 if (PyObject_HasAttrString(obj, "id")) {
5611                         int res;
5612                         tmp = PyObject_GetAttrString(obj, "id");
5613                         if (tmp == NULL) goto failed;
5614                         res = obj2ast_identifier(tmp, &id, arena);
5615                         if (res != 0) goto failed;
5616                         Py_XDECREF(tmp);
5617                         tmp = NULL;
5618                 } else {
5619                         PyErr_SetString(PyExc_TypeError, "required field \"id\" missing from Name");
5620                         return 1;
5621                 }
5622                 if (PyObject_HasAttrString(obj, "ctx")) {
5623                         int res;
5624                         tmp = PyObject_GetAttrString(obj, "ctx");
5625                         if (tmp == NULL) goto failed;
5626                         res = obj2ast_expr_context(tmp, &ctx, arena);
5627                         if (res != 0) goto failed;
5628                         Py_XDECREF(tmp);
5629                         tmp = NULL;
5630                 } else {
5631                         PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Name");
5632                         return 1;
5633                 }
5634                 *out = Name(id, ctx, lineno, col_offset, arena);
5635                 if (*out == NULL) goto failed;
5636                 return 0;
5637         }
5638         isinstance = PyObject_IsInstance(obj, (PyObject*)List_type);
5639         if (isinstance == -1) {
5640                 return 1;
5641         }
5642         if (isinstance) {
5643                 asdl_seq* elts;
5644                 expr_context_ty ctx;
5645
5646                 if (PyObject_HasAttrString(obj, "elts")) {
5647                         int res;
5648                         Py_ssize_t len;
5649                         Py_ssize_t i;
5650                         tmp = PyObject_GetAttrString(obj, "elts");
5651                         if (tmp == NULL) goto failed;
5652                         if (!PyList_Check(tmp)) {
5653                                 PyErr_Format(PyExc_TypeError, "List field \"elts\" must be a list, not a %.200s", tmp->ob_type->tp_name);
5654                                 goto failed;
5655                         }
5656                         len = PyList_GET_SIZE(tmp);
5657                         elts = asdl_seq_new(len, arena);
5658                         if (elts == NULL) goto failed;
5659                         for (i = 0; i < len; i++) {
5660                                 expr_ty value;
5661                                 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
5662                                 if (res != 0) goto failed;
5663                                 asdl_seq_SET(elts, i, value);
5664                         }
5665                         Py_XDECREF(tmp);
5666                         tmp = NULL;
5667                 } else {
5668                         PyErr_SetString(PyExc_TypeError, "required field \"elts\" missing from List");
5669                         return 1;
5670                 }
5671                 if (PyObject_HasAttrString(obj, "ctx")) {
5672                         int res;
5673                         tmp = PyObject_GetAttrString(obj, "ctx");
5674                         if (tmp == NULL) goto failed;
5675                         res = obj2ast_expr_context(tmp, &ctx, arena);
5676                         if (res != 0) goto failed;
5677                         Py_XDECREF(tmp);
5678                         tmp = NULL;
5679                 } else {
5680                         PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from List");
5681                         return 1;
5682                 }
5683                 *out = List(elts, ctx, lineno, col_offset, arena);
5684                 if (*out == NULL) goto failed;
5685                 return 0;
5686         }
5687         isinstance = PyObject_IsInstance(obj, (PyObject*)Tuple_type);
5688         if (isinstance == -1) {
5689                 return 1;
5690         }
5691         if (isinstance) {
5692                 asdl_seq* elts;
5693                 expr_context_ty ctx;
5694
5695                 if (PyObject_HasAttrString(obj, "elts")) {
5696                         int res;
5697                         Py_ssize_t len;
5698                         Py_ssize_t i;
5699                         tmp = PyObject_GetAttrString(obj, "elts");
5700                         if (tmp == NULL) goto failed;
5701                         if (!PyList_Check(tmp)) {
5702                                 PyErr_Format(PyExc_TypeError, "Tuple field \"elts\" must be a list, not a %.200s", tmp->ob_type->tp_name);
5703                                 goto failed;
5704                         }
5705                         len = PyList_GET_SIZE(tmp);
5706                         elts = asdl_seq_new(len, arena);
5707                         if (elts == NULL) goto failed;
5708                         for (i = 0; i < len; i++) {
5709                                 expr_ty value;
5710                                 res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
5711                                 if (res != 0) goto failed;
5712                                 asdl_seq_SET(elts, i, value);
5713                         }
5714                         Py_XDECREF(tmp);
5715                         tmp = NULL;
5716                 } else {
5717                         PyErr_SetString(PyExc_TypeError, "required field \"elts\" missing from Tuple");
5718                         return 1;
5719                 }
5720                 if (PyObject_HasAttrString(obj, "ctx")) {
5721                         int res;
5722                         tmp = PyObject_GetAttrString(obj, "ctx");
5723                         if (tmp == NULL) goto failed;
5724                         res = obj2ast_expr_context(tmp, &ctx, arena);
5725                         if (res != 0) goto failed;
5726                         Py_XDECREF(tmp);
5727                         tmp = NULL;
5728                 } else {
5729                         PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Tuple");
5730                         return 1;
5731                 }
5732                 *out = Tuple(elts, ctx, lineno, col_offset, arena);
5733                 if (*out == NULL) goto failed;
5734                 return 0;
5735         }
5736
5737         tmp = PyObject_Repr(obj);
5738         if (tmp == NULL) goto failed;
5739         PyErr_Format(PyExc_TypeError, "expected some sort of expr, but got %.400s", PyString_AS_STRING(tmp));
5740 failed:
5741         Py_XDECREF(tmp);
5742         return 1;
5743 }
5744
5745 int
5746 obj2ast_expr_context(PyObject* obj, expr_context_ty* out, PyArena* arena)
5747 {
5748         PyObject* tmp = NULL;
5749         int isinstance;
5750
5751         isinstance = PyObject_IsInstance(obj, (PyObject *)Load_type);
5752         if (isinstance == -1) {
5753                 return 1;
5754         }
5755         if (isinstance) {
5756                 *out = Load;
5757                 return 0;
5758         }
5759         isinstance = PyObject_IsInstance(obj, (PyObject *)Store_type);
5760         if (isinstance == -1) {
5761                 return 1;
5762         }
5763         if (isinstance) {
5764                 *out = Store;
5765                 return 0;
5766         }
5767         isinstance = PyObject_IsInstance(obj, (PyObject *)Del_type);
5768         if (isinstance == -1) {
5769                 return 1;
5770         }
5771         if (isinstance) {
5772                 *out = Del;
5773                 return 0;
5774         }
5775         isinstance = PyObject_IsInstance(obj, (PyObject *)AugLoad_type);
5776         if (isinstance == -1) {
5777                 return 1;
5778         }
5779         if (isinstance) {
5780                 *out = AugLoad;
5781                 return 0;
5782         }
5783         isinstance = PyObject_IsInstance(obj, (PyObject *)AugStore_type);
5784         if (isinstance == -1) {
5785                 return 1;
5786         }
5787         if (isinstance) {
5788                 *out = AugStore;
5789                 return 0;
5790         }
5791         isinstance = PyObject_IsInstance(obj, (PyObject *)Param_type);
5792         if (isinstance == -1) {
5793                 return 1;
5794         }
5795         if (isinstance) {
5796                 *out = Param;
5797                 return 0;
5798         }
5799
5800         tmp = PyObject_Repr(obj);
5801         if (tmp == NULL) goto failed;
5802         PyErr_Format(PyExc_TypeError, "expected some sort of expr_context, but got %.400s", PyString_AS_STRING(tmp));
5803 failed:
5804         Py_XDECREF(tmp);
5805         return 1;
5806 }
5807
5808 int
5809 obj2ast_slice(PyObject* obj, slice_ty* out, PyArena* arena)
5810 {
5811         PyObject* tmp = NULL;
5812         int isinstance;
5813
5814
5815         if (obj == Py_None) {
5816                 *out = NULL;
5817                 return 0;
5818         }
5819         isinstance = PyObject_IsInstance(obj, (PyObject*)Ellipsis_type);
5820         if (isinstance == -1) {
5821                 return 1;
5822         }
5823         if (isinstance) {
5824
5825                 *out = Ellipsis(arena);
5826                 if (*out == NULL) goto failed;
5827                 return 0;
5828         }
5829         isinstance = PyObject_IsInstance(obj, (PyObject*)Slice_type);
5830         if (isinstance == -1) {
5831                 return 1;
5832         }
5833         if (isinstance) {
5834                 expr_ty lower;
5835                 expr_ty upper;
5836                 expr_ty step;
5837
5838                 if (PyObject_HasAttrString(obj, "lower")) {
5839                         int res;
5840                         tmp = PyObject_GetAttrString(obj, "lower");
5841                         if (tmp == NULL) goto failed;
5842                         res = obj2ast_expr(tmp, &lower, arena);
5843                         if (res != 0) goto failed;
5844                         Py_XDECREF(tmp);
5845                         tmp = NULL;
5846                 } else {
5847                         lower = NULL;
5848                 }
5849                 if (PyObject_HasAttrString(obj, "upper")) {
5850                         int res;
5851                         tmp = PyObject_GetAttrString(obj, "upper");
5852                         if (tmp == NULL) goto failed;
5853                         res = obj2ast_expr(tmp, &upper, arena);
5854                         if (res != 0) goto failed;
5855                         Py_XDECREF(tmp);
5856                         tmp = NULL;
5857                 } else {
5858                         upper = NULL;
5859                 }
5860                 if (PyObject_HasAttrString(obj, "step")) {
5861                         int res;
5862                         tmp = PyObject_GetAttrString(obj, "step");
5863                         if (tmp == NULL) goto failed;
5864                         res = obj2ast_expr(tmp, &step, arena);
5865                         if (res != 0) goto failed;
5866                         Py_XDECREF(tmp);
5867                         tmp = NULL;
5868                 } else {
5869                         step = NULL;
5870                 }
5871                 *out = Slice(lower, upper, step, arena);
5872                 if (*out == NULL) goto failed;
5873                 return 0;
5874         }
5875         isinstance = PyObject_IsInstance(obj, (PyObject*)ExtSlice_type);
5876         if (isinstance == -1) {
5877                 return 1;
5878         }
5879         if (isinstance) {
5880                 asdl_seq* dims;
5881
5882                 if (PyObject_HasAttrString(obj, "dims")) {
5883                         int res;
5884                         Py_ssize_t len;
5885                         Py_ssize_t i;
5886                         tmp = PyObject_GetAttrString(obj, "dims");
5887                         if (tmp == NULL) goto failed;
5888                         if (!PyList_Check(tmp)) {
5889                                 PyErr_Format(PyExc_TypeError, "ExtSlice field \"dims\" must be a list, not a %.200s", tmp->ob_type->tp_name);
5890                                 goto failed;
5891                         }
5892                         len = PyList_GET_SIZE(tmp);
5893                         dims = asdl_seq_new(len, arena);
5894                         if (dims == NULL) goto failed;
5895                         for (i = 0; i < len; i++) {
5896                                 slice_ty value;
5897                                 res = obj2ast_slice(PyList_GET_ITEM(tmp, i), &value, arena);
5898                                 if (res != 0) goto failed;
5899                                 asdl_seq_SET(dims, i, value);
5900                         }
5901                         Py_XDECREF(tmp);
5902                         tmp = NULL;
5903                 } else {
5904                         PyErr_SetString(PyExc_TypeError, "required field \"dims\" missing from ExtSlice");
5905                         return 1;
5906                 }
5907                 *out = ExtSlice(dims, arena);
5908                 if (*out == NULL) goto failed;
5909                 return 0;
5910         }
5911         isinstance = PyObject_IsInstance(obj, (PyObject*)Index_type);
5912         if (isinstance == -1) {
5913                 return 1;
5914         }
5915         if (isinstance) {
5916                 expr_ty value;
5917
5918                 if (PyObject_HasAttrString(obj, "value")) {
5919                         int res;
5920                         tmp = PyObject_GetAttrString(obj, "value");
5921                         if (tmp == NULL) goto failed;
5922                         res = obj2ast_expr(tmp, &value, arena);
5923                         if (res != 0) goto failed;
5924                         Py_XDECREF(tmp);
5925                         tmp = NULL;
5926                 } else {
5927                         PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Index");
5928                         return 1;
5929                 }
5930                 *out = Index(value, arena);
5931                 if (*out == NULL) goto failed;
5932                 return 0;
5933         }
5934
5935         tmp = PyObject_Repr(obj);
5936         if (tmp == NULL) goto failed;
5937         PyErr_Format(PyExc_TypeError, "expected some sort of slice, but got %.400s", PyString_AS_STRING(tmp));
5938 failed:
5939         Py_XDECREF(tmp);
5940         return 1;
5941 }
5942
5943 int
5944 obj2ast_boolop(PyObject* obj, boolop_ty* out, PyArena* arena)
5945 {
5946         PyObject* tmp = NULL;
5947         int isinstance;
5948
5949         isinstance = PyObject_IsInstance(obj, (PyObject *)And_type);
5950         if (isinstance == -1) {
5951                 return 1;
5952         }
5953         if (isinstance) {
5954                 *out = And;
5955                 return 0;
5956         }
5957         isinstance = PyObject_IsInstance(obj, (PyObject *)Or_type);
5958         if (isinstance == -1) {
5959                 return 1;
5960         }
5961         if (isinstance) {
5962                 *out = Or;
5963                 return 0;
5964         }
5965
5966         tmp = PyObject_Repr(obj);
5967         if (tmp == NULL) goto failed;
5968         PyErr_Format(PyExc_TypeError, "expected some sort of boolop, but got %.400s", PyString_AS_STRING(tmp));
5969 failed:
5970         Py_XDECREF(tmp);
5971         return 1;
5972 }
5973
5974 int
5975 obj2ast_operator(PyObject* obj, operator_ty* out, PyArena* arena)
5976 {
5977         PyObject* tmp = NULL;
5978         int isinstance;
5979
5980         isinstance = PyObject_IsInstance(obj, (PyObject *)Add_type);
5981         if (isinstance == -1) {
5982                 return 1;
5983         }
5984         if (isinstance) {
5985                 *out = Add;
5986                 return 0;
5987         }
5988         isinstance = PyObject_IsInstance(obj, (PyObject *)Sub_type);
5989         if (isinstance == -1) {
5990                 return 1;
5991         }
5992         if (isinstance) {
5993                 *out = Sub;
5994                 return 0;
5995         }
5996         isinstance = PyObject_IsInstance(obj, (PyObject *)Mult_type);
5997         if (isinstance == -1) {
5998                 return 1;
5999         }
6000         if (isinstance) {
6001                 *out = Mult;
6002                 return 0;
6003         }
6004         isinstance = PyObject_IsInstance(obj, (PyObject *)Div_type);
6005         if (isinstance == -1) {
6006                 return 1;
6007         }
6008         if (isinstance) {
6009                 *out = Div;
6010                 return 0;
6011         }
6012         isinstance = PyObject_IsInstance(obj, (PyObject *)Mod_type);
6013         if (isinstance == -1) {
6014                 return 1;
6015         }
6016         if (isinstance) {
6017                 *out = Mod;
6018                 return 0;
6019         }
6020         isinstance = PyObject_IsInstance(obj, (PyObject *)Pow_type);
6021         if (isinstance == -1) {
6022                 return 1;
6023         }
6024         if (isinstance) {
6025                 *out = Pow;
6026                 return 0;
6027         }
6028         isinstance = PyObject_IsInstance(obj, (PyObject *)LShift_type);
6029         if (isinstance == -1) {
6030                 return 1;
6031         }
6032         if (isinstance) {
6033                 *out = LShift;
6034                 return 0;
6035         }
6036         isinstance = PyObject_IsInstance(obj, (PyObject *)RShift_type);
6037         if (isinstance == -1) {
6038                 return 1;
6039         }
6040         if (isinstance) {
6041                 *out = RShift;
6042                 return 0;
6043         }
6044         isinstance = PyObject_IsInstance(obj, (PyObject *)BitOr_type);
6045         if (isinstance == -1) {
6046                 return 1;
6047         }
6048         if (isinstance) {
6049                 *out = BitOr;
6050                 return 0;
6051         }
6052         isinstance = PyObject_IsInstance(obj, (PyObject *)BitXor_type);
6053         if (isinstance == -1) {
6054                 return 1;
6055         }
6056         if (isinstance) {
6057                 *out = BitXor;
6058                 return 0;
6059         }
6060         isinstance = PyObject_IsInstance(obj, (PyObject *)BitAnd_type);
6061         if (isinstance == -1) {
6062                 return 1;
6063         }
6064         if (isinstance) {
6065                 *out = BitAnd;
6066                 return 0;
6067         }
6068         isinstance = PyObject_IsInstance(obj, (PyObject *)FloorDiv_type);
6069         if (isinstance == -1) {
6070                 return 1;
6071         }
6072         if (isinstance) {
6073                 *out = FloorDiv;
6074                 return 0;
6075         }
6076
6077         tmp = PyObject_Repr(obj);
6078         if (tmp == NULL) goto failed;
6079         PyErr_Format(PyExc_TypeError, "expected some sort of operator, but got %.400s", PyString_AS_STRING(tmp));
6080 failed:
6081         Py_XDECREF(tmp);
6082         return 1;
6083 }
6084
6085 int
6086 obj2ast_unaryop(PyObject* obj, unaryop_ty* out, PyArena* arena)
6087 {
6088         PyObject* tmp = NULL;
6089         int isinstance;
6090
6091         isinstance = PyObject_IsInstance(obj, (PyObject *)Invert_type);
6092         if (isinstance == -1) {
6093                 return 1;
6094         }
6095         if (isinstance) {
6096                 *out = Invert;
6097                 return 0;
6098         }
6099         isinstance = PyObject_IsInstance(obj, (PyObject *)Not_type);
6100         if (isinstance == -1) {
6101                 return 1;
6102         }
6103         if (isinstance) {
6104                 *out = Not;
6105                 return 0;
6106         }
6107         isinstance = PyObject_IsInstance(obj, (PyObject *)UAdd_type);
6108         if (isinstance == -1) {
6109                 return 1;
6110         }
6111         if (isinstance) {
6112                 *out = UAdd;
6113                 return 0;
6114         }
6115         isinstance = PyObject_IsInstance(obj, (PyObject *)USub_type);
6116         if (isinstance == -1) {
6117                 return 1;
6118         }
6119         if (isinstance) {
6120                 *out = USub;
6121                 return 0;
6122         }
6123
6124         tmp = PyObject_Repr(obj);
6125         if (tmp == NULL) goto failed;
6126         PyErr_Format(PyExc_TypeError, "expected some sort of unaryop, but got %.400s", PyString_AS_STRING(tmp));
6127 failed:
6128         Py_XDECREF(tmp);
6129         return 1;
6130 }
6131
6132 int
6133 obj2ast_cmpop(PyObject* obj, cmpop_ty* out, PyArena* arena)
6134 {
6135         PyObject* tmp = NULL;
6136         int isinstance;
6137
6138         isinstance = PyObject_IsInstance(obj, (PyObject *)Eq_type);
6139         if (isinstance == -1) {
6140                 return 1;
6141         }
6142         if (isinstance) {
6143                 *out = Eq;
6144                 return 0;
6145         }
6146         isinstance = PyObject_IsInstance(obj, (PyObject *)NotEq_type);
6147         if (isinstance == -1) {
6148                 return 1;
6149         }
6150         if (isinstance) {
6151                 *out = NotEq;
6152                 return 0;
6153         }
6154         isinstance = PyObject_IsInstance(obj, (PyObject *)Lt_type);
6155         if (isinstance == -1) {
6156                 return 1;
6157         }
6158         if (isinstance) {
6159                 *out = Lt;
6160                 return 0;
6161         }
6162         isinstance = PyObject_IsInstance(obj, (PyObject *)LtE_type);
6163         if (isinstance == -1) {
6164                 return 1;
6165         }
6166         if (isinstance) {
6167                 *out = LtE;
6168                 return 0;
6169         }
6170         isinstance = PyObject_IsInstance(obj, (PyObject *)Gt_type);
6171         if (isinstance == -1) {
6172                 return 1;
6173         }
6174         if (isinstance) {
6175                 *out = Gt;
6176                 return 0;
6177         }
6178         isinstance = PyObject_IsInstance(obj, (PyObject *)GtE_type);
6179         if (isinstance == -1) {
6180                 return 1;
6181         }
6182         if (isinstance) {
6183                 *out = GtE;
6184                 return 0;
6185         }
6186         isinstance = PyObject_IsInstance(obj, (PyObject *)Is_type);
6187         if (isinstance == -1) {
6188                 return 1;
6189         }
6190         if (isinstance) {
6191                 *out = Is;
6192                 return 0;
6193         }
6194         isinstance = PyObject_IsInstance(obj, (PyObject *)IsNot_type);
6195         if (isinstance == -1) {
6196                 return 1;
6197         }
6198         if (isinstance) {
6199                 *out = IsNot;
6200                 return 0;
6201         }
6202         isinstance = PyObject_IsInstance(obj, (PyObject *)In_type);
6203         if (isinstance == -1) {
6204                 return 1;
6205         }
6206         if (isinstance) {
6207                 *out = In;
6208                 return 0;
6209         }
6210         isinstance = PyObject_IsInstance(obj, (PyObject *)NotIn_type);
6211         if (isinstance == -1) {
6212                 return 1;
6213         }
6214         if (isinstance) {
6215                 *out = NotIn;
6216                 return 0;
6217         }
6218
6219         tmp = PyObject_Repr(obj);
6220         if (tmp == NULL) goto failed;
6221         PyErr_Format(PyExc_TypeError, "expected some sort of cmpop, but got %.400s", PyString_AS_STRING(tmp));
6222 failed:
6223         Py_XDECREF(tmp);
6224         return 1;
6225 }
6226
6227 int
6228 obj2ast_comprehension(PyObject* obj, comprehension_ty* out, PyArena* arena)
6229 {
6230         PyObject* tmp = NULL;
6231         expr_ty target;
6232         expr_ty iter;
6233         asdl_seq* ifs;
6234
6235         if (PyObject_HasAttrString(obj, "target")) {
6236                 int res;
6237                 tmp = PyObject_GetAttrString(obj, "target");
6238                 if (tmp == NULL) goto failed;
6239                 res = obj2ast_expr(tmp, &target, arena);
6240                 if (res != 0) goto failed;
6241                 Py_XDECREF(tmp);
6242                 tmp = NULL;
6243         } else {
6244                 PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from comprehension");
6245                 return 1;
6246         }
6247         if (PyObject_HasAttrString(obj, "iter")) {
6248                 int res;
6249                 tmp = PyObject_GetAttrString(obj, "iter");
6250                 if (tmp == NULL) goto failed;
6251                 res = obj2ast_expr(tmp, &iter, arena);
6252                 if (res != 0) goto failed;
6253                 Py_XDECREF(tmp);
6254                 tmp = NULL;
6255         } else {
6256                 PyErr_SetString(PyExc_TypeError, "required field \"iter\" missing from comprehension");
6257                 return 1;
6258         }
6259         if (PyObject_HasAttrString(obj, "ifs")) {
6260                 int res;
6261                 Py_ssize_t len;
6262                 Py_ssize_t i;
6263                 tmp = PyObject_GetAttrString(obj, "ifs");
6264                 if (tmp == NULL) goto failed;
6265                 if (!PyList_Check(tmp)) {
6266                         PyErr_Format(PyExc_TypeError, "comprehension field \"ifs\" must be a list, not a %.200s", tmp->ob_type->tp_name);
6267                         goto failed;
6268                 }
6269                 len = PyList_GET_SIZE(tmp);
6270                 ifs = asdl_seq_new(len, arena);
6271                 if (ifs == NULL) goto failed;
6272                 for (i = 0; i < len; i++) {
6273                         expr_ty value;
6274                         res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
6275                         if (res != 0) goto failed;
6276                         asdl_seq_SET(ifs, i, value);
6277                 }
6278                 Py_XDECREF(tmp);
6279                 tmp = NULL;
6280         } else {
6281                 PyErr_SetString(PyExc_TypeError, "required field \"ifs\" missing from comprehension");
6282                 return 1;
6283         }
6284         *out = comprehension(target, iter, ifs, arena);
6285         return 0;
6286 failed:
6287         Py_XDECREF(tmp);
6288         return 1;
6289 }
6290
6291 int
6292 obj2ast_excepthandler(PyObject* obj, excepthandler_ty* out, PyArena* arena)
6293 {
6294         PyObject* tmp = NULL;
6295         int isinstance;
6296
6297         int lineno;
6298         int col_offset;
6299
6300         if (obj == Py_None) {
6301                 *out = NULL;
6302                 return 0;
6303         }
6304         if (PyObject_HasAttrString(obj, "lineno")) {
6305                 int res;
6306                 tmp = PyObject_GetAttrString(obj, "lineno");
6307                 if (tmp == NULL) goto failed;
6308                 res = obj2ast_int(tmp, &lineno, arena);
6309                 if (res != 0) goto failed;
6310                 Py_XDECREF(tmp);
6311                 tmp = NULL;
6312         } else {
6313                 PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from excepthandler");
6314                 return 1;
6315         }
6316         if (PyObject_HasAttrString(obj, "col_offset")) {
6317                 int res;
6318                 tmp = PyObject_GetAttrString(obj, "col_offset");
6319                 if (tmp == NULL) goto failed;
6320                 res = obj2ast_int(tmp, &col_offset, arena);
6321                 if (res != 0) goto failed;
6322                 Py_XDECREF(tmp);
6323                 tmp = NULL;
6324         } else {
6325                 PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from excepthandler");
6326                 return 1;
6327         }
6328         isinstance = PyObject_IsInstance(obj, (PyObject*)ExceptHandler_type);
6329         if (isinstance == -1) {
6330                 return 1;
6331         }
6332         if (isinstance) {
6333                 expr_ty type;
6334                 expr_ty name;
6335                 asdl_seq* body;
6336
6337                 if (PyObject_HasAttrString(obj, "type")) {
6338                         int res;
6339                         tmp = PyObject_GetAttrString(obj, "type");
6340                         if (tmp == NULL) goto failed;
6341                         res = obj2ast_expr(tmp, &type, arena);
6342                         if (res != 0) goto failed;
6343                         Py_XDECREF(tmp);
6344                         tmp = NULL;
6345                 } else {
6346                         type = NULL;
6347                 }
6348                 if (PyObject_HasAttrString(obj, "name")) {
6349                         int res;
6350                         tmp = PyObject_GetAttrString(obj, "name");
6351                         if (tmp == NULL) goto failed;
6352                         res = obj2ast_expr(tmp, &name, arena);
6353                         if (res != 0) goto failed;
6354                         Py_XDECREF(tmp);
6355                         tmp = NULL;
6356                 } else {
6357                         name = NULL;
6358                 }
6359                 if (PyObject_HasAttrString(obj, "body")) {
6360                         int res;
6361                         Py_ssize_t len;
6362                         Py_ssize_t i;
6363                         tmp = PyObject_GetAttrString(obj, "body");
6364                         if (tmp == NULL) goto failed;
6365                         if (!PyList_Check(tmp)) {
6366                                 PyErr_Format(PyExc_TypeError, "ExceptHandler field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name);
6367                                 goto failed;
6368                         }
6369                         len = PyList_GET_SIZE(tmp);
6370                         body = asdl_seq_new(len, arena);
6371                         if (body == NULL) goto failed;
6372                         for (i = 0; i < len; i++) {
6373                                 stmt_ty value;
6374                                 res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena);
6375                                 if (res != 0) goto failed;
6376                                 asdl_seq_SET(body, i, value);
6377                         }
6378                         Py_XDECREF(tmp);
6379                         tmp = NULL;
6380                 } else {
6381                         PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from ExceptHandler");
6382                         return 1;
6383                 }
6384                 *out = ExceptHandler(type, name, body, lineno, col_offset,
6385                                      arena);
6386                 if (*out == NULL) goto failed;
6387                 return 0;
6388         }
6389
6390         tmp = PyObject_Repr(obj);
6391         if (tmp == NULL) goto failed;
6392         PyErr_Format(PyExc_TypeError, "expected some sort of excepthandler, but got %.400s", PyString_AS_STRING(tmp));
6393 failed:
6394         Py_XDECREF(tmp);
6395         return 1;
6396 }
6397
6398 int
6399 obj2ast_arguments(PyObject* obj, arguments_ty* out, PyArena* arena)
6400 {
6401         PyObject* tmp = NULL;
6402         asdl_seq* args;
6403         identifier vararg;
6404         identifier kwarg;
6405         asdl_seq* defaults;
6406
6407         if (PyObject_HasAttrString(obj, "args")) {
6408                 int res;
6409                 Py_ssize_t len;
6410                 Py_ssize_t i;
6411                 tmp = PyObject_GetAttrString(obj, "args");
6412                 if (tmp == NULL) goto failed;
6413                 if (!PyList_Check(tmp)) {
6414                         PyErr_Format(PyExc_TypeError, "arguments field \"args\" must be a list, not a %.200s", tmp->ob_type->tp_name);
6415                         goto failed;
6416                 }
6417                 len = PyList_GET_SIZE(tmp);
6418                 args = asdl_seq_new(len, arena);
6419                 if (args == NULL) goto failed;
6420                 for (i = 0; i < len; i++) {
6421                         expr_ty value;
6422                         res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
6423                         if (res != 0) goto failed;
6424                         asdl_seq_SET(args, i, value);
6425                 }
6426                 Py_XDECREF(tmp);
6427                 tmp = NULL;
6428         } else {
6429                 PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from arguments");
6430                 return 1;
6431         }
6432         if (PyObject_HasAttrString(obj, "vararg")) {
6433                 int res;
6434                 tmp = PyObject_GetAttrString(obj, "vararg");
6435                 if (tmp == NULL) goto failed;
6436                 res = obj2ast_identifier(tmp, &vararg, arena);
6437                 if (res != 0) goto failed;
6438                 Py_XDECREF(tmp);
6439                 tmp = NULL;
6440         } else {
6441                 vararg = NULL;
6442         }
6443         if (PyObject_HasAttrString(obj, "kwarg")) {
6444                 int res;
6445                 tmp = PyObject_GetAttrString(obj, "kwarg");
6446                 if (tmp == NULL) goto failed;
6447                 res = obj2ast_identifier(tmp, &kwarg, arena);
6448                 if (res != 0) goto failed;
6449                 Py_XDECREF(tmp);
6450                 tmp = NULL;
6451         } else {
6452                 kwarg = NULL;
6453         }
6454         if (PyObject_HasAttrString(obj, "defaults")) {
6455                 int res;
6456                 Py_ssize_t len;
6457                 Py_ssize_t i;
6458                 tmp = PyObject_GetAttrString(obj, "defaults");
6459                 if (tmp == NULL) goto failed;
6460                 if (!PyList_Check(tmp)) {
6461                         PyErr_Format(PyExc_TypeError, "arguments field \"defaults\" must be a list, not a %.200s", tmp->ob_type->tp_name);
6462                         goto failed;
6463                 }
6464                 len = PyList_GET_SIZE(tmp);
6465                 defaults = asdl_seq_new(len, arena);
6466                 if (defaults == NULL) goto failed;
6467                 for (i = 0; i < len; i++) {
6468                         expr_ty value;
6469                         res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena);
6470                         if (res != 0) goto failed;
6471                         asdl_seq_SET(defaults, i, value);
6472                 }
6473                 Py_XDECREF(tmp);
6474                 tmp = NULL;
6475         } else {
6476                 PyErr_SetString(PyExc_TypeError, "required field \"defaults\" missing from arguments");
6477                 return 1;
6478         }
6479         *out = arguments(args, vararg, kwarg, defaults, arena);
6480         return 0;
6481 failed:
6482         Py_XDECREF(tmp);
6483         return 1;
6484 }
6485
6486 int
6487 obj2ast_keyword(PyObject* obj, keyword_ty* out, PyArena* arena)
6488 {
6489         PyObject* tmp = NULL;
6490         identifier arg;
6491         expr_ty value;
6492
6493         if (PyObject_HasAttrString(obj, "arg")) {
6494                 int res;
6495                 tmp = PyObject_GetAttrString(obj, "arg");
6496                 if (tmp == NULL) goto failed;
6497                 res = obj2ast_identifier(tmp, &arg, arena);
6498                 if (res != 0) goto failed;
6499                 Py_XDECREF(tmp);
6500                 tmp = NULL;
6501         } else {
6502                 PyErr_SetString(PyExc_TypeError, "required field \"arg\" missing from keyword");
6503                 return 1;
6504         }
6505         if (PyObject_HasAttrString(obj, "value")) {
6506                 int res;
6507                 tmp = PyObject_GetAttrString(obj, "value");
6508                 if (tmp == NULL) goto failed;
6509                 res = obj2ast_expr(tmp, &value, arena);
6510                 if (res != 0) goto failed;
6511                 Py_XDECREF(tmp);
6512                 tmp = NULL;
6513         } else {
6514                 PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from keyword");
6515                 return 1;
6516         }
6517         *out = keyword(arg, value, arena);
6518         return 0;
6519 failed:
6520         Py_XDECREF(tmp);
6521         return 1;
6522 }
6523
6524 int
6525 obj2ast_alias(PyObject* obj, alias_ty* out, PyArena* arena)
6526 {
6527         PyObject* tmp = NULL;
6528         identifier name;
6529         identifier asname;
6530
6531         if (PyObject_HasAttrString(obj, "name")) {
6532                 int res;
6533                 tmp = PyObject_GetAttrString(obj, "name");
6534                 if (tmp == NULL) goto failed;
6535                 res = obj2ast_identifier(tmp, &name, arena);
6536                 if (res != 0) goto failed;
6537                 Py_XDECREF(tmp);
6538                 tmp = NULL;
6539         } else {
6540                 PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from alias");
6541                 return 1;
6542         }
6543         if (PyObject_HasAttrString(obj, "asname")) {
6544                 int res;
6545                 tmp = PyObject_GetAttrString(obj, "asname");
6546                 if (tmp == NULL) goto failed;
6547                 res = obj2ast_identifier(tmp, &asname, arena);
6548                 if (res != 0) goto failed;
6549                 Py_XDECREF(tmp);
6550                 tmp = NULL;
6551         } else {
6552                 asname = NULL;
6553         }
6554         *out = alias(name, asname, arena);
6555         return 0;
6556 failed:
6557         Py_XDECREF(tmp);
6558         return 1;
6559 }
6560
6561
6562 PyMODINIT_FUNC
6563 init_ast(void)
6564 {
6565         PyObject *m, *d;
6566         if (!init_types()) return;
6567         m = Py_InitModule3("_ast", NULL, NULL);
6568         if (!m) return;
6569         d = PyModule_GetDict(m);
6570         if (PyDict_SetItemString(d, "AST", (PyObject*)&AST_type) < 0) return;
6571         if (PyModule_AddIntConstant(m, "PyCF_ONLY_AST", PyCF_ONLY_AST) < 0)
6572                 return;
6573         if (PyModule_AddStringConstant(m, "__version__", "82160") < 0)
6574                 return;
6575         if (PyDict_SetItemString(d, "mod", (PyObject*)mod_type) < 0) return;
6576         if (PyDict_SetItemString(d, "Module", (PyObject*)Module_type) < 0)
6577             return;
6578         if (PyDict_SetItemString(d, "Interactive", (PyObject*)Interactive_type)
6579             < 0) return;
6580         if (PyDict_SetItemString(d, "Expression", (PyObject*)Expression_type) <
6581             0) return;
6582         if (PyDict_SetItemString(d, "Suite", (PyObject*)Suite_type) < 0) return;
6583         if (PyDict_SetItemString(d, "stmt", (PyObject*)stmt_type) < 0) return;
6584         if (PyDict_SetItemString(d, "FunctionDef", (PyObject*)FunctionDef_type)
6585             < 0) return;
6586         if (PyDict_SetItemString(d, "ClassDef", (PyObject*)ClassDef_type) < 0)
6587             return;
6588         if (PyDict_SetItemString(d, "Return", (PyObject*)Return_type) < 0)
6589             return;
6590         if (PyDict_SetItemString(d, "Delete", (PyObject*)Delete_type) < 0)
6591             return;
6592         if (PyDict_SetItemString(d, "Assign", (PyObject*)Assign_type) < 0)
6593             return;
6594         if (PyDict_SetItemString(d, "AugAssign", (PyObject*)AugAssign_type) <
6595             0) return;
6596         if (PyDict_SetItemString(d, "Print", (PyObject*)Print_type) < 0) return;
6597         if (PyDict_SetItemString(d, "For", (PyObject*)For_type) < 0) return;
6598         if (PyDict_SetItemString(d, "While", (PyObject*)While_type) < 0) return;
6599         if (PyDict_SetItemString(d, "If", (PyObject*)If_type) < 0) return;
6600         if (PyDict_SetItemString(d, "With", (PyObject*)With_type) < 0) return;
6601         if (PyDict_SetItemString(d, "Raise", (PyObject*)Raise_type) < 0) return;
6602         if (PyDict_SetItemString(d, "TryExcept", (PyObject*)TryExcept_type) <
6603             0) return;
6604         if (PyDict_SetItemString(d, "TryFinally", (PyObject*)TryFinally_type) <
6605             0) return;
6606         if (PyDict_SetItemString(d, "Assert", (PyObject*)Assert_type) < 0)
6607             return;
6608         if (PyDict_SetItemString(d, "Import", (PyObject*)Import_type) < 0)
6609             return;
6610         if (PyDict_SetItemString(d, "ImportFrom", (PyObject*)ImportFrom_type) <
6611             0) return;
6612         if (PyDict_SetItemString(d, "Exec", (PyObject*)Exec_type) < 0) return;
6613         if (PyDict_SetItemString(d, "Global", (PyObject*)Global_type) < 0)
6614             return;
6615         if (PyDict_SetItemString(d, "Expr", (PyObject*)Expr_type) < 0) return;
6616         if (PyDict_SetItemString(d, "Pass", (PyObject*)Pass_type) < 0) return;
6617         if (PyDict_SetItemString(d, "Break", (PyObject*)Break_type) < 0) return;
6618         if (PyDict_SetItemString(d, "Continue", (PyObject*)Continue_type) < 0)
6619             return;
6620         if (PyDict_SetItemString(d, "expr", (PyObject*)expr_type) < 0) return;
6621         if (PyDict_SetItemString(d, "BoolOp", (PyObject*)BoolOp_type) < 0)
6622             return;
6623         if (PyDict_SetItemString(d, "BinOp", (PyObject*)BinOp_type) < 0) return;
6624         if (PyDict_SetItemString(d, "UnaryOp", (PyObject*)UnaryOp_type) < 0)
6625             return;
6626         if (PyDict_SetItemString(d, "Lambda", (PyObject*)Lambda_type) < 0)
6627             return;
6628         if (PyDict_SetItemString(d, "IfExp", (PyObject*)IfExp_type) < 0) return;
6629         if (PyDict_SetItemString(d, "Dict", (PyObject*)Dict_type) < 0) return;
6630         if (PyDict_SetItemString(d, "Set", (PyObject*)Set_type) < 0) return;
6631         if (PyDict_SetItemString(d, "ListComp", (PyObject*)ListComp_type) < 0)
6632             return;
6633         if (PyDict_SetItemString(d, "SetComp", (PyObject*)SetComp_type) < 0)
6634             return;
6635         if (PyDict_SetItemString(d, "DictComp", (PyObject*)DictComp_type) < 0)
6636             return;
6637         if (PyDict_SetItemString(d, "GeneratorExp",
6638             (PyObject*)GeneratorExp_type) < 0) return;
6639         if (PyDict_SetItemString(d, "Yield", (PyObject*)Yield_type) < 0) return;
6640         if (PyDict_SetItemString(d, "Compare", (PyObject*)Compare_type) < 0)
6641             return;
6642         if (PyDict_SetItemString(d, "Call", (PyObject*)Call_type) < 0) return;
6643         if (PyDict_SetItemString(d, "Repr", (PyObject*)Repr_type) < 0) return;
6644         if (PyDict_SetItemString(d, "Num", (PyObject*)Num_type) < 0) return;
6645         if (PyDict_SetItemString(d, "Str", (PyObject*)Str_type) < 0) return;
6646         if (PyDict_SetItemString(d, "Attribute", (PyObject*)Attribute_type) <
6647             0) return;
6648         if (PyDict_SetItemString(d, "Subscript", (PyObject*)Subscript_type) <
6649             0) return;
6650         if (PyDict_SetItemString(d, "Name", (PyObject*)Name_type) < 0) return;
6651         if (PyDict_SetItemString(d, "List", (PyObject*)List_type) < 0) return;
6652         if (PyDict_SetItemString(d, "Tuple", (PyObject*)Tuple_type) < 0) return;
6653         if (PyDict_SetItemString(d, "expr_context",
6654             (PyObject*)expr_context_type) < 0) return;
6655         if (PyDict_SetItemString(d, "Load", (PyObject*)Load_type) < 0) return;
6656         if (PyDict_SetItemString(d, "Store", (PyObject*)Store_type) < 0) return;
6657         if (PyDict_SetItemString(d, "Del", (PyObject*)Del_type) < 0) return;
6658         if (PyDict_SetItemString(d, "AugLoad", (PyObject*)AugLoad_type) < 0)
6659             return;
6660         if (PyDict_SetItemString(d, "AugStore", (PyObject*)AugStore_type) < 0)
6661             return;
6662         if (PyDict_SetItemString(d, "Param", (PyObject*)Param_type) < 0) return;
6663         if (PyDict_SetItemString(d, "slice", (PyObject*)slice_type) < 0) return;
6664         if (PyDict_SetItemString(d, "Ellipsis", (PyObject*)Ellipsis_type) < 0)
6665             return;
6666         if (PyDict_SetItemString(d, "Slice", (PyObject*)Slice_type) < 0) return;
6667         if (PyDict_SetItemString(d, "ExtSlice", (PyObject*)ExtSlice_type) < 0)
6668             return;
6669         if (PyDict_SetItemString(d, "Index", (PyObject*)Index_type) < 0) return;
6670         if (PyDict_SetItemString(d, "boolop", (PyObject*)boolop_type) < 0)
6671             return;
6672         if (PyDict_SetItemString(d, "And", (PyObject*)And_type) < 0) return;
6673         if (PyDict_SetItemString(d, "Or", (PyObject*)Or_type) < 0) return;
6674         if (PyDict_SetItemString(d, "operator", (PyObject*)operator_type) < 0)
6675             return;
6676         if (PyDict_SetItemString(d, "Add", (PyObject*)Add_type) < 0) return;
6677         if (PyDict_SetItemString(d, "Sub", (PyObject*)Sub_type) < 0) return;
6678         if (PyDict_SetItemString(d, "Mult", (PyObject*)Mult_type) < 0) return;
6679         if (PyDict_SetItemString(d, "Div", (PyObject*)Div_type) < 0) return;
6680         if (PyDict_SetItemString(d, "Mod", (PyObject*)Mod_type) < 0) return;
6681         if (PyDict_SetItemString(d, "Pow", (PyObject*)Pow_type) < 0) return;
6682         if (PyDict_SetItemString(d, "LShift", (PyObject*)LShift_type) < 0)
6683             return;
6684         if (PyDict_SetItemString(d, "RShift", (PyObject*)RShift_type) < 0)
6685             return;
6686         if (PyDict_SetItemString(d, "BitOr", (PyObject*)BitOr_type) < 0) return;
6687         if (PyDict_SetItemString(d, "BitXor", (PyObject*)BitXor_type) < 0)
6688             return;
6689         if (PyDict_SetItemString(d, "BitAnd", (PyObject*)BitAnd_type) < 0)
6690             return;
6691         if (PyDict_SetItemString(d, "FloorDiv", (PyObject*)FloorDiv_type) < 0)
6692             return;
6693         if (PyDict_SetItemString(d, "unaryop", (PyObject*)unaryop_type) < 0)
6694             return;
6695         if (PyDict_SetItemString(d, "Invert", (PyObject*)Invert_type) < 0)
6696             return;
6697         if (PyDict_SetItemString(d, "Not", (PyObject*)Not_type) < 0) return;
6698         if (PyDict_SetItemString(d, "UAdd", (PyObject*)UAdd_type) < 0) return;
6699         if (PyDict_SetItemString(d, "USub", (PyObject*)USub_type) < 0) return;
6700         if (PyDict_SetItemString(d, "cmpop", (PyObject*)cmpop_type) < 0) return;
6701         if (PyDict_SetItemString(d, "Eq", (PyObject*)Eq_type) < 0) return;
6702         if (PyDict_SetItemString(d, "NotEq", (PyObject*)NotEq_type) < 0) return;
6703         if (PyDict_SetItemString(d, "Lt", (PyObject*)Lt_type) < 0) return;
6704         if (PyDict_SetItemString(d, "LtE", (PyObject*)LtE_type) < 0) return;
6705         if (PyDict_SetItemString(d, "Gt", (PyObject*)Gt_type) < 0) return;
6706         if (PyDict_SetItemString(d, "GtE", (PyObject*)GtE_type) < 0) return;
6707         if (PyDict_SetItemString(d, "Is", (PyObject*)Is_type) < 0) return;
6708         if (PyDict_SetItemString(d, "IsNot", (PyObject*)IsNot_type) < 0) return;
6709         if (PyDict_SetItemString(d, "In", (PyObject*)In_type) < 0) return;
6710         if (PyDict_SetItemString(d, "NotIn", (PyObject*)NotIn_type) < 0) return;
6711         if (PyDict_SetItemString(d, "comprehension",
6712             (PyObject*)comprehension_type) < 0) return;
6713         if (PyDict_SetItemString(d, "excepthandler",
6714             (PyObject*)excepthandler_type) < 0) return;
6715         if (PyDict_SetItemString(d, "ExceptHandler",
6716             (PyObject*)ExceptHandler_type) < 0) return;
6717         if (PyDict_SetItemString(d, "arguments", (PyObject*)arguments_type) <
6718             0) return;
6719         if (PyDict_SetItemString(d, "keyword", (PyObject*)keyword_type) < 0)
6720             return;
6721         if (PyDict_SetItemString(d, "alias", (PyObject*)alias_type) < 0) return;
6722 }
6723
6724
6725 PyObject* PyAST_mod2obj(mod_ty t)
6726 {
6727     init_types();
6728     return ast2obj_mod(t);
6729 }
6730
6731 /* mode is 0 for "exec", 1 for "eval" and 2 for "single" input */
6732 mod_ty PyAST_obj2mod(PyObject* ast, PyArena* arena, int mode)
6733 {
6734     mod_ty res;
6735     PyObject *req_type[] = {(PyObject*)Module_type, (PyObject*)Expression_type,
6736                             (PyObject*)Interactive_type};
6737     char *req_name[] = {"Module", "Expression", "Interactive"};
6738     int isinstance;
6739     assert(0 <= mode && mode <= 2);
6740
6741     init_types();
6742
6743     isinstance = PyObject_IsInstance(ast, req_type[mode]);
6744     if (isinstance == -1)
6745         return NULL;
6746     if (!isinstance) {
6747         PyErr_Format(PyExc_TypeError, "expected %s node, got %.400s",
6748                      req_name[mode], Py_TYPE(ast)->tp_name);
6749         return NULL;
6750     }
6751     if (obj2ast_mod(ast, &res, arena) != 0)
6752         return NULL;
6753     else
6754         return res;
6755 }
6756
6757 int PyAST_Check(PyObject* obj)
6758 {
6759     init_types();
6760     return PyObject_IsInstance(obj, (PyObject*)&AST_type);
6761 }
6762
6763