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