1 2 /* Function object implementation */ 3 4 #include "Python.h" 5 #include "code.h" 6 #include "eval.h" 7 #include "structmember.h" 8 9 PyObject * 10 PyFunction_New(PyObject *code, PyObject *globals) 11 { 12 PyFunctionObject *op = PyObject_GC_New(PyFunctionObject, 13 &PyFunction_Type); 14 static PyObject *__name__ = 0; 15 if (op != NULL) { 16 PyObject *doc; 17 PyObject *consts; 18 PyObject *module; 19 op->func_weakreflist = NULL; 20 Py_INCREF(code); 21 op->func_code = code; 22 Py_INCREF(globals); 23 op->func_globals = globals; 24 op->func_name = ((PyCodeObject *)code)->co_name; 25 Py_INCREF(op->func_name); 26 op->func_defaults = NULL; /* No default arguments */ 27 op->func_closure = NULL; 28 consts = ((PyCodeObject *)code)->co_consts; 29 if (PyTuple_Size(consts) >= 1) { 30 doc = PyTuple_GetItem(consts, 0); 31 if (!PyString_Check(doc) && !PyUnicode_Check(doc)) 32 doc = Py_None; 33 } 34 else 35 doc = Py_None; 36 Py_INCREF(doc); 37 op->func_doc = doc; 38 op->func_dict = NULL; 39 op->func_module = NULL; 40 41 /* __module__: If module name is in globals, use it. 42 Otherwise, use None. 43 */ 44 if (!__name__) { 45 __name__ = PyString_InternFromString("__name__"); 46 if (!__name__) { 47 Py_DECREF(op); 48 return NULL; 49 } 50 } 51 module = PyDict_GetItem(globals, __name__); 52 if (module) { 53 Py_INCREF(module); 54 op->func_module = module; 55 } 56 } 57 else 58 return NULL; 59 _PyObject_GC_TRACK(op); 60 return (PyObject *)op; 61 } 62 63 PyObject * 64 PyFunction_GetCode(PyObject *op) 65 { 66 if (!PyFunction_Check(op)) { 67 PyErr_BadInternalCall(); 68 return NULL; 69 } 70 return ((PyFunctionObject *) op) -> func_code; 71 } 72 73 PyObject * 74 PyFunction_GetGlobals(PyObject *op) 75 { 76 if (!PyFunction_Check(op)) { 77 PyErr_BadInternalCall(); 78 return NULL; 79 } 80 return ((PyFunctionObject *) op) -> func_globals; 81 } 82 83 PyObject * 84 PyFunction_GetModule(PyObject *op) 85 { 86 if (!PyFunction_Check(op)) { 87 PyErr_BadInternalCall(); 88 return NULL; 89 } 90 return ((PyFunctionObject *) op) -> func_module; 91 } 92 93 PyObject * 94 PyFunction_GetDefaults(PyObject *op) 95 { 96 if (!PyFunction_Check(op)) { 97 PyErr_BadInternalCall(); 98 return NULL; 99 } 100 return ((PyFunctionObject *) op) -> func_defaults; 101 } 102 103 int 104 PyFunction_SetDefaults(PyObject *op, PyObject *defaults) 105 { 106 if (!PyFunction_Check(op)) { 107 PyErr_BadInternalCall(); 108 return -1; 109 } 110 if (defaults == Py_None) 111 defaults = NULL; 112 else if (defaults && PyTuple_Check(defaults)) { 113 Py_INCREF(defaults); 114 } 115 else { 116 PyErr_SetString(PyExc_SystemError, "non-tuple default args"); 117 return -1; 118 } 119 Py_XDECREF(((PyFunctionObject *) op) -> func_defaults); 120 ((PyFunctionObject *) op) -> func_defaults = defaults; 121 return 0; 122 } 123 124 PyObject * 125 PyFunction_GetClosure(PyObject *op) 126 { 127 if (!PyFunction_Check(op)) { 128 PyErr_BadInternalCall(); 129 return NULL; 130 } 131 return ((PyFunctionObject *) op) -> func_closure; 132 } 133 134 int 135 PyFunction_SetClosure(PyObject *op, PyObject *closure) 136 { 137 if (!PyFunction_Check(op)) { 138 PyErr_BadInternalCall(); 139 return -1; 140 } 141 if (closure == Py_None) 142 closure = NULL; 143 else if (PyTuple_Check(closure)) { 144 Py_INCREF(closure); 145 } 146 else { 147 PyErr_Format(PyExc_SystemError, 148 "expected tuple for closure, got '%.100s'", 149 closure->ob_type->tp_name); 150 return -1; 151 } 152 Py_XDECREF(((PyFunctionObject *) op) -> func_closure); 153 ((PyFunctionObject *) op) -> func_closure = closure; 154 return 0; 155 } 156 157 /* Methods */ 158 159 #define OFF(x) offsetof(PyFunctionObject, x) 160 161 static PyMemberDef func_memberlist[] = { 162 {"func_closure", T_OBJECT, OFF(func_closure), 163 RESTRICTED|READONLY}, 164 {"__closure__", T_OBJECT, OFF(func_closure), 165 RESTRICTED|READONLY}, 166 {"func_doc", T_OBJECT, OFF(func_doc), PY_WRITE_RESTRICTED}, 167 {"__doc__", T_OBJECT, OFF(func_doc), PY_WRITE_RESTRICTED}, 168 {"func_globals", T_OBJECT, OFF(func_globals), 169 RESTRICTED|READONLY}, 170 {"__globals__", T_OBJECT, OFF(func_globals), 171 RESTRICTED|READONLY}, 172 {"__module__", T_OBJECT, OFF(func_module), PY_WRITE_RESTRICTED}, 173 {NULL} /* Sentinel */ 174 }; 175 176 static int 177 restricted(void) 178 { 179 if (!PyEval_GetRestricted()) 180 return 0; 181 PyErr_SetString(PyExc_RuntimeError, 182 "function attributes not accessible in restricted mode"); 183 return 1; 184 } 185 186 static PyObject * 187 func_get_dict(PyFunctionObject *op) 188 { 189 if (restricted()) 190 return NULL; 191 if (op->func_dict == NULL) { 192 op->func_dict = PyDict_New(); 193 if (op->func_dict == NULL) 194 return NULL; 195 } 196 Py_INCREF(op->func_dict); 197 return op->func_dict; 198 } 199 200 static int 201 func_set_dict(PyFunctionObject *op, PyObject *value) 202 { 203 PyObject *tmp; 204 205 if (restricted()) 206 return -1; 207 /* It is illegal to del f.func_dict */ 208 if (value == NULL) { 209 PyErr_SetString(PyExc_TypeError, 210 "function's dictionary may not be deleted"); 211 return -1; 212 } 213 /* Can only set func_dict to a dictionary */ 214 if (!PyDict_Check(value)) { 215 PyErr_SetString(PyExc_TypeError, 216 "setting function's dictionary to a non-dict"); 217 return -1; 218 } 219 tmp = op->func_dict; 220 Py_INCREF(value); 221 op->func_dict = value; 222 Py_XDECREF(tmp); 223 return 0; 224 } 225 226 static PyObject * 227 func_get_code(PyFunctionObject *op) 228 { 229 if (restricted()) 230 return NULL; 231 Py_INCREF(op->func_code); 232 return op->func_code; 233 } 234 235 static int 236 func_set_code(PyFunctionObject *op, PyObject *value) 237 { 238 PyObject *tmp; 239 Py_ssize_t nfree, nclosure; 240 241 if (restricted()) 242 return -1; 243 /* Not legal to del f.func_code or to set it to anything 244 * other than a code object. */ 245 if (value == NULL || !PyCode_Check(value)) { 246 PyErr_SetString(PyExc_TypeError, 247 "__code__ must be set to a code object"); 248 return -1; 249 } 250 nfree = PyCode_GetNumFree((PyCodeObject *)value); 251 nclosure = (op->func_closure == NULL ? 0 : 252 PyTuple_GET_SIZE(op->func_closure)); 253 if (nclosure != nfree) { 254 PyErr_Format(PyExc_ValueError, 255 "%s() requires a code object with %zd free vars," 256 " not %zd", 257 PyString_AsString(op->func_name), 258 nclosure, nfree); 259 return -1; 260 } 261 tmp = op->func_code; 262 Py_INCREF(value); 263 op->func_code = value; 264 Py_DECREF(tmp); 265 return 0; 266 } 267 268 static PyObject * 269 func_get_name(PyFunctionObject *op) 270 { 271 Py_INCREF(op->func_name); 272 return op->func_name; 273 } 274 275 static int 276 func_set_name(PyFunctionObject *op, PyObject *value) 277 { 278 PyObject *tmp; 279 280 if (restricted()) 281 return -1; 282 /* Not legal to del f.func_name or to set it to anything 283 * other than a string object. */ 284 if (value == NULL || !PyString_Check(value)) { 285 PyErr_SetString(PyExc_TypeError, 286 "__name__ must be set to a string object"); 287 return -1; 288 } 289 tmp = op->func_name; 290 Py_INCREF(value); 291 op->func_name = value; 292 Py_DECREF(tmp); 293 return 0; 294 } 295 296 static PyObject * 297 func_get_defaults(PyFunctionObject *op) 298 { 299 if (restricted()) 300 return NULL; 301 if (op->func_defaults == NULL) { 302 Py_INCREF(Py_None); 303 return Py_None; 304 } 305 Py_INCREF(op->func_defaults); 306 return op->func_defaults; 307 } 308 309 static int 310 func_set_defaults(PyFunctionObject *op, PyObject *value) 311 { 312 PyObject *tmp; 313 314 if (restricted()) 315 return -1; 316 /* Legal to del f.func_defaults. 317 * Can only set func_defaults to NULL or a tuple. */ 318 if (value == Py_None) 319 value = NULL; 320 if (value != NULL && !PyTuple_Check(value)) { 321 PyErr_SetString(PyExc_TypeError, 322 "__defaults__ must be set to a tuple object"); 323 return -1; 324 } 325 tmp = op->func_defaults; 326 Py_XINCREF(value); 327 op->func_defaults = value; 328 Py_XDECREF(tmp); 329 return 0; 330 } 331 332 static PyGetSetDef func_getsetlist[] = { 333 {"func_code", (getter)func_get_code, (setter)func_set_code}, 334 {"__code__", (getter)func_get_code, (setter)func_set_code}, 335 {"func_defaults", (getter)func_get_defaults, 336 (setter)func_set_defaults}, 337 {"__defaults__", (getter)func_get_defaults, 338 (setter)func_set_defaults}, 339 {"func_dict", (getter)func_get_dict, (setter)func_set_dict}, 340 {"__dict__", (getter)func_get_dict, (setter)func_set_dict}, 341 {"func_name", (getter)func_get_name, (setter)func_set_name}, 342 {"__name__", (getter)func_get_name, (setter)func_set_name}, 343 {NULL} /* Sentinel */ 344 }; 345 346 PyDoc_STRVAR(func_doc, 347 "function(code, globals[, name[, argdefs[, closure]]])\n\ 348 \n\ 349 Create a function object from a code object and a dictionary.\n\ 350 The optional name string overrides the name from the code object.\n\ 351 The optional argdefs tuple specifies the default argument values.\n\ 352 The optional closure tuple supplies the bindings for free variables."); 353 354 /* func_new() maintains the following invariants for closures. The 355 closure must correspond to the free variables of the code object. 356 357 if len(code.co_freevars) == 0: 358 closure = NULL 359 else: 360 len(closure) == len(code.co_freevars) 361 for every elt in closure, type(elt) == cell 362 */ 363 364 static PyObject * 365 func_new(PyTypeObject* type, PyObject* args, PyObject* kw) 366 { 367 PyCodeObject *code; 368 PyObject *globals; 369 PyObject *name = Py_None; 370 PyObject *defaults = Py_None; 371 PyObject *closure = Py_None; 372 PyFunctionObject *newfunc; 373 Py_ssize_t nfree, nclosure; 374 static char *kwlist[] = {"code", "globals", "name", 375 "argdefs", "closure", 0}; 376 377 if (!PyArg_ParseTupleAndKeywords(args, kw, "O!O!|OOO:function", 378 kwlist, 379 &PyCode_Type, &code, 380 &PyDict_Type, &globals, 381 &name, &defaults, &closure)) 382 return NULL; 383 if (name != Py_None && !PyString_Check(name)) { 384 PyErr_SetString(PyExc_TypeError, 385 "arg 3 (name) must be None or string"); 386 return NULL; 387 } 388 if (defaults != Py_None && !PyTuple_Check(defaults)) { 389 PyErr_SetString(PyExc_TypeError, 390 "arg 4 (defaults) must be None or tuple"); 391 return NULL; 392 } 393 nfree = PyTuple_GET_SIZE(code->co_freevars); 394 if (!PyTuple_Check(closure)) { 395 if (nfree && closure == Py_None) { 396 PyErr_SetString(PyExc_TypeError, 397 "arg 5 (closure) must be tuple"); 398 return NULL; 399 } 400 else if (closure != Py_None) { 401 PyErr_SetString(PyExc_TypeError, 402 "arg 5 (closure) must be None or tuple"); 403 return NULL; 404 } 405 } 406 407 /* check that the closure is well-formed */ 408 nclosure = closure == Py_None ? 0 : PyTuple_GET_SIZE(closure); 409 if (nfree != nclosure) 410 return PyErr_Format(PyExc_ValueError, 411 "%s requires closure of length %zd, not %zd", 412 PyString_AS_STRING(code->co_name), 413 nfree, nclosure); 414 if (nclosure) { 415 Py_ssize_t i; 416 for (i = 0; i < nclosure; i++) { 417 PyObject *o = PyTuple_GET_ITEM(closure, i); 418 if (!PyCell_Check(o)) { 419 return PyErr_Format(PyExc_TypeError, 420 "arg 5 (closure) expected cell, found %s", 421 o->ob_type->tp_name); 422 } 423 } 424 } 425 426 newfunc = (PyFunctionObject *)PyFunction_New((PyObject *)code, 427 globals); 428 if (newfunc == NULL) 429 return NULL; 430 431 if (name != Py_None) { 432 Py_INCREF(name); 433 Py_DECREF(newfunc->func_name); 434 newfunc->func_name = name; 435 } 436 if (defaults != Py_None) { 437 Py_INCREF(defaults); 438 newfunc->func_defaults = defaults; 439 } 440 if (closure != Py_None) { 441 Py_INCREF(closure); 442 newfunc->func_closure = closure; 443 } 444 445 return (PyObject *)newfunc; 446 } 447 448 static void 449 func_dealloc(PyFunctionObject *op) 450 { 451 _PyObject_GC_UNTRACK(op); 452 if (op->func_weakreflist != NULL) 453 PyObject_ClearWeakRefs((PyObject *) op); 454 Py_DECREF(op->func_code); 455 Py_DECREF(op->func_globals); 456 Py_XDECREF(op->func_module); 457 Py_DECREF(op->func_name); 458 Py_XDECREF(op->func_defaults); 459 Py_XDECREF(op->func_doc); 460 Py_XDECREF(op->func_dict); 461 Py_XDECREF(op->func_closure); 462 PyObject_GC_Del(op); 463 } 464 465 static PyObject* 466 func_repr(PyFunctionObject *op) 467 { 468 return PyString_FromFormat("<function %s at %p>", 469 PyString_AsString(op->func_name), 470 op); 471 } 472 473 static int 474 func_traverse(PyFunctionObject *f, visitproc visit, void *arg) 475 { 476 Py_VISIT(f->func_code); 477 Py_VISIT(f->func_globals); 478 Py_VISIT(f->func_module); 479 Py_VISIT(f->func_defaults); 480 Py_VISIT(f->func_doc); 481 Py_VISIT(f->func_name); 482 Py_VISIT(f->func_dict); 483 Py_VISIT(f->func_closure); 484 return 0; 485 } 486 487 static PyObject * 488 function_call(PyObject *func, PyObject *arg, PyObject *kw) 489 { 490 PyObject *result; 491 PyObject *argdefs; 492 PyObject *kwtuple = NULL; 493 PyObject **d, **k; 494 Py_ssize_t nk, nd; 495 496 argdefs = PyFunction_GET_DEFAULTS(func); 497 if (argdefs != NULL && PyTuple_Check(argdefs)) { 498 d = &PyTuple_GET_ITEM((PyTupleObject *)argdefs, 0); 499 nd = PyTuple_GET_SIZE(argdefs); 500 } 501 else { 502 d = NULL; 503 nd = 0; 504 } 505 506 if (kw != NULL && PyDict_Check(kw)) { 507 Py_ssize_t pos, i; 508 nk = PyDict_Size(kw); 509 kwtuple = PyTuple_New(2*nk); 510 if (kwtuple == NULL) 511 return NULL; 512 k = &PyTuple_GET_ITEM(kwtuple, 0); 513 pos = i = 0; 514 while (PyDict_Next(kw, &pos, &k[i], &k[i+1])) { 515 Py_INCREF(k[i]); 516 Py_INCREF(k[i+1]); 517 i += 2; 518 } 519 nk = i/2; 520 } 521 else { 522 k = NULL; 523 nk = 0; 524 } 525 526 result = PyEval_EvalCodeEx( 527 (PyCodeObject *)PyFunction_GET_CODE(func), 528 PyFunction_GET_GLOBALS(func), (PyObject *)NULL, 529 &PyTuple_GET_ITEM(arg, 0), PyTuple_GET_SIZE(arg), 530 k, nk, d, nd, 531 PyFunction_GET_CLOSURE(func)); 532 533 Py_XDECREF(kwtuple); 534 535 return result; 536 } 537 538 /* Bind a function to an object */ 539 static PyObject * 540 func_descr_get(PyObject *func, PyObject *obj, PyObject *type) 541 { 542 if (obj == Py_None) 543 obj = NULL; 544 return PyMethod_New(func, obj, type); 545 } 546 547 PyTypeObject PyFunction_Type = { 548 PyVarObject_HEAD_INIT(&PyType_Type, 0) 549 "function", 550 sizeof(PyFunctionObject), 551 0, 552 (destructor)func_dealloc, /* tp_dealloc */ 553 0, /* tp_print */ 554 0, /* tp_getattr */ 555 0, /* tp_setattr */ 556 0, /* tp_compare */ 557 (reprfunc)func_repr, /* tp_repr */ 558 0, /* tp_as_number */ 559 0, /* tp_as_sequence */ 560 0, /* tp_as_mapping */ 561 0, /* tp_hash */ 562 function_call, /* tp_call */ 563 0, /* tp_str */ 564 PyObject_GenericGetAttr, /* tp_getattro */ 565 PyObject_GenericSetAttr, /* tp_setattro */ 566 0, /* tp_as_buffer */ 567 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */ 568 func_doc, /* tp_doc */ 569 (traverseproc)func_traverse, /* tp_traverse */ 570 0, /* tp_clear */ 571 0, /* tp_richcompare */ 572 offsetof(PyFunctionObject, func_weakreflist), /* tp_weaklistoffset */ 573 0, /* tp_iter */ 574 0, /* tp_iternext */ 575 0, /* tp_methods */ 576 func_memberlist, /* tp_members */ 577 func_getsetlist, /* tp_getset */ 578 0, /* tp_base */ 579 0, /* tp_dict */ 580 func_descr_get, /* tp_descr_get */ 581 0, /* tp_descr_set */ 582 offsetof(PyFunctionObject, func_dict), /* tp_dictoffset */ 583 0, /* tp_init */ 584 0, /* tp_alloc */ 585 func_new, /* tp_new */ 586 }; 587 588 589 /* Class method object */ 590 591 /* A class method receives the class as implicit first argument, 592 just like an instance method receives the instance. 593 To declare a class method, use this idiom: 594 595 class C: 596 def f(cls, arg1, arg2, ...): ... 597 f = classmethod(f) 598 599 It can be called either on the class (e.g. C.f()) or on an instance 600 (e.g. C().f()); the instance is ignored except for its class. 601 If a class method is called for a derived class, the derived class 602 object is passed as the implied first argument. 603 604 Class methods are different than C++ or Java static methods. 605 If you want those, see static methods below. 606 */ 607 608 typedef struct { 609 PyObject_HEAD 610 PyObject *cm_callable; 611 } classmethod; 612 613 static void 614 cm_dealloc(classmethod *cm) 615 { 616 _PyObject_GC_UNTRACK((PyObject *)cm); 617 Py_XDECREF(cm->cm_callable); 618 Py_TYPE(cm)->tp_free((PyObject *)cm); 619 } 620 621 static int 622 cm_traverse(classmethod *cm, visitproc visit, void *arg) 623 { 624 Py_VISIT(cm->cm_callable); 625 return 0; 626 } 627 628 static int 629 cm_clear(classmethod *cm) 630 { 631 Py_CLEAR(cm->cm_callable); 632 return 0; 633 } 634 635 636 static PyObject * 637 cm_descr_get(PyObject *self, PyObject *obj, PyObject *type) 638 { 639 classmethod *cm = (classmethod *)self; 640 641 if (cm->cm_callable == NULL) { 642 PyErr_SetString(PyExc_RuntimeError, 643 "uninitialized classmethod object"); 644 return NULL; 645 } 646 if (type == NULL) 647 type = (PyObject *)(Py_TYPE(obj)); 648 return PyMethod_New(cm->cm_callable, 649 type, (PyObject *)(Py_TYPE(type))); 650 } 651 652 static int 653 cm_init(PyObject *self, PyObject *args, PyObject *kwds) 654 { 655 classmethod *cm = (classmethod *)self; 656 PyObject *callable; 657 658 if (!PyArg_UnpackTuple(args, "classmethod", 1, 1, &callable)) 659 return -1; 660 if (!_PyArg_NoKeywords("classmethod", kwds)) 661 return -1; 662 Py_INCREF(callable); 663 cm->cm_callable = callable; 664 return 0; 665 } 666 667 static PyMemberDef cm_memberlist[] = { 668 {"__func__", T_OBJECT, offsetof(classmethod, cm_callable), READONLY}, 669 {NULL} /* Sentinel */ 670 }; 671 672 PyDoc_STRVAR(classmethod_doc, 673 "classmethod(function) -> method\n\ 674 \n\ 675 Convert a function to be a class method.\n\ 676 \n\ 677 A class method receives the class as implicit first argument,\n\ 678 just like an instance method receives the instance.\n\ 679 To declare a class method, use this idiom:\n\ 680 \n\ 681 class C:\n\ 682 def f(cls, arg1, arg2, ...): ...\n\ 683 f = classmethod(f)\n\ 684 \n\ 685 It can be called either on the class (e.g. C.f()) or on an instance\n\ 686 (e.g. C().f()). The instance is ignored except for its class.\n\ 687 If a class method is called for a derived class, the derived class\n\ 688 object is passed as the implied first argument.\n\ 689 \n\ 690 Class methods are different than C++ or Java static methods.\n\ 691 If you want those, see the staticmethod builtin."); 692 693 PyTypeObject PyClassMethod_Type = { 694 PyVarObject_HEAD_INIT(&PyType_Type, 0) 695 "classmethod", 696 sizeof(classmethod), 697 0, 698 (destructor)cm_dealloc, /* tp_dealloc */ 699 0, /* tp_print */ 700 0, /* tp_getattr */ 701 0, /* tp_setattr */ 702 0, /* tp_compare */ 703 0, /* tp_repr */ 704 0, /* tp_as_number */ 705 0, /* tp_as_sequence */ 706 0, /* tp_as_mapping */ 707 0, /* tp_hash */ 708 0, /* tp_call */ 709 0, /* tp_str */ 710 PyObject_GenericGetAttr, /* tp_getattro */ 711 0, /* tp_setattro */ 712 0, /* tp_as_buffer */ 713 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, 714 classmethod_doc, /* tp_doc */ 715 (traverseproc)cm_traverse, /* tp_traverse */ 716 (inquiry)cm_clear, /* tp_clear */ 717 0, /* tp_richcompare */ 718 0, /* tp_weaklistoffset */ 719 0, /* tp_iter */ 720 0, /* tp_iternext */ 721 0, /* tp_methods */ 722 cm_memberlist, /* tp_members */ 723 0, /* tp_getset */ 724 0, /* tp_base */ 725 0, /* tp_dict */ 726 cm_descr_get, /* tp_descr_get */ 727 0, /* tp_descr_set */ 728 0, /* tp_dictoffset */ 729 cm_init, /* tp_init */ 730 PyType_GenericAlloc, /* tp_alloc */ 731 PyType_GenericNew, /* tp_new */ 732 PyObject_GC_Del, /* tp_free */ 733 }; 734 735 PyObject * 736 PyClassMethod_New(PyObject *callable) 737 { 738 classmethod *cm = (classmethod *) 739 PyType_GenericAlloc(&PyClassMethod_Type, 0); 740 if (cm != NULL) { 741 Py_INCREF(callable); 742 cm->cm_callable = callable; 743 } 744 return (PyObject *)cm; 745 } 746 747 748 /* Static method object */ 749 750 /* A static method does not receive an implicit first argument. 751 To declare a static method, use this idiom: 752 753 class C: 754 def f(arg1, arg2, ...): ... 755 f = staticmethod(f) 756 757 It can be called either on the class (e.g. C.f()) or on an instance 758 (e.g. C().f()); the instance is ignored except for its class. 759 760 Static methods in Python are similar to those found in Java or C++. 761 For a more advanced concept, see class methods above. 762 */ 763 764 typedef struct { 765 PyObject_HEAD 766 PyObject *sm_callable; 767 } staticmethod; 768 769 static void 770 sm_dealloc(staticmethod *sm) 771 { 772 _PyObject_GC_UNTRACK((PyObject *)sm); 773 Py_XDECREF(sm->sm_callable); 774 Py_TYPE(sm)->tp_free((PyObject *)sm); 775 } 776 777 static int 778 sm_traverse(staticmethod *sm, visitproc visit, void *arg) 779 { 780 Py_VISIT(sm->sm_callable); 781 return 0; 782 } 783 784 static int 785 sm_clear(staticmethod *sm) 786 { 787 Py_CLEAR(sm->sm_callable); 788 return 0; 789 } 790 791 static PyObject * 792 sm_descr_get(PyObject *self, PyObject *obj, PyObject *type) 793 { 794 staticmethod *sm = (staticmethod *)self; 795 796 if (sm->sm_callable == NULL) { 797 PyErr_SetString(PyExc_RuntimeError, 798 "uninitialized staticmethod object"); 799 return NULL; 800 } 801 Py_INCREF(sm->sm_callable); 802 return sm->sm_callable; 803 } 804 805 static int 806 sm_init(PyObject *self, PyObject *args, PyObject *kwds) 807 { 808 staticmethod *sm = (staticmethod *)self; 809 PyObject *callable; 810 811 if (!PyArg_UnpackTuple(args, "staticmethod", 1, 1, &callable)) 812 return -1; 813 if (!_PyArg_NoKeywords("staticmethod", kwds)) 814 return -1; 815 Py_INCREF(callable); 816 sm->sm_callable = callable; 817 return 0; 818 } 819 820 static PyMemberDef sm_memberlist[] = { 821 {"__func__", T_OBJECT, offsetof(staticmethod, sm_callable), READONLY}, 822 {NULL} /* Sentinel */ 823 }; 824 825 PyDoc_STRVAR(staticmethod_doc, 826 "staticmethod(function) -> method\n\ 827 \n\ 828 Convert a function to be a static method.\n\ 829 \n\ 830 A static method does not receive an implicit first argument.\n\ 831 To declare a static method, use this idiom:\n\ 832 \n\ 833 class C:\n\ 834 def f(arg1, arg2, ...): ...\n\ 835 f = staticmethod(f)\n\ 836 \n\ 837 It can be called either on the class (e.g. C.f()) or on an instance\n\ 838 (e.g. C().f()). The instance is ignored except for its class.\n\ 839 \n\ 840 Static methods in Python are similar to those found in Java or C++.\n\ 841 For a more advanced concept, see the classmethod builtin."); 842 843 PyTypeObject PyStaticMethod_Type = { 844 PyVarObject_HEAD_INIT(&PyType_Type, 0) 845 "staticmethod", 846 sizeof(staticmethod), 847 0, 848 (destructor)sm_dealloc, /* tp_dealloc */ 849 0, /* tp_print */ 850 0, /* tp_getattr */ 851 0, /* tp_setattr */ 852 0, /* tp_compare */ 853 0, /* tp_repr */ 854 0, /* tp_as_number */ 855 0, /* tp_as_sequence */ 856 0, /* tp_as_mapping */ 857 0, /* tp_hash */ 858 0, /* tp_call */ 859 0, /* tp_str */ 860 PyObject_GenericGetAttr, /* tp_getattro */ 861 0, /* tp_setattro */ 862 0, /* tp_as_buffer */ 863 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, 864 staticmethod_doc, /* tp_doc */ 865 (traverseproc)sm_traverse, /* tp_traverse */ 866 (inquiry)sm_clear, /* tp_clear */ 867 0, /* tp_richcompare */ 868 0, /* tp_weaklistoffset */ 869 0, /* tp_iter */ 870 0, /* tp_iternext */ 871 0, /* tp_methods */ 872 sm_memberlist, /* tp_members */ 873 0, /* tp_getset */ 874 0, /* tp_base */ 875 0, /* tp_dict */ 876 sm_descr_get, /* tp_descr_get */ 877 0, /* tp_descr_set */ 878 0, /* tp_dictoffset */ 879 sm_init, /* tp_init */ 880 PyType_GenericAlloc, /* tp_alloc */ 881 PyType_GenericNew, /* tp_new */ 882 PyObject_GC_Del, /* tp_free */ 883 }; 884 885 PyObject * 886 PyStaticMethod_New(PyObject *callable) 887 { 888 staticmethod *sm = (staticmethod *) 889 PyType_GenericAlloc(&PyStaticMethod_Type, 0); 890 if (sm != NULL) { 891 Py_INCREF(callable); 892 sm->sm_callable = callable; 893 } 894 return (PyObject *)sm; 895 } 896
