Python/Python-ast.c

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