Objects/funcobject.c

   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 **d, **k;
 493         Py_ssize_t nk, nd;
 494
 495         argdefs = PyFunction_GET_DEFAULTS(func);
 496         if (argdefs != NULL && PyTuple_Check(argdefs)) {
 497                 d = &PyTuple_GET_ITEM((PyTupleObject *)argdefs, 0);
 498                 nd = PyTuple_Size(argdefs);
 499         }
 500         else {
 501                 d = NULL;
 502                 nd = 0;
 503         }
 504
 505         if (kw != NULL && PyDict_Check(kw)) {
 506                 Py_ssize_t pos, i;
 507                 nk = PyDict_Size(kw);
 508                 k = PyMem_NEW(PyObject *, 2*nk);
 509                 if (k == NULL) {
 510                         PyErr_NoMemory();
 511                         return NULL;
 512                 }
 513                 pos = i = 0;
 514                 while (PyDict_Next(kw, &pos, &k[i], &k[i+1]))
 515                         i += 2;
 516                 nk = i/2;
 517                 /* XXX This is broken if the caller deletes dict items! */
 518         }
 519         else {
 520                 k = NULL;
 521                 nk = 0;
 522         }
 523
 524         result = PyEval_EvalCodeEx(
 525                 (PyCodeObject *)PyFunction_GET_CODE(func),
 526                 PyFunction_GET_GLOBALS(func), (PyObject *)NULL,
 527                 &PyTuple_GET_ITEM(arg, 0), PyTuple_Size(arg),
 528                 k, nk, d, nd,
 529                 PyFunction_GET_CLOSURE(func));
 530
 531         if (k != NULL)
 532                 PyMem_DEL(k);
 533
 534         return result;
 535 }
 536
 537 /* Bind a function to an object */
 538 static PyObject *
 539 func_descr_get(PyObject *func, PyObject *obj, PyObject *type)
 540 {
 541         if (obj == Py_None)
 542                 obj = NULL;
 543         return PyMethod_New(func, obj, type);
 544 }
 545
 546 PyTypeObject PyFunction_Type = {
 547         PyVarObject_HEAD_INIT(&PyType_Type, 0)
 548         "function",
 549         sizeof(PyFunctionObject),
 550         0,
 551         (destructor)func_dealloc,               /* tp_dealloc */
 552         0,                                      /* tp_print */
 553         0,                                      /* tp_getattr */
 554         0,                                      /* tp_setattr */
 555         0,                                      /* tp_compare */
 556         (reprfunc)func_repr,                    /* tp_repr */
 557         0,                                      /* tp_as_number */
 558         0,                                      /* tp_as_sequence */
 559         0,                                      /* tp_as_mapping */
 560         0,                                      /* tp_hash */
 561         function_call,                          /* tp_call */
 562         0,                                      /* tp_str */
 563         PyObject_GenericGetAttr,                /* tp_getattro */
 564         PyObject_GenericSetAttr,                /* tp_setattro */
 565         0,                                      /* tp_as_buffer */
 566         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
 567         func_doc,                               /* tp_doc */
 568         (traverseproc)func_traverse,            /* tp_traverse */
 569         0,                                      /* tp_clear */
 570         0,                                      /* tp_richcompare */
 571         offsetof(PyFunctionObject, func_weakreflist), /* tp_weaklistoffset */
 572         0,                                      /* tp_iter */
 573         0,                                      /* tp_iternext */
 574         0,                                      /* tp_methods */
 575         func_memberlist,                        /* tp_members */
 576         func_getsetlist,                        /* tp_getset */
 577         0,                                      /* tp_base */
 578         0,                                      /* tp_dict */
 579         func_descr_get,                         /* tp_descr_get */
 580         0,                                      /* tp_descr_set */
 581         offsetof(PyFunctionObject, func_dict),  /* tp_dictoffset */
 582         0,                                      /* tp_init */
 583         0,                                      /* tp_alloc */
 584         func_new,                               /* tp_new */
 585 };
 586
 587
 588 /* Class method object */
 589
 590 /* A class method receives the class as implicit first argument,
 591    just like an instance method receives the instance.
 592    To declare a class method, use this idiom:
 593
 594      class C:
 595          def f(cls, arg1, arg2, ...): ...
 596          f = classmethod(f)
 597
 598    It can be called either on the class (e.g. C.f()) or on an instance
 599    (e.g. C().f()); the instance is ignored except for its class.
 600    If a class method is called for a derived class, the derived class
 601    object is passed as the implied first argument.
 602
 603    Class methods are different than C++ or Java static methods.
 604    If you want those, see static methods below.
 605 */
 606
 607 typedef struct {
 608         PyObject_HEAD
 609         PyObject *cm_callable;
 610 } classmethod;
 611
 612 static void
 613 cm_dealloc(classmethod *cm)
 614 {
 615         _PyObject_GC_UNTRACK((PyObject *)cm);
 616         Py_XDECREF(cm->cm_callable);
 617         Py_TYPE(cm)->tp_free((PyObject *)cm);
 618 }
 619
 620 static int
 621 cm_traverse(classmethod *cm, visitproc visit, void *arg)
 622 {
 623         Py_VISIT(cm->cm_callable);
 624         return 0;
 625 }
 626
 627 static int
 628 cm_clear(classmethod *cm)
 629 {
 630         Py_CLEAR(cm->cm_callable);
 631         return 0;
 632 }
 633
 634
 635 static PyObject *
 636 cm_descr_get(PyObject *self, PyObject *obj, PyObject *type)
 637 {
 638         classmethod *cm = (classmethod *)self;
 639
 640         if (cm->cm_callable == NULL) {
 641                 PyErr_SetString(PyExc_RuntimeError,
 642                                 "uninitialized classmethod object");
 643                 return NULL;
 644         }
 645         if (type == NULL)
 646                 type = (PyObject *)(Py_TYPE(obj));
 647         return PyMethod_New(cm->cm_callable,
 648                             type, (PyObject *)(Py_TYPE(type)));
 649 }
 650
 651 static int
 652 cm_init(PyObject *self, PyObject *args, PyObject *kwds)
 653 {
 654         classmethod *cm = (classmethod *)self;
 655         PyObject *callable;
 656
 657         if (!PyArg_UnpackTuple(args, "classmethod", 1, 1, &callable))
 658                 return -1;
 659         if (!_PyArg_NoKeywords("classmethod", kwds))
 660                 return -1;
 661         if (!PyCallable_Check(callable)) {
 662                 PyErr_Format(PyExc_TypeError, "'%s' object is not callable",
 663                      callable->ob_type->tp_name);
 664                 return -1;
 665         }
 666
 667         Py_INCREF(callable);
 668         cm->cm_callable = callable;
 669         return 0;
 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         0,                                      /* 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_XDECREF(sm->sm_callable);
 788         sm->sm_callable = NULL;
 789
 790         return 0;
 791 }
 792
 793 static PyObject *
 794 sm_descr_get(PyObject *self, PyObject *obj, PyObject *type)
 795 {
 796         staticmethod *sm = (staticmethod *)self;
 797
 798         if (sm->sm_callable == NULL) {
 799                 PyErr_SetString(PyExc_RuntimeError,
 800                                 "uninitialized staticmethod object");
 801                 return NULL;
 802         }
 803         Py_INCREF(sm->sm_callable);
 804         return sm->sm_callable;
 805 }
 806
 807 static int
 808 sm_init(PyObject *self, PyObject *args, PyObject *kwds)
 809 {
 810         staticmethod *sm = (staticmethod *)self;
 811         PyObject *callable;
 812
 813         if (!PyArg_UnpackTuple(args, "staticmethod", 1, 1, &callable))
 814                 return -1;
 815         if (!_PyArg_NoKeywords("staticmethod", kwds))
 816                 return -1;
 817         Py_INCREF(callable);
 818         sm->sm_callable = callable;
 819         return 0;
 820 }
 821
 822 PyDoc_STRVAR(staticmethod_doc,
 823 "staticmethod(function) -> method\n\
 824 \n\
 825 Convert a function to be a static method.\n\
 826 \n\
 827 A static method does not receive an implicit first argument.\n\
 828 To declare a static method, use this idiom:\n\
 829 \n\
 830      class C:\n\
 831          def f(arg1, arg2, ...): ...\n\
 832          f = staticmethod(f)\n\
 833 \n\
 834 It can be called either on the class (e.g. C.f()) or on an instance\n\
 835 (e.g. C().f()).  The instance is ignored except for its class.\n\
 836 \n\
 837 Static methods in Python are similar to those found in Java or C++.\n\
 838 For a more advanced concept, see the classmethod builtin.");
 839
 840 PyTypeObject PyStaticMethod_Type = {
 841         PyVarObject_HEAD_INIT(&PyType_Type, 0)
 842         "staticmethod",
 843         sizeof(staticmethod),
 844         0,
 845         (destructor)sm_dealloc,                 /* tp_dealloc */
 846         0,                                      /* tp_print */
 847         0,                                      /* tp_getattr */
 848         0,                                      /* tp_setattr */
 849         0,                                      /* tp_compare */
 850         0,                                      /* tp_repr */
 851         0,                                      /* tp_as_number */
 852         0,                                      /* tp_as_sequence */
 853         0,                                      /* tp_as_mapping */
 854         0,                                      /* tp_hash */
 855         0,                                      /* tp_call */
 856         0,                                      /* tp_str */
 857         PyObject_GenericGetAttr,                /* tp_getattro */
 858         0,                                      /* tp_setattro */
 859         0,                                      /* tp_as_buffer */
 860         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
 861         staticmethod_doc,                       /* tp_doc */
 862         (traverseproc)sm_traverse,              /* tp_traverse */
 863         (inquiry)sm_clear,                      /* tp_clear */
 864         0,                                      /* tp_richcompare */
 865         0,                                      /* tp_weaklistoffset */
 866         0,                                      /* tp_iter */
 867         0,                                      /* tp_iternext */
 868         0,                                      /* tp_methods */
 869         0,                                      /* tp_members */
 870         0,                                      /* tp_getset */
 871         0,                                      /* tp_base */
 872         0,                                      /* tp_dict */
 873         sm_descr_get,                           /* tp_descr_get */
 874         0,                                      /* tp_descr_set */
 875         0,                                      /* tp_dictoffset */
 876         sm_init,                                /* tp_init */
 877         PyType_GenericAlloc,                    /* tp_alloc */
 878         PyType_GenericNew,                      /* tp_new */
 879         PyObject_GC_Del,                        /* tp_free */
 880 };
 881
 882 PyObject *
 883 PyStaticMethod_New(PyObject *callable)
 884 {
 885         staticmethod *sm = (staticmethod *)
 886                 PyType_GenericAlloc(&PyStaticMethod_Type, 0);
 887         if (sm != NULL) {
 888                 Py_INCREF(callable);
 889                 sm->sm_callable = callable;
 890         }
 891         return (PyObject *)sm;
 892 }