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