Objects/funcobject.c

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