1
2/* Function object implementation */
3
4#include "Python.h"
5#include "code.h"
6#include "eval.h"
7#include "structmember.h"
8
9PyObject *
10PyFunction_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
63PyObject *
64PyFunction_GetCode(PyObject *op)
65{
66    if (!PyFunction_Check(op)) {
67        PyErr_BadInternalCall();
68        return NULL;
69    }
70    return ((PyFunctionObject *) op) -> func_code;
71}
72
73PyObject *
74PyFunction_GetGlobals(PyObject *op)
75{
76    if (!PyFunction_Check(op)) {
77        PyErr_BadInternalCall();
78        return NULL;
79    }
80    return ((PyFunctionObject *) op) -> func_globals;
81}
82
83PyObject *
84PyFunction_GetModule(PyObject *op)
85{
86    if (!PyFunction_Check(op)) {
87        PyErr_BadInternalCall();
88        return NULL;
89    }
90    return ((PyFunctionObject *) op) -> func_module;
91}
92
93PyObject *
94PyFunction_GetDefaults(PyObject *op)
95{
96    if (!PyFunction_Check(op)) {
97        PyErr_BadInternalCall();
98        return NULL;
99    }
100    return ((PyFunctionObject *) op) -> func_defaults;
101}
102
103int
104PyFunction_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
124PyObject *
125PyFunction_GetClosure(PyObject *op)
126{
127    if (!PyFunction_Check(op)) {
128        PyErr_BadInternalCall();
129        return NULL;
130    }
131    return ((PyFunctionObject *) op) -> func_closure;
132}
133
134int
135PyFunction_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
161static 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
176static int
177restricted(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
186static PyObject *
187func_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
200static int
201func_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
226static PyObject *
227func_get_code(PyFunctionObject *op)
228{
229    if (restricted())
230        return NULL;
231    Py_INCREF(op->func_code);
232    return op->func_code;
233}
234
235static int
236func_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
268static PyObject *
269func_get_name(PyFunctionObject *op)
270{
271    Py_INCREF(op->func_name);
272    return op->func_name;
273}
274
275static int
276func_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
296static PyObject *
297func_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
309static int
310func_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
332static 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
346PyDoc_STRVAR(func_doc,
347"function(code, globals[, name[, argdefs[, closure]]])\n\
348\n\
349Create a function object from a code object and a dictionary.\n\
350The optional name string overrides the name from the code object.\n\
351The optional argdefs tuple specifies the default argument values.\n\
352The 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
364static PyObject *
365func_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
448static void
449func_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
465static PyObject*
466func_repr(PyFunctionObject *op)
467{
468    return PyString_FromFormat("<function %s at %p>",
469                               PyString_AsString(op->func_name),
470                               op);
471}
472
473static int
474func_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
487static PyObject *
488function_call(PyObject *func, PyObject *arg, PyObject *kw)
489{
490    PyObject *result;
491    PyObject *argdefs;
492    PyObject *kwtuple = NULL;
493    PyObject **d, **k;
494    Py_ssize_t nk, nd;
495
496    argdefs = PyFunction_GET_DEFAULTS(func);
497    if (argdefs != NULL && PyTuple_Check(argdefs)) {
498        d = &PyTuple_GET_ITEM((PyTupleObject *)argdefs, 0);
499        nd = PyTuple_GET_SIZE(argdefs);
500    }
501    else {
502        d = NULL;
503        nd = 0;
504    }
505
506    if (kw != NULL && PyDict_Check(kw)) {
507        Py_ssize_t pos, i;
508        nk = PyDict_Size(kw);
509        kwtuple = PyTuple_New(2*nk);
510        if (kwtuple == NULL)
511            return NULL;
512        k = &PyTuple_GET_ITEM(kwtuple, 0);
513        pos = i = 0;
514        while (PyDict_Next(kw, &pos, &k[i], &k[i+1])) {
515            Py_INCREF(k[i]);
516            Py_INCREF(k[i+1]);
517            i += 2;
518        }
519        nk = i/2;
520    }
521    else {
522        k = NULL;
523        nk = 0;
524    }
525
526    result = PyEval_EvalCodeEx(
527        (PyCodeObject *)PyFunction_GET_CODE(func),
528        PyFunction_GET_GLOBALS(func), (PyObject *)NULL,
529        &PyTuple_GET_ITEM(arg, 0), PyTuple_GET_SIZE(arg),
530        k, nk, d, nd,
531        PyFunction_GET_CLOSURE(func));
532
533    Py_XDECREF(kwtuple);
534
535    return result;
536}
537
538/* Bind a function to an object */
539static PyObject *
540func_descr_get(PyObject *func, PyObject *obj, PyObject *type)
541{
542    if (obj == Py_None)
543        obj = NULL;
544    return PyMethod_New(func, obj, type);
545}
546
547PyTypeObject PyFunction_Type = {
548    PyVarObject_HEAD_INIT(&PyType_Type, 0)
549    "function",
550    sizeof(PyFunctionObject),
551    0,
552    (destructor)func_dealloc,                   /* tp_dealloc */
553    0,                                          /* tp_print */
554    0,                                          /* tp_getattr */
555    0,                                          /* tp_setattr */
556    0,                                          /* tp_compare */
557    (reprfunc)func_repr,                        /* tp_repr */
558    0,                                          /* tp_as_number */
559    0,                                          /* tp_as_sequence */
560    0,                                          /* tp_as_mapping */
561    0,                                          /* tp_hash */
562    function_call,                              /* tp_call */
563    0,                                          /* tp_str */
564    PyObject_GenericGetAttr,                    /* tp_getattro */
565    PyObject_GenericSetAttr,                    /* tp_setattro */
566    0,                                          /* tp_as_buffer */
567    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
568    func_doc,                                   /* tp_doc */
569    (traverseproc)func_traverse,                /* tp_traverse */
570    0,                                          /* tp_clear */
571    0,                                          /* tp_richcompare */
572    offsetof(PyFunctionObject, func_weakreflist), /* tp_weaklistoffset */
573    0,                                          /* tp_iter */
574    0,                                          /* tp_iternext */
575    0,                                          /* tp_methods */
576    func_memberlist,                            /* tp_members */
577    func_getsetlist,                            /* tp_getset */
578    0,                                          /* tp_base */
579    0,                                          /* tp_dict */
580    func_descr_get,                             /* tp_descr_get */
581    0,                                          /* tp_descr_set */
582    offsetof(PyFunctionObject, func_dict),      /* tp_dictoffset */
583    0,                                          /* tp_init */
584    0,                                          /* tp_alloc */
585    func_new,                                   /* tp_new */
586};
587
588
589/* Class method object */
590
591/* A class method receives the class as implicit first argument,
592   just like an instance method receives the instance.
593   To declare a class method, use this idiom:
594
595     class C:
596     def f(cls, arg1, arg2, ...): ...
597     f = classmethod(f)
598
599   It can be called either on the class (e.g. C.f()) or on an instance
600   (e.g. C().f()); the instance is ignored except for its class.
601   If a class method is called for a derived class, the derived class
602   object is passed as the implied first argument.
603
604   Class methods are different than C++ or Java static methods.
605   If you want those, see static methods below.
606*/
607
608typedef struct {
609    PyObject_HEAD
610    PyObject *cm_callable;
611} classmethod;
612
613static void
614cm_dealloc(classmethod *cm)
615{
616    _PyObject_GC_UNTRACK((PyObject *)cm);
617    Py_XDECREF(cm->cm_callable);
618    Py_TYPE(cm)->tp_free((PyObject *)cm);
619}
620
621static int
622cm_traverse(classmethod *cm, visitproc visit, void *arg)
623{
624    Py_VISIT(cm->cm_callable);
625    return 0;
626}
627
628static int
629cm_clear(classmethod *cm)
630{
631    Py_CLEAR(cm->cm_callable);
632    return 0;
633}
634
635
636static PyObject *
637cm_descr_get(PyObject *self, PyObject *obj, PyObject *type)
638{
639    classmethod *cm = (classmethod *)self;
640
641    if (cm->cm_callable == NULL) {
642        PyErr_SetString(PyExc_RuntimeError,
643                        "uninitialized classmethod object");
644        return NULL;
645    }
646    if (type == NULL)
647        type = (PyObject *)(Py_TYPE(obj));
648    return PyMethod_New(cm->cm_callable,
649                        type, (PyObject *)(Py_TYPE(type)));
650}
651
652static int
653cm_init(PyObject *self, PyObject *args, PyObject *kwds)
654{
655    classmethod *cm = (classmethod *)self;
656    PyObject *callable;
657
658    if (!PyArg_UnpackTuple(args, "classmethod", 1, 1, &callable))
659        return -1;
660    if (!_PyArg_NoKeywords("classmethod", kwds))
661        return -1;
662    Py_INCREF(callable);
663    cm->cm_callable = callable;
664    return 0;
665}
666
667static PyMemberDef cm_memberlist[] = {
668    {"__func__", T_OBJECT, offsetof(classmethod, cm_callable), READONLY},
669    {NULL}  /* Sentinel */
670};
671
672PyDoc_STRVAR(classmethod_doc,
673"classmethod(function) -> method\n\
674\n\
675Convert a function to be a class method.\n\
676\n\
677A class method receives the class as implicit first argument,\n\
678just like an instance method receives the instance.\n\
679To declare a class method, use this idiom:\n\
680\n\
681  class C:\n\
682      def f(cls, arg1, arg2, ...): ...\n\
683      f = classmethod(f)\n\
684\n\
685It can be called either on the class (e.g. C.f()) or on an instance\n\
686(e.g. C().f()).  The instance is ignored except for its class.\n\
687If a class method is called for a derived class, the derived class\n\
688object is passed as the implied first argument.\n\
689\n\
690Class methods are different than C++ or Java static methods.\n\
691If you want those, see the staticmethod builtin.");
692
693PyTypeObject PyClassMethod_Type = {
694    PyVarObject_HEAD_INIT(&PyType_Type, 0)
695    "classmethod",
696    sizeof(classmethod),
697    0,
698    (destructor)cm_dealloc,                     /* tp_dealloc */
699    0,                                          /* tp_print */
700    0,                                          /* tp_getattr */
701    0,                                          /* tp_setattr */
702    0,                                          /* tp_compare */
703    0,                                          /* tp_repr */
704    0,                                          /* tp_as_number */
705    0,                                          /* tp_as_sequence */
706    0,                                          /* tp_as_mapping */
707    0,                                          /* tp_hash */
708    0,                                          /* tp_call */
709    0,                                          /* tp_str */
710    PyObject_GenericGetAttr,                    /* tp_getattro */
711    0,                                          /* tp_setattro */
712    0,                                          /* tp_as_buffer */
713    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
714    classmethod_doc,                            /* tp_doc */
715    (traverseproc)cm_traverse,                  /* tp_traverse */
716    (inquiry)cm_clear,                          /* tp_clear */
717    0,                                          /* tp_richcompare */
718    0,                                          /* tp_weaklistoffset */
719    0,                                          /* tp_iter */
720    0,                                          /* tp_iternext */
721    0,                                          /* tp_methods */
722    cm_memberlist,              /* tp_members */
723    0,                                          /* tp_getset */
724    0,                                          /* tp_base */
725    0,                                          /* tp_dict */
726    cm_descr_get,                               /* tp_descr_get */
727    0,                                          /* tp_descr_set */
728    0,                                          /* tp_dictoffset */
729    cm_init,                                    /* tp_init */
730    PyType_GenericAlloc,                        /* tp_alloc */
731    PyType_GenericNew,                          /* tp_new */
732    PyObject_GC_Del,                            /* tp_free */
733};
734
735PyObject *
736PyClassMethod_New(PyObject *callable)
737{
738    classmethod *cm = (classmethod *)
739        PyType_GenericAlloc(&PyClassMethod_Type, 0);
740    if (cm != NULL) {
741        Py_INCREF(callable);
742        cm->cm_callable = callable;
743    }
744    return (PyObject *)cm;
745}
746
747
748/* Static method object */
749
750/* A static method does not receive an implicit first argument.
751   To declare a static method, use this idiom:
752
753     class C:
754     def f(arg1, arg2, ...): ...
755     f = staticmethod(f)
756
757   It can be called either on the class (e.g. C.f()) or on an instance
758   (e.g. C().f()); the instance is ignored except for its class.
759
760   Static methods in Python are similar to those found in Java or C++.
761   For a more advanced concept, see class methods above.
762*/
763
764typedef struct {
765    PyObject_HEAD
766    PyObject *sm_callable;
767} staticmethod;
768
769static void
770sm_dealloc(staticmethod *sm)
771{
772    _PyObject_GC_UNTRACK((PyObject *)sm);
773    Py_XDECREF(sm->sm_callable);
774    Py_TYPE(sm)->tp_free((PyObject *)sm);
775}
776
777static int
778sm_traverse(staticmethod *sm, visitproc visit, void *arg)
779{
780    Py_VISIT(sm->sm_callable);
781    return 0;
782}
783
784static int
785sm_clear(staticmethod *sm)
786{
787    Py_XDECREF(sm->sm_callable);
788    sm->sm_callable = NULL;
789
790    return 0;
791}
792
793static PyObject *
794sm_descr_get(PyObject *self, PyObject *obj, PyObject *type)
795{
796    staticmethod *sm = (staticmethod *)self;
797
798    if (sm->sm_callable == NULL) {
799        PyErr_SetString(PyExc_RuntimeError,
800                        "uninitialized staticmethod object");
801        return NULL;
802    }
803    Py_INCREF(sm->sm_callable);
804    return sm->sm_callable;
805}
806
807static int
808sm_init(PyObject *self, PyObject *args, PyObject *kwds)
809{
810    staticmethod *sm = (staticmethod *)self;
811    PyObject *callable;
812
813    if (!PyArg_UnpackTuple(args, "staticmethod", 1, 1, &callable))
814        return -1;
815    if (!_PyArg_NoKeywords("staticmethod", kwds))
816        return -1;
817    Py_INCREF(callable);
818    sm->sm_callable = callable;
819    return 0;
820}
821
822static PyMemberDef sm_memberlist[] = {
823    {"__func__", T_OBJECT, offsetof(staticmethod, sm_callable), READONLY},
824    {NULL}  /* Sentinel */
825};
826
827PyDoc_STRVAR(staticmethod_doc,
828"staticmethod(function) -> method\n\
829\n\
830Convert a function to be a static method.\n\
831\n\
832A static method does not receive an implicit first argument.\n\
833To declare a static method, use this idiom:\n\
834\n\
835     class C:\n\
836     def f(arg1, arg2, ...): ...\n\
837     f = staticmethod(f)\n\
838\n\
839It can be called either on the class (e.g. C.f()) or on an instance\n\
840(e.g. C().f()).  The instance is ignored except for its class.\n\
841\n\
842Static methods in Python are similar to those found in Java or C++.\n\
843For a more advanced concept, see the classmethod builtin.");
844
845PyTypeObject PyStaticMethod_Type = {
846    PyVarObject_HEAD_INIT(&PyType_Type, 0)
847    "staticmethod",
848    sizeof(staticmethod),
849    0,
850    (destructor)sm_dealloc,                     /* tp_dealloc */
851    0,                                          /* tp_print */
852    0,                                          /* tp_getattr */
853    0,                                          /* tp_setattr */
854    0,                                          /* tp_compare */
855    0,                                          /* tp_repr */
856    0,                                          /* tp_as_number */
857    0,                                          /* tp_as_sequence */
858    0,                                          /* tp_as_mapping */
859    0,                                          /* tp_hash */
860    0,                                          /* tp_call */
861    0,                                          /* tp_str */
862    PyObject_GenericGetAttr,                    /* tp_getattro */
863    0,                                          /* tp_setattro */
864    0,                                          /* tp_as_buffer */
865    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
866    staticmethod_doc,                           /* tp_doc */
867    (traverseproc)sm_traverse,                  /* tp_traverse */
868    (inquiry)sm_clear,                          /* tp_clear */
869    0,                                          /* tp_richcompare */
870    0,                                          /* tp_weaklistoffset */
871    0,                                          /* tp_iter */
872    0,                                          /* tp_iternext */
873    0,                                          /* tp_methods */
874    sm_memberlist,              /* tp_members */
875    0,                                          /* tp_getset */
876    0,                                          /* tp_base */
877    0,                                          /* tp_dict */
878    sm_descr_get,                               /* tp_descr_get */
879    0,                                          /* tp_descr_set */
880    0,                                          /* tp_dictoffset */
881    sm_init,                                    /* tp_init */
882    PyType_GenericAlloc,                        /* tp_alloc */
883    PyType_GenericNew,                          /* tp_new */
884    PyObject_GC_Del,                            /* tp_free */
885};
886
887PyObject *
888PyStaticMethod_New(PyObject *callable)
889{
890    staticmethod *sm = (staticmethod *)
891        PyType_GenericAlloc(&PyStaticMethod_Type, 0);
892    if (sm != NULL) {
893        Py_INCREF(callable);
894        sm->sm_callable = callable;
895    }
896    return (PyObject *)sm;
897}
898