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