source: vendor/python/2.5/Objects/funcobject.c

Last change on this file was 3225, checked in by bird, 18 years ago

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