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 static PyMemberDef cm_memberlist[] = {
 673         {"__func__", T_OBJECT, offsetof(classmethod, cm_callable), READONLY},
 674         {NULL}  /* Sentinel */
 675 };
 676
 677 PyDoc_STRVAR(classmethod_doc,
 678 "classmethod(function) -> method\n\
 679 \n\
 680 Convert a function to be a class method.\n\
 681 \n\
 682 A class method receives the class as implicit first argument,\n\
 683 just like an instance method receives the instance.\n\
 684 To declare a class method, use this idiom:\n\
 685 \n\
 686   class C:\n\
 687       def f(cls, arg1, arg2, ...): ...\n\
 688       f = classmethod(f)\n\
 689 \n\
 690 It can be called either on the class (e.g. C.f()) or on an instance\n\
 691 (e.g. C().f()).  The instance is ignored except for its class.\n\
 692 If a class method is called for a derived class, the derived class\n\
 693 object is passed as the implied first argument.\n\
 694 \n\
 695 Class methods are different than C++ or Java static methods.\n\
 696 If you want those, see the staticmethod builtin.");
 697
 698 PyTypeObject PyClassMethod_Type = {
 699         PyVarObject_HEAD_INIT(&PyType_Type, 0)
 700         "classmethod",
 701         sizeof(classmethod),
 702         0,
 703         (destructor)cm_dealloc,                 /* tp_dealloc */
 704         0,                                      /* tp_print */
 705         0,                                      /* tp_getattr */
 706         0,                                      /* tp_setattr */
 707         0,                                      /* tp_compare */
 708         0,                                      /* tp_repr */
 709         0,                                      /* tp_as_number */
 710         0,                                      /* tp_as_sequence */
 711         0,                                      /* tp_as_mapping */
 712         0,                                      /* tp_hash */
 713         0,                                      /* tp_call */
 714         0,                                      /* tp_str */
 715         PyObject_GenericGetAttr,                /* tp_getattro */
 716         0,                                      /* tp_setattro */
 717         0,                                      /* tp_as_buffer */
 718         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
 719         classmethod_doc,                        /* tp_doc */
 720         (traverseproc)cm_traverse,              /* tp_traverse */
 721         (inquiry)cm_clear,                      /* tp_clear */
 722         0,                                      /* tp_richcompare */
 723         0,                                      /* tp_weaklistoffset */
 724         0,                                      /* tp_iter */
 725         0,                                      /* tp_iternext */
 726         0,                                      /* tp_methods */
 727         cm_memberlist,          /* tp_members */
 728         0,                                      /* tp_getset */
 729         0,                                      /* tp_base */
 730         0,                                      /* tp_dict */
 731         cm_descr_get,                           /* tp_descr_get */
 732         0,                                      /* tp_descr_set */
 733         0,                                      /* tp_dictoffset */
 734         cm_init,                                /* tp_init */
 735         PyType_GenericAlloc,                    /* tp_alloc */
 736         PyType_GenericNew,                      /* tp_new */
 737         PyObject_GC_Del,                        /* tp_free */
 738 };
 739
 740 PyObject *
 741 PyClassMethod_New(PyObject *callable)
 742 {
 743         classmethod *cm = (classmethod *)
 744                 PyType_GenericAlloc(&PyClassMethod_Type, 0);
 745         if (cm != NULL) {
 746                 Py_INCREF(callable);
 747                 cm->cm_callable = callable;
 748         }
 749         return (PyObject *)cm;
 750 }
 751
 752
 753 /* Static method object */
 754
 755 /* A static method does not receive an implicit first argument.
 756    To declare a static method, use this idiom:
 757
 758      class C:
 759          def f(arg1, arg2, ...): ...
 760          f = staticmethod(f)
 761
 762    It can be called either on the class (e.g. C.f()) or on an instance
 763    (e.g. C().f()); the instance is ignored except for its class.
 764
 765    Static methods in Python are similar to those found in Java or C++.
 766    For a more advanced concept, see class methods above.
 767 */
 768
 769 typedef struct {
 770         PyObject_HEAD
 771         PyObject *sm_callable;
 772 } staticmethod;
 773
 774 static void
 775 sm_dealloc(staticmethod *sm)
 776 {
 777         _PyObject_GC_UNTRACK((PyObject *)sm);
 778         Py_XDECREF(sm->sm_callable);
 779         Py_TYPE(sm)->tp_free((PyObject *)sm);
 780 }
 781
 782 static int
 783 sm_traverse(staticmethod *sm, visitproc visit, void *arg)
 784 {
 785         Py_VISIT(sm->sm_callable);
 786         return 0;
 787 }
 788
 789 static int
 790 sm_clear(staticmethod *sm)
 791 {
 792         Py_XDECREF(sm->sm_callable);
 793         sm->sm_callable = NULL;
 794
 795         return 0;
 796 }
 797
 798 static PyObject *
 799 sm_descr_get(PyObject *self, PyObject *obj, PyObject *type)
 800 {
 801         staticmethod *sm = (staticmethod *)self;
 802
 803         if (sm->sm_callable == NULL) {
 804                 PyErr_SetString(PyExc_RuntimeError,
 805                                 "uninitialized staticmethod object");
 806                 return NULL;
 807         }
 808         Py_INCREF(sm->sm_callable);
 809         return sm->sm_callable;
 810 }
 811
 812 static int
 813 sm_init(PyObject *self, PyObject *args, PyObject *kwds)
 814 {
 815         staticmethod *sm = (staticmethod *)self;
 816         PyObject *callable;
 817
 818         if (!PyArg_UnpackTuple(args, "staticmethod", 1, 1, &callable))
 819                 return -1;
 820         if (!_PyArg_NoKeywords("staticmethod", kwds))
 821                 return -1;
 822         Py_INCREF(callable);
 823         sm->sm_callable = callable;
 824         return 0;
 825 }
 826
 827 static PyMemberDef sm_memberlist[] = {
 828         {"__func__", T_OBJECT, offsetof(staticmethod, sm_callable), READONLY},
 829         {NULL}  /* Sentinel */
 830 };
 831
 832 PyDoc_STRVAR(staticmethod_doc,
 833 "staticmethod(function) -> method\n\
 834 \n\
 835 Convert a function to be a static method.\n\
 836 \n\
 837 A static method does not receive an implicit first argument.\n\
 838 To declare a static method, use this idiom:\n\
 839 \n\
 840      class C:\n\
 841          def f(arg1, arg2, ...): ...\n\
 842          f = staticmethod(f)\n\
 843 \n\
 844 It can be called either on the class (e.g. C.f()) or on an instance\n\
 845 (e.g. C().f()).  The instance is ignored except for its class.\n\
 846 \n\
 847 Static methods in Python are similar to those found in Java or C++.\n\
 848 For a more advanced concept, see the classmethod builtin.");
 849
 850 PyTypeObject PyStaticMethod_Type = {
 851         PyVarObject_HEAD_INIT(&PyType_Type, 0)
 852         "staticmethod",
 853         sizeof(staticmethod),
 854         0,
 855         (destructor)sm_dealloc,                 /* tp_dealloc */
 856         0,                                      /* tp_print */
 857         0,                                      /* tp_getattr */
 858         0,                                      /* tp_setattr */
 859         0,                                      /* tp_compare */
 860         0,                                      /* tp_repr */
 861         0,                                      /* tp_as_number */
 862         0,                                      /* tp_as_sequence */
 863         0,                                      /* tp_as_mapping */
 864         0,                                      /* tp_hash */
 865         0,                                      /* tp_call */
 866         0,                                      /* tp_str */
 867         PyObject_GenericGetAttr,                /* tp_getattro */
 868         0,                                      /* tp_setattro */
 869         0,                                      /* tp_as_buffer */
 870         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
 871         staticmethod_doc,                       /* tp_doc */
 872         (traverseproc)sm_traverse,              /* tp_traverse */
 873         (inquiry)sm_clear,                      /* tp_clear */
 874         0,                                      /* tp_richcompare */
 875         0,                                      /* tp_weaklistoffset */
 876         0,                                      /* tp_iter */
 877         0,                                      /* tp_iternext */
 878         0,                                      /* tp_methods */
 879         sm_memberlist,          /* tp_members */
 880         0,                                      /* tp_getset */
 881         0,                                      /* tp_base */
 882         0,                                      /* tp_dict */
 883         sm_descr_get,                           /* tp_descr_get */
 884         0,                                      /* tp_descr_set */
 885         0,                                      /* tp_dictoffset */
 886         sm_init,                                /* tp_init */
 887         PyType_GenericAlloc,                    /* tp_alloc */
 888         PyType_GenericNew,                      /* tp_new */
 889         PyObject_GC_Del,                        /* tp_free */
 890 };
 891
 892 PyObject *
 893 PyStaticMethod_New(PyObject *callable)
 894 {
 895         staticmethod *sm = (staticmethod *)
 896                 PyType_GenericAlloc(&PyStaticMethod_Type, 0);
 897         if (sm != NULL) {
 898                 Py_INCREF(callable);
 899                 sm->sm_callable = callable;
 900         }
 901         return (PyObject *)sm;
 902 }