1 2/* Function object implementation */ 3 4#include "Python.h" 5#include "pycore_ceval.h" // _PyEval_BuiltinsFromGlobals() 6#include "pycore_object.h" // _PyObject_GC_UNTRACK() 7#include "pycore_pyerrors.h" // _PyErr_Occurred() 8#include "structmember.h" // PyMemberDef 9 10static uint32_t next_func_version = 1; 11 12PyFunctionObject * 13_PyFunction_FromConstructor(PyFrameConstructor *constr) 14{ 15 16 PyFunctionObject *op = PyObject_GC_New(PyFunctionObject, &PyFunction_Type); 17 if (op == NULL) { 18 return NULL; 19 } 20 Py_INCREF(constr->fc_globals); 21 op->func_globals = constr->fc_globals; 22 Py_INCREF(constr->fc_builtins); 23 op->func_builtins = constr->fc_builtins; 24 Py_INCREF(constr->fc_name); 25 op->func_name = constr->fc_name; 26 Py_INCREF(constr->fc_qualname); 27 op->func_qualname = constr->fc_qualname; 28 Py_INCREF(constr->fc_code); 29 op->func_code = constr->fc_code; 30 Py_XINCREF(constr->fc_defaults); 31 op->func_defaults = constr->fc_defaults; 32 Py_XINCREF(constr->fc_kwdefaults); 33 op->func_kwdefaults = constr->fc_kwdefaults; 34 Py_XINCREF(constr->fc_closure); 35 op->func_closure = constr->fc_closure; 36 Py_INCREF(Py_None); 37 op->func_doc = Py_None; 38 op->func_dict = NULL; 39 op->func_weakreflist = NULL; 40 op->func_module = NULL; 41 op->func_annotations = NULL; 42 op->vectorcall = _PyFunction_Vectorcall; 43 op->func_version = 0; 44 _PyObject_GC_TRACK(op); 45 return op; 46} 47 48PyObject * 49PyFunction_NewWithQualName(PyObject *code, PyObject *globals, PyObject *qualname) 50{ 51 assert(globals != NULL); 52 assert(PyDict_Check(globals)); 53 Py_INCREF(globals); 54 55 PyThreadState *tstate = _PyThreadState_GET(); 56 57 PyCodeObject *code_obj = (PyCodeObject *)code; 58 Py_INCREF(code_obj); 59 60 PyObject *name = code_obj->co_name; 61 assert(name != NULL); 62 Py_INCREF(name); 63 64 if (!qualname) { 65 qualname = code_obj->co_qualname; 66 } 67 assert(qualname != NULL); 68 Py_INCREF(qualname); 69 70 PyObject *consts = code_obj->co_consts; 71 assert(PyTuple_Check(consts)); 72 PyObject *doc; 73 if (PyTuple_Size(consts) >= 1) { 74 doc = PyTuple_GetItem(consts, 0); 75 if (!PyUnicode_Check(doc)) { 76 doc = Py_None; 77 } 78 } 79 else { 80 doc = Py_None; 81 } 82 Py_INCREF(doc); 83 84 // __module__: Use globals['__name__'] if it exists, or NULL. 85 PyObject *module = PyDict_GetItemWithError(globals, &_Py_ID(__name__)); 86 PyObject *builtins = NULL; 87 if (module == NULL && _PyErr_Occurred(tstate)) { 88 goto error; 89 } 90 Py_XINCREF(module); 91 92 builtins = _PyEval_BuiltinsFromGlobals(tstate, globals); // borrowed ref 93 if (builtins == NULL) { 94 goto error; 95 } 96 Py_INCREF(builtins); 97 98 PyFunctionObject *op = PyObject_GC_New(PyFunctionObject, &PyFunction_Type); 99 if (op == NULL) { 100 goto error; 101 } 102 /* Note: No failures from this point on, since func_dealloc() does not 103 expect a partially-created object. */ 104 105 op->func_globals = globals; 106 op->func_builtins = builtins; 107 op->func_name = name; 108 op->func_qualname = qualname; 109 op->func_code = (PyObject*)code_obj; 110 op->func_defaults = NULL; // No default positional arguments 111 op->func_kwdefaults = NULL; // No default keyword arguments 112 op->func_closure = NULL; 113 op->func_doc = doc; 114 op->func_dict = NULL; 115 op->func_weakreflist = NULL; 116 op->func_module = module; 117 op->func_annotations = NULL; 118 op->vectorcall = _PyFunction_Vectorcall; 119 op->func_version = 0; 120 _PyObject_GC_TRACK(op); 121 return (PyObject *)op; 122 123error: 124 Py_DECREF(globals); 125 Py_DECREF(code_obj); 126 Py_DECREF(name); 127 Py_DECREF(qualname); 128 Py_DECREF(doc); 129 Py_XDECREF(module); 130 Py_XDECREF(builtins); 131 return NULL; 132} 133 134uint32_t _PyFunction_GetVersionForCurrentState(PyFunctionObject *func) 135{ 136 if (func->func_version != 0) { 137 return func->func_version; 138 } 139 if (next_func_version == 0) { 140 return 0; 141 } 142 uint32_t v = next_func_version++; 143 func->func_version = v; 144 return v; 145} 146 147PyObject * 148PyFunction_New(PyObject *code, PyObject *globals) 149{ 150 return PyFunction_NewWithQualName(code, globals, NULL); 151} 152 153PyObject * 154PyFunction_GetCode(PyObject *op) 155{ 156 if (!PyFunction_Check(op)) { 157 PyErr_BadInternalCall(); 158 return NULL; 159 } 160 return ((PyFunctionObject *) op) -> func_code; 161} 162 163PyObject * 164PyFunction_GetGlobals(PyObject *op) 165{ 166 if (!PyFunction_Check(op)) { 167 PyErr_BadInternalCall(); 168 return NULL; 169 } 170 return ((PyFunctionObject *) op) -> func_globals; 171} 172 173PyObject * 174PyFunction_GetModule(PyObject *op) 175{ 176 if (!PyFunction_Check(op)) { 177 PyErr_BadInternalCall(); 178 return NULL; 179 } 180 return ((PyFunctionObject *) op) -> func_module; 181} 182 183PyObject * 184PyFunction_GetDefaults(PyObject *op) 185{ 186 if (!PyFunction_Check(op)) { 187 PyErr_BadInternalCall(); 188 return NULL; 189 } 190 return ((PyFunctionObject *) op) -> func_defaults; 191} 192 193int 194PyFunction_SetDefaults(PyObject *op, PyObject *defaults) 195{ 196 if (!PyFunction_Check(op)) { 197 PyErr_BadInternalCall(); 198 return -1; 199 } 200 if (defaults == Py_None) 201 defaults = NULL; 202 else if (defaults && PyTuple_Check(defaults)) { 203 Py_INCREF(defaults); 204 } 205 else { 206 PyErr_SetString(PyExc_SystemError, "non-tuple default args"); 207 return -1; 208 } 209 ((PyFunctionObject *)op)->func_version = 0; 210 Py_XSETREF(((PyFunctionObject *)op)->func_defaults, defaults); 211 return 0; 212} 213 214PyObject * 215PyFunction_GetKwDefaults(PyObject *op) 216{ 217 if (!PyFunction_Check(op)) { 218 PyErr_BadInternalCall(); 219 return NULL; 220 } 221 return ((PyFunctionObject *) op) -> func_kwdefaults; 222} 223 224int 225PyFunction_SetKwDefaults(PyObject *op, PyObject *defaults) 226{ 227 if (!PyFunction_Check(op)) { 228 PyErr_BadInternalCall(); 229 return -1; 230 } 231 if (defaults == Py_None) 232 defaults = NULL; 233 else if (defaults && PyDict_Check(defaults)) { 234 Py_INCREF(defaults); 235 } 236 else { 237 PyErr_SetString(PyExc_SystemError, 238 "non-dict keyword only default args"); 239 return -1; 240 } 241 ((PyFunctionObject *)op)->func_version = 0; 242 Py_XSETREF(((PyFunctionObject *)op)->func_kwdefaults, defaults); 243 return 0; 244} 245 246PyObject * 247PyFunction_GetClosure(PyObject *op) 248{ 249 if (!PyFunction_Check(op)) { 250 PyErr_BadInternalCall(); 251 return NULL; 252 } 253 return ((PyFunctionObject *) op) -> func_closure; 254} 255 256int 257PyFunction_SetClosure(PyObject *op, PyObject *closure) 258{ 259 if (!PyFunction_Check(op)) { 260 PyErr_BadInternalCall(); 261 return -1; 262 } 263 if (closure == Py_None) 264 closure = NULL; 265 else if (PyTuple_Check(closure)) { 266 Py_INCREF(closure); 267 } 268 else { 269 PyErr_Format(PyExc_SystemError, 270 "expected tuple for closure, got '%.100s'", 271 Py_TYPE(closure)->tp_name); 272 return -1; 273 } 274 ((PyFunctionObject *)op)->func_version = 0; 275 Py_XSETREF(((PyFunctionObject *)op)->func_closure, closure); 276 return 0; 277} 278 279static PyObject * 280func_get_annotation_dict(PyFunctionObject *op) 281{ 282 if (op->func_annotations == NULL) { 283 return NULL; 284 } 285 if (PyTuple_CheckExact(op->func_annotations)) { 286 PyObject *ann_tuple = op->func_annotations; 287 PyObject *ann_dict = PyDict_New(); 288 if (ann_dict == NULL) { 289 return NULL; 290 } 291 292 assert(PyTuple_GET_SIZE(ann_tuple) % 2 == 0); 293 294 for (Py_ssize_t i = 0; i < PyTuple_GET_SIZE(ann_tuple); i += 2) { 295 int err = PyDict_SetItem(ann_dict, 296 PyTuple_GET_ITEM(ann_tuple, i), 297 PyTuple_GET_ITEM(ann_tuple, i + 1)); 298 299 if (err < 0) { 300 return NULL; 301 } 302 } 303 Py_SETREF(op->func_annotations, ann_dict); 304 } 305 assert(PyDict_Check(op->func_annotations)); 306 return op->func_annotations; 307} 308 309PyObject * 310PyFunction_GetAnnotations(PyObject *op) 311{ 312 if (!PyFunction_Check(op)) { 313 PyErr_BadInternalCall(); 314 return NULL; 315 } 316 return func_get_annotation_dict((PyFunctionObject *)op); 317} 318 319int 320PyFunction_SetAnnotations(PyObject *op, PyObject *annotations) 321{ 322 if (!PyFunction_Check(op)) { 323 PyErr_BadInternalCall(); 324 return -1; 325 } 326 if (annotations == Py_None) 327 annotations = NULL; 328 else if (annotations && PyDict_Check(annotations)) { 329 Py_INCREF(annotations); 330 } 331 else { 332 PyErr_SetString(PyExc_SystemError, 333 "non-dict annotations"); 334 return -1; 335 } 336 ((PyFunctionObject *)op)->func_version = 0; 337 Py_XSETREF(((PyFunctionObject *)op)->func_annotations, annotations); 338 return 0; 339} 340 341/* Methods */ 342 343#define OFF(x) offsetof(PyFunctionObject, x) 344 345static PyMemberDef func_memberlist[] = { 346 {"__closure__", T_OBJECT, OFF(func_closure), READONLY}, 347 {"__doc__", T_OBJECT, OFF(func_doc), 0}, 348 {"__globals__", T_OBJECT, OFF(func_globals), READONLY}, 349 {"__module__", T_OBJECT, OFF(func_module), 0}, 350 {"__builtins__", T_OBJECT, OFF(func_builtins), READONLY}, 351 {NULL} /* Sentinel */ 352}; 353 354static PyObject * 355func_get_code(PyFunctionObject *op, void *Py_UNUSED(ignored)) 356{ 357 if (PySys_Audit("object.__getattr__", "Os", op, "__code__") < 0) { 358 return NULL; 359 } 360 361 Py_INCREF(op->func_code); 362 return op->func_code; 363} 364 365static int 366func_set_code(PyFunctionObject *op, PyObject *value, void *Py_UNUSED(ignored)) 367{ 368 Py_ssize_t nclosure; 369 int nfree; 370 371 /* Not legal to del f.func_code or to set it to anything 372 * other than a code object. */ 373 if (value == NULL || !PyCode_Check(value)) { 374 PyErr_SetString(PyExc_TypeError, 375 "__code__ must be set to a code object"); 376 return -1; 377 } 378 379 if (PySys_Audit("object.__setattr__", "OsO", 380 op, "__code__", value) < 0) { 381 return -1; 382 } 383 384 nfree = ((PyCodeObject *)value)->co_nfreevars; 385 nclosure = (op->func_closure == NULL ? 0 : 386 PyTuple_GET_SIZE(op->func_closure)); 387 if (nclosure != nfree) { 388 PyErr_Format(PyExc_ValueError, 389 "%U() requires a code object with %zd free vars," 390 " not %zd", 391 op->func_name, 392 nclosure, nfree); 393 return -1; 394 } 395 op->func_version = 0; 396 Py_INCREF(value); 397 Py_XSETREF(op->func_code, value); 398 return 0; 399} 400 401static PyObject * 402func_get_name(PyFunctionObject *op, void *Py_UNUSED(ignored)) 403{ 404 Py_INCREF(op->func_name); 405 return op->func_name; 406} 407 408static int 409func_set_name(PyFunctionObject *op, PyObject *value, void *Py_UNUSED(ignored)) 410{ 411 /* Not legal to del f.func_name or to set it to anything 412 * other than a string object. */ 413 if (value == NULL || !PyUnicode_Check(value)) { 414 PyErr_SetString(PyExc_TypeError, 415 "__name__ must be set to a string object"); 416 return -1; 417 } 418 Py_INCREF(value); 419 Py_XSETREF(op->func_name, value); 420 return 0; 421} 422 423static PyObject * 424func_get_qualname(PyFunctionObject *op, void *Py_UNUSED(ignored)) 425{ 426 Py_INCREF(op->func_qualname); 427 return op->func_qualname; 428} 429 430static int 431func_set_qualname(PyFunctionObject *op, PyObject *value, void *Py_UNUSED(ignored)) 432{ 433 /* Not legal to del f.__qualname__ or to set it to anything 434 * other than a string object. */ 435 if (value == NULL || !PyUnicode_Check(value)) { 436 PyErr_SetString(PyExc_TypeError, 437 "__qualname__ must be set to a string object"); 438 return -1; 439 } 440 Py_INCREF(value); 441 Py_XSETREF(op->func_qualname, value); 442 return 0; 443} 444 445static PyObject * 446func_get_defaults(PyFunctionObject *op, void *Py_UNUSED(ignored)) 447{ 448 if (PySys_Audit("object.__getattr__", "Os", op, "__defaults__") < 0) { 449 return NULL; 450 } 451 if (op->func_defaults == NULL) { 452 Py_RETURN_NONE; 453 } 454 Py_INCREF(op->func_defaults); 455 return op->func_defaults; 456} 457 458static int 459func_set_defaults(PyFunctionObject *op, PyObject *value, void *Py_UNUSED(ignored)) 460{ 461 /* Legal to del f.func_defaults. 462 * Can only set func_defaults to NULL or a tuple. */ 463 if (value == Py_None) 464 value = NULL; 465 if (value != NULL && !PyTuple_Check(value)) { 466 PyErr_SetString(PyExc_TypeError, 467 "__defaults__ must be set to a tuple object"); 468 return -1; 469 } 470 if (value) { 471 if (PySys_Audit("object.__setattr__", "OsO", 472 op, "__defaults__", value) < 0) { 473 return -1; 474 } 475 } else if (PySys_Audit("object.__delattr__", "Os", 476 op, "__defaults__") < 0) { 477 return -1; 478 } 479 480 op->func_version = 0; 481 Py_XINCREF(value); 482 Py_XSETREF(op->func_defaults, value); 483 return 0; 484} 485 486static PyObject * 487func_get_kwdefaults(PyFunctionObject *op, void *Py_UNUSED(ignored)) 488{ 489 if (PySys_Audit("object.__getattr__", "Os", 490 op, "__kwdefaults__") < 0) { 491 return NULL; 492 } 493 if (op->func_kwdefaults == NULL) { 494 Py_RETURN_NONE; 495 } 496 Py_INCREF(op->func_kwdefaults); 497 return op->func_kwdefaults; 498} 499 500static int 501func_set_kwdefaults(PyFunctionObject *op, PyObject *value, void *Py_UNUSED(ignored)) 502{ 503 if (value == Py_None) 504 value = NULL; 505 /* Legal to del f.func_kwdefaults. 506 * Can only set func_kwdefaults to NULL or a dict. */ 507 if (value != NULL && !PyDict_Check(value)) { 508 PyErr_SetString(PyExc_TypeError, 509 "__kwdefaults__ must be set to a dict object"); 510 return -1; 511 } 512 if (value) { 513 if (PySys_Audit("object.__setattr__", "OsO", 514 op, "__kwdefaults__", value) < 0) { 515 return -1; 516 } 517 } else if (PySys_Audit("object.__delattr__", "Os", 518 op, "__kwdefaults__") < 0) { 519 return -1; 520 } 521 522 op->func_version = 0; 523 Py_XINCREF(value); 524 Py_XSETREF(op->func_kwdefaults, value); 525 return 0; 526} 527 528static PyObject * 529func_get_annotations(PyFunctionObject *op, void *Py_UNUSED(ignored)) 530{ 531 if (op->func_annotations == NULL) { 532 op->func_annotations = PyDict_New(); 533 if (op->func_annotations == NULL) 534 return NULL; 535 } 536 PyObject *d = func_get_annotation_dict(op); 537 if (d) { 538 Py_INCREF(d); 539 } 540 return d; 541} 542 543static int 544func_set_annotations(PyFunctionObject *op, PyObject *value, void *Py_UNUSED(ignored)) 545{ 546 if (value == Py_None) 547 value = NULL; 548 /* Legal to del f.func_annotations. 549 * Can only set func_annotations to NULL (through C api) 550 * or a dict. */ 551 if (value != NULL && !PyDict_Check(value)) { 552 PyErr_SetString(PyExc_TypeError, 553 "__annotations__ must be set to a dict object"); 554 return -1; 555 } 556 op->func_version = 0; 557 Py_XINCREF(value); 558 Py_XSETREF(op->func_annotations, value); 559 return 0; 560} 561 562static PyGetSetDef func_getsetlist[] = { 563 {"__code__", (getter)func_get_code, (setter)func_set_code}, 564 {"__defaults__", (getter)func_get_defaults, 565 (setter)func_set_defaults}, 566 {"__kwdefaults__", (getter)func_get_kwdefaults, 567 (setter)func_set_kwdefaults}, 568 {"__annotations__", (getter)func_get_annotations, 569 (setter)func_set_annotations}, 570 {"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict}, 571 {"__name__", (getter)func_get_name, (setter)func_set_name}, 572 {"__qualname__", (getter)func_get_qualname, (setter)func_set_qualname}, 573 {NULL} /* Sentinel */ 574}; 575 576/*[clinic input] 577class function "PyFunctionObject *" "&PyFunction_Type" 578[clinic start generated code]*/ 579/*[clinic end generated code: output=da39a3ee5e6b4b0d input=70af9c90aa2e71b0]*/ 580 581#include "clinic/funcobject.c.h" 582 583/* function.__new__() maintains the following invariants for closures. 584 The closure must correspond to the free variables of the code object. 585 586 if len(code.co_freevars) == 0: 587 closure = NULL 588 else: 589 len(closure) == len(code.co_freevars) 590 for every elt in closure, type(elt) == cell 591*/ 592 593/*[clinic input] 594@classmethod 595function.__new__ as func_new 596 code: object(type="PyCodeObject *", subclass_of="&PyCode_Type") 597 a code object 598 globals: object(subclass_of="&PyDict_Type") 599 the globals dictionary 600 name: object = None 601 a string that overrides the name from the code object 602 argdefs as defaults: object = None 603 a tuple that specifies the default argument values 604 closure: object = None 605 a tuple that supplies the bindings for free variables 606 607Create a function object. 608[clinic start generated code]*/ 609 610static PyObject * 611func_new_impl(PyTypeObject *type, PyCodeObject *code, PyObject *globals, 612 PyObject *name, PyObject *defaults, PyObject *closure) 613/*[clinic end generated code: output=99c6d9da3a24e3be input=93611752fc2daf11]*/ 614{ 615 PyFunctionObject *newfunc; 616 Py_ssize_t nclosure; 617 618 if (name != Py_None && !PyUnicode_Check(name)) { 619 PyErr_SetString(PyExc_TypeError, 620 "arg 3 (name) must be None or string"); 621 return NULL; 622 } 623 if (defaults != Py_None && !PyTuple_Check(defaults)) { 624 PyErr_SetString(PyExc_TypeError, 625 "arg 4 (defaults) must be None or tuple"); 626 return NULL; 627 } 628 if (!PyTuple_Check(closure)) { 629 if (code->co_nfreevars && closure == Py_None) { 630 PyErr_SetString(PyExc_TypeError, 631 "arg 5 (closure) must be tuple"); 632 return NULL; 633 } 634 else if (closure != Py_None) { 635 PyErr_SetString(PyExc_TypeError, 636 "arg 5 (closure) must be None or tuple"); 637 return NULL; 638 } 639 } 640 641 /* check that the closure is well-formed */ 642 nclosure = closure == Py_None ? 0 : PyTuple_GET_SIZE(closure); 643 if (code->co_nfreevars != nclosure) 644 return PyErr_Format(PyExc_ValueError, 645 "%U requires closure of length %zd, not %zd", 646 code->co_name, code->co_nfreevars, nclosure); 647 if (nclosure) { 648 Py_ssize_t i; 649 for (i = 0; i < nclosure; i++) { 650 PyObject *o = PyTuple_GET_ITEM(closure, i); 651 if (!PyCell_Check(o)) { 652 return PyErr_Format(PyExc_TypeError, 653 "arg 5 (closure) expected cell, found %s", 654 Py_TYPE(o)->tp_name); 655 } 656 } 657 } 658 if (PySys_Audit("function.__new__", "O", code) < 0) { 659 return NULL; 660 } 661 662 newfunc = (PyFunctionObject *)PyFunction_New((PyObject *)code, 663 globals); 664 if (newfunc == NULL) { 665 return NULL; 666 } 667 if (name != Py_None) { 668 Py_INCREF(name); 669 Py_SETREF(newfunc->func_name, name); 670 } 671 if (defaults != Py_None) { 672 Py_INCREF(defaults); 673 newfunc->func_defaults = defaults; 674 } 675 if (closure != Py_None) { 676 Py_INCREF(closure); 677 newfunc->func_closure = closure; 678 } 679 680 return (PyObject *)newfunc; 681} 682 683static int 684func_clear(PyFunctionObject *op) 685{ 686 op->func_version = 0; 687 Py_CLEAR(op->func_globals); 688 Py_CLEAR(op->func_builtins); 689 Py_CLEAR(op->func_module); 690 Py_CLEAR(op->func_defaults); 691 Py_CLEAR(op->func_kwdefaults); 692 Py_CLEAR(op->func_doc); 693 Py_CLEAR(op->func_dict); 694 Py_CLEAR(op->func_closure); 695 Py_CLEAR(op->func_annotations); 696 // Don't Py_CLEAR(op->func_code), since code is always required 697 // to be non-NULL. Similarly, name and qualname shouldn't be NULL. 698 // However, name and qualname could be str subclasses, so they 699 // could have reference cycles. The solution is to replace them 700 // with a genuinely immutable string. 701 Py_SETREF(op->func_name, Py_NewRef(&_Py_STR(empty))); 702 Py_SETREF(op->func_qualname, Py_NewRef(&_Py_STR(empty))); 703 return 0; 704} 705 706static void 707func_dealloc(PyFunctionObject *op) 708{ 709 _PyObject_GC_UNTRACK(op); 710 if (op->func_weakreflist != NULL) { 711 PyObject_ClearWeakRefs((PyObject *) op); 712 } 713 (void)func_clear(op); 714 // These aren't cleared by func_clear(). 715 Py_DECREF(op->func_code); 716 Py_DECREF(op->func_name); 717 Py_DECREF(op->func_qualname); 718 PyObject_GC_Del(op); 719} 720 721static PyObject* 722func_repr(PyFunctionObject *op) 723{ 724 return PyUnicode_FromFormat("<function %U at %p>", 725 op->func_qualname, op); 726} 727 728static int 729func_traverse(PyFunctionObject *f, visitproc visit, void *arg) 730{ 731 Py_VISIT(f->func_code); 732 Py_VISIT(f->func_globals); 733 Py_VISIT(f->func_builtins); 734 Py_VISIT(f->func_module); 735 Py_VISIT(f->func_defaults); 736 Py_VISIT(f->func_kwdefaults); 737 Py_VISIT(f->func_doc); 738 Py_VISIT(f->func_name); 739 Py_VISIT(f->func_dict); 740 Py_VISIT(f->func_closure); 741 Py_VISIT(f->func_annotations); 742 Py_VISIT(f->func_qualname); 743 return 0; 744} 745 746/* Bind a function to an object */ 747static PyObject * 748func_descr_get(PyObject *func, PyObject *obj, PyObject *type) 749{ 750 if (obj == Py_None || obj == NULL) { 751 Py_INCREF(func); 752 return func; 753 } 754 return PyMethod_New(func, obj); 755} 756 757PyTypeObject PyFunction_Type = { 758 PyVarObject_HEAD_INIT(&PyType_Type, 0) 759 "function", 760 sizeof(PyFunctionObject), 761 0, 762 (destructor)func_dealloc, /* tp_dealloc */ 763 offsetof(PyFunctionObject, vectorcall), /* tp_vectorcall_offset */ 764 0, /* tp_getattr */ 765 0, /* tp_setattr */ 766 0, /* tp_as_async */ 767 (reprfunc)func_repr, /* tp_repr */ 768 0, /* tp_as_number */ 769 0, /* tp_as_sequence */ 770 0, /* tp_as_mapping */ 771 0, /* tp_hash */ 772 PyVectorcall_Call, /* tp_call */ 773 0, /* tp_str */ 774 0, /* tp_getattro */ 775 0, /* tp_setattro */ 776 0, /* tp_as_buffer */ 777 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | 778 Py_TPFLAGS_HAVE_VECTORCALL | 779 Py_TPFLAGS_METHOD_DESCRIPTOR, /* tp_flags */ 780 func_new__doc__, /* tp_doc */ 781 (traverseproc)func_traverse, /* tp_traverse */ 782 (inquiry)func_clear, /* tp_clear */ 783 0, /* tp_richcompare */ 784 offsetof(PyFunctionObject, func_weakreflist), /* tp_weaklistoffset */ 785 0, /* tp_iter */ 786 0, /* tp_iternext */ 787 0, /* tp_methods */ 788 func_memberlist, /* tp_members */ 789 func_getsetlist, /* tp_getset */ 790 0, /* tp_base */ 791 0, /* tp_dict */ 792 func_descr_get, /* tp_descr_get */ 793 0, /* tp_descr_set */ 794 offsetof(PyFunctionObject, func_dict), /* tp_dictoffset */ 795 0, /* tp_init */ 796 0, /* tp_alloc */ 797 func_new, /* tp_new */ 798}; 799 800 801static int 802functools_copy_attr(PyObject *wrapper, PyObject *wrapped, PyObject *name) 803{ 804 PyObject *value = PyObject_GetAttr(wrapped, name); 805 if (value == NULL) { 806 if (PyErr_ExceptionMatches(PyExc_AttributeError)) { 807 PyErr_Clear(); 808 return 0; 809 } 810 return -1; 811 } 812 813 int res = PyObject_SetAttr(wrapper, name, value); 814 Py_DECREF(value); 815 return res; 816} 817 818// Similar to functools.wraps(wrapper, wrapped) 819static int 820functools_wraps(PyObject *wrapper, PyObject *wrapped) 821{ 822#define COPY_ATTR(ATTR) \ 823 do { \ 824 if (functools_copy_attr(wrapper, wrapped, &_Py_ID(ATTR)) < 0) { \ 825 return -1; \ 826 } \ 827 } while (0) \ 828 829 COPY_ATTR(__module__); 830 COPY_ATTR(__name__); 831 COPY_ATTR(__qualname__); 832 COPY_ATTR(__doc__); 833 COPY_ATTR(__annotations__); 834 return 0; 835 836#undef COPY_ATTR 837} 838 839 840/* Class method object */ 841 842/* A class method receives the class as implicit first argument, 843 just like an instance method receives the instance. 844 To declare a class method, use this idiom: 845 846 class C: 847 @classmethod 848 def f(cls, arg1, arg2, argN): 849 ... 850 851 It can be called either on the class (e.g. C.f()) or on an instance 852 (e.g. C().f()); the instance is ignored except for its class. 853 If a class method is called for a derived class, the derived class 854 object is passed as the implied first argument. 855 856 Class methods are different than C++ or Java static methods. 857 If you want those, see static methods below. 858*/ 859 860typedef struct { 861 PyObject_HEAD 862 PyObject *cm_callable; 863 PyObject *cm_dict; 864} classmethod; 865 866static void 867cm_dealloc(classmethod *cm) 868{ 869 _PyObject_GC_UNTRACK((PyObject *)cm); 870 Py_XDECREF(cm->cm_callable); 871 Py_XDECREF(cm->cm_dict); 872 Py_TYPE(cm)->tp_free((PyObject *)cm); 873} 874 875static int 876cm_traverse(classmethod *cm, visitproc visit, void *arg) 877{ 878 Py_VISIT(cm->cm_callable); 879 Py_VISIT(cm->cm_dict); 880 return 0; 881} 882 883static int 884cm_clear(classmethod *cm) 885{ 886 Py_CLEAR(cm->cm_callable); 887 Py_CLEAR(cm->cm_dict); 888 return 0; 889} 890 891 892static PyObject * 893cm_descr_get(PyObject *self, PyObject *obj, PyObject *type) 894{ 895 classmethod *cm = (classmethod *)self; 896 897 if (cm->cm_callable == NULL) { 898 PyErr_SetString(PyExc_RuntimeError, 899 "uninitialized classmethod object"); 900 return NULL; 901 } 902 if (type == NULL) 903 type = (PyObject *)(Py_TYPE(obj)); 904 if (Py_TYPE(cm->cm_callable)->tp_descr_get != NULL) { 905 return Py_TYPE(cm->cm_callable)->tp_descr_get(cm->cm_callable, type, 906 type); 907 } 908 return PyMethod_New(cm->cm_callable, type); 909} 910 911static int 912cm_init(PyObject *self, PyObject *args, PyObject *kwds) 913{ 914 classmethod *cm = (classmethod *)self; 915 PyObject *callable; 916 917 if (!_PyArg_NoKeywords("classmethod", kwds)) 918 return -1; 919 if (!PyArg_UnpackTuple(args, "classmethod", 1, 1, &callable)) 920 return -1; 921 Py_INCREF(callable); 922 Py_XSETREF(cm->cm_callable, callable); 923 924 if (functools_wraps((PyObject *)cm, cm->cm_callable) < 0) { 925 return -1; 926 } 927 return 0; 928} 929 930static PyMemberDef cm_memberlist[] = { 931 {"__func__", T_OBJECT, offsetof(classmethod, cm_callable), READONLY}, 932 {"__wrapped__", T_OBJECT, offsetof(classmethod, cm_callable), READONLY}, 933 {NULL} /* Sentinel */ 934}; 935 936static PyObject * 937cm_get___isabstractmethod__(classmethod *cm, void *closure) 938{ 939 int res = _PyObject_IsAbstract(cm->cm_callable); 940 if (res == -1) { 941 return NULL; 942 } 943 else if (res) { 944 Py_RETURN_TRUE; 945 } 946 Py_RETURN_FALSE; 947} 948 949static PyGetSetDef cm_getsetlist[] = { 950 {"__isabstractmethod__", 951 (getter)cm_get___isabstractmethod__, NULL, NULL, NULL}, 952 {"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict, NULL, NULL}, 953 {NULL} /* Sentinel */ 954}; 955 956static PyObject* 957cm_repr(classmethod *cm) 958{ 959 return PyUnicode_FromFormat("<classmethod(%R)>", cm->cm_callable); 960} 961 962PyDoc_STRVAR(classmethod_doc, 963"classmethod(function) -> method\n\ 964\n\ 965Convert a function to be a class method.\n\ 966\n\ 967A class method receives the class as implicit first argument,\n\ 968just like an instance method receives the instance.\n\ 969To declare a class method, use this idiom:\n\ 970\n\ 971 class C:\n\ 972 @classmethod\n\ 973 def f(cls, arg1, arg2, argN):\n\ 974 ...\n\ 975\n\ 976It can be called either on the class (e.g. C.f()) or on an instance\n\ 977(e.g. C().f()). The instance is ignored except for its class.\n\ 978If a class method is called for a derived class, the derived class\n\ 979object is passed as the implied first argument.\n\ 980\n\ 981Class methods are different than C++ or Java static methods.\n\ 982If you want those, see the staticmethod builtin."); 983 984PyTypeObject PyClassMethod_Type = { 985 PyVarObject_HEAD_INIT(&PyType_Type, 0) 986 "classmethod", 987 sizeof(classmethod), 988 0, 989 (destructor)cm_dealloc, /* tp_dealloc */ 990 0, /* tp_vectorcall_offset */ 991 0, /* tp_getattr */ 992 0, /* tp_setattr */ 993 0, /* tp_as_async */ 994 (reprfunc)cm_repr, /* tp_repr */ 995 0, /* tp_as_number */ 996 0, /* tp_as_sequence */ 997 0, /* tp_as_mapping */ 998 0, /* tp_hash */ 999 0, /* tp_call */ 1000 0, /* tp_str */ 1001 0, /* tp_getattro */ 1002 0, /* tp_setattro */ 1003 0, /* tp_as_buffer */ 1004 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, 1005 classmethod_doc, /* tp_doc */ 1006 (traverseproc)cm_traverse, /* tp_traverse */ 1007 (inquiry)cm_clear, /* tp_clear */ 1008 0, /* tp_richcompare */ 1009 0, /* tp_weaklistoffset */ 1010 0, /* tp_iter */ 1011 0, /* tp_iternext */ 1012 0, /* tp_methods */ 1013 cm_memberlist, /* tp_members */ 1014 cm_getsetlist, /* tp_getset */ 1015 0, /* tp_base */ 1016 0, /* tp_dict */ 1017 cm_descr_get, /* tp_descr_get */ 1018 0, /* tp_descr_set */ 1019 offsetof(classmethod, cm_dict), /* tp_dictoffset */ 1020 cm_init, /* tp_init */ 1021 PyType_GenericAlloc, /* tp_alloc */ 1022 PyType_GenericNew, /* tp_new */ 1023 PyObject_GC_Del, /* tp_free */ 1024}; 1025 1026PyObject * 1027PyClassMethod_New(PyObject *callable) 1028{ 1029 classmethod *cm = (classmethod *) 1030 PyType_GenericAlloc(&PyClassMethod_Type, 0); 1031 if (cm != NULL) { 1032 Py_INCREF(callable); 1033 cm->cm_callable = callable; 1034 } 1035 return (PyObject *)cm; 1036} 1037 1038 1039/* Static method object */ 1040 1041/* A static method does not receive an implicit first argument. 1042 To declare a static method, use this idiom: 1043 1044 class C: 1045 @staticmethod 1046 def f(arg1, arg2, argN): 1047 ... 1048 1049 It can be called either on the class (e.g. C.f()) or on an instance 1050 (e.g. C().f()). Both the class and the instance are ignored, and 1051 neither is passed implicitly as the first argument to the method. 1052 1053 Static methods in Python are similar to those found in Java or C++. 1054 For a more advanced concept, see class methods above. 1055*/ 1056 1057typedef struct { 1058 PyObject_HEAD 1059 PyObject *sm_callable; 1060 PyObject *sm_dict; 1061} staticmethod; 1062 1063static void 1064sm_dealloc(staticmethod *sm) 1065{ 1066 _PyObject_GC_UNTRACK((PyObject *)sm); 1067 Py_XDECREF(sm->sm_callable); 1068 Py_XDECREF(sm->sm_dict); 1069 Py_TYPE(sm)->tp_free((PyObject *)sm); 1070} 1071 1072static int 1073sm_traverse(staticmethod *sm, visitproc visit, void *arg) 1074{ 1075 Py_VISIT(sm->sm_callable); 1076 Py_VISIT(sm->sm_dict); 1077 return 0; 1078} 1079 1080static int 1081sm_clear(staticmethod *sm) 1082{ 1083 Py_CLEAR(sm->sm_callable); 1084 Py_CLEAR(sm->sm_dict); 1085 return 0; 1086} 1087 1088static PyObject * 1089sm_descr_get(PyObject *self, PyObject *obj, PyObject *type) 1090{ 1091 staticmethod *sm = (staticmethod *)self; 1092 1093 if (sm->sm_callable == NULL) { 1094 PyErr_SetString(PyExc_RuntimeError, 1095 "uninitialized staticmethod object"); 1096 return NULL; 1097 } 1098 Py_INCREF(sm->sm_callable); 1099 return sm->sm_callable; 1100} 1101 1102static int 1103sm_init(PyObject *self, PyObject *args, PyObject *kwds) 1104{ 1105 staticmethod *sm = (staticmethod *)self; 1106 PyObject *callable; 1107 1108 if (!_PyArg_NoKeywords("staticmethod", kwds)) 1109 return -1; 1110 if (!PyArg_UnpackTuple(args, "staticmethod", 1, 1, &callable)) 1111 return -1; 1112 Py_INCREF(callable); 1113 Py_XSETREF(sm->sm_callable, callable); 1114 1115 if (functools_wraps((PyObject *)sm, sm->sm_callable) < 0) { 1116 return -1; 1117 } 1118 return 0; 1119} 1120 1121static PyObject* 1122sm_call(PyObject *callable, PyObject *args, PyObject *kwargs) 1123{ 1124 staticmethod *sm = (staticmethod *)callable; 1125 return PyObject_Call(sm->sm_callable, args, kwargs); 1126} 1127 1128static PyMemberDef sm_memberlist[] = { 1129 {"__func__", T_OBJECT, offsetof(staticmethod, sm_callable), READONLY}, 1130 {"__wrapped__", T_OBJECT, offsetof(staticmethod, sm_callable), READONLY}, 1131 {NULL} /* Sentinel */ 1132}; 1133 1134static PyObject * 1135sm_get___isabstractmethod__(staticmethod *sm, void *closure) 1136{ 1137 int res = _PyObject_IsAbstract(sm->sm_callable); 1138 if (res == -1) { 1139 return NULL; 1140 } 1141 else if (res) { 1142 Py_RETURN_TRUE; 1143 } 1144 Py_RETURN_FALSE; 1145} 1146 1147static PyGetSetDef sm_getsetlist[] = { 1148 {"__isabstractmethod__", 1149 (getter)sm_get___isabstractmethod__, NULL, NULL, NULL}, 1150 {"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict, NULL, NULL}, 1151 {NULL} /* Sentinel */ 1152}; 1153 1154static PyObject* 1155sm_repr(staticmethod *sm) 1156{ 1157 return PyUnicode_FromFormat("<staticmethod(%R)>", sm->sm_callable); 1158} 1159 1160PyDoc_STRVAR(staticmethod_doc, 1161"staticmethod(function) -> method\n\ 1162\n\ 1163Convert a function to be a static method.\n\ 1164\n\ 1165A static method does not receive an implicit first argument.\n\ 1166To declare a static method, use this idiom:\n\ 1167\n\ 1168 class C:\n\ 1169 @staticmethod\n\ 1170 def f(arg1, arg2, argN):\n\ 1171 ...\n\ 1172\n\ 1173It can be called either on the class (e.g. C.f()) or on an instance\n\ 1174(e.g. C().f()). Both the class and the instance are ignored, and\n\ 1175neither is passed implicitly as the first argument to the method.\n\ 1176\n\ 1177Static methods in Python are similar to those found in Java or C++.\n\ 1178For a more advanced concept, see the classmethod builtin."); 1179 1180PyTypeObject PyStaticMethod_Type = { 1181 PyVarObject_HEAD_INIT(&PyType_Type, 0) 1182 "staticmethod", 1183 sizeof(staticmethod), 1184 0, 1185 (destructor)sm_dealloc, /* tp_dealloc */ 1186 0, /* tp_vectorcall_offset */ 1187 0, /* tp_getattr */ 1188 0, /* tp_setattr */ 1189 0, /* tp_as_async */ 1190 (reprfunc)sm_repr, /* tp_repr */ 1191 0, /* tp_as_number */ 1192 0, /* tp_as_sequence */ 1193 0, /* tp_as_mapping */ 1194 0, /* tp_hash */ 1195 sm_call, /* tp_call */ 1196 0, /* tp_str */ 1197 0, /* tp_getattro */ 1198 0, /* tp_setattro */ 1199 0, /* tp_as_buffer */ 1200 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, 1201 staticmethod_doc, /* tp_doc */ 1202 (traverseproc)sm_traverse, /* tp_traverse */ 1203 (inquiry)sm_clear, /* tp_clear */ 1204 0, /* tp_richcompare */ 1205 0, /* tp_weaklistoffset */ 1206 0, /* tp_iter */ 1207 0, /* tp_iternext */ 1208 0, /* tp_methods */ 1209 sm_memberlist, /* tp_members */ 1210 sm_getsetlist, /* tp_getset */ 1211 0, /* tp_base */ 1212 0, /* tp_dict */ 1213 sm_descr_get, /* tp_descr_get */ 1214 0, /* tp_descr_set */ 1215 offsetof(staticmethod, sm_dict), /* tp_dictoffset */ 1216 sm_init, /* tp_init */ 1217 PyType_GenericAlloc, /* tp_alloc */ 1218 PyType_GenericNew, /* tp_new */ 1219 PyObject_GC_Del, /* tp_free */ 1220}; 1221 1222PyObject * 1223PyStaticMethod_New(PyObject *callable) 1224{ 1225 staticmethod *sm = (staticmethod *) 1226 PyType_GenericAlloc(&PyStaticMethod_Type, 0); 1227 if (sm != NULL) { 1228 Py_INCREF(callable); 1229 sm->sm_callable = callable; 1230 } 1231 return (PyObject *)sm; 1232} 1233