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