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