source: python/vendor/Python-2.6.5/Objects/funcobject.c

Last change on this file was 2, checked in by Yuri Dario, 15 years ago

Initial import for vendor code.
  • Property svn:eol-style set to native
File size: 21.2 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 {"__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 **d, **k;
493 Py_ssize_t nk, nd;
494
495 argdefs = PyFunction_GET_DEFAULTS(func);
496 if (argdefs != NULL && PyTuple_Check(argdefs)) {
497 d = &PyTuple_GET_ITEM((PyTupleObject *)argdefs, 0);
498 nd = PyTuple_Size(argdefs);
499 }
500 else {
501 d = NULL;
502 nd = 0;
503 }
504
505 if (kw != NULL && PyDict_Check(kw)) {
506 Py_ssize_t pos, i;
507 nk = PyDict_Size(kw);
508 k = PyMem_NEW(PyObject *, 2*nk);
509 if (k == NULL) {
510 PyErr_NoMemory();
511 return NULL;
512 }
513 pos = i = 0;
514 while (PyDict_Next(kw, &pos, &k[i], &k[i+1]))
515 i += 2;
516 nk = i/2;
517 /* XXX This is broken if the caller deletes dict items! */
518 }
519 else {
520 k = NULL;
521 nk = 0;
522 }
523
524 result = PyEval_EvalCodeEx(
525 (PyCodeObject *)PyFunction_GET_CODE(func),
526 PyFunction_GET_GLOBALS(func), (PyObject *)NULL,
527 &PyTuple_GET_ITEM(arg, 0), PyTuple_Size(arg),
528 k, nk, d, nd,
529 PyFunction_GET_CLOSURE(func));
530
531 if (k != NULL)
532 PyMem_DEL(k);
533
534 return result;
535}
536
537/* Bind a function to an object */
538static PyObject *
539func_descr_get(PyObject *func, PyObject *obj, PyObject *type)
540{
541 if (obj == Py_None)
542 obj = NULL;
543 return PyMethod_New(func, obj, type);
544}
545
546PyTypeObject PyFunction_Type = {
547 PyVarObject_HEAD_INIT(&PyType_Type, 0)
548 "function",
549 sizeof(PyFunctionObject),
550 0,
551 (destructor)func_dealloc, /* tp_dealloc */
552 0, /* tp_print */
553 0, /* tp_getattr */
554 0, /* tp_setattr */
555 0, /* tp_compare */
556 (reprfunc)func_repr, /* tp_repr */
557 0, /* tp_as_number */
558 0, /* tp_as_sequence */
559 0, /* tp_as_mapping */
560 0, /* tp_hash */
561 function_call, /* tp_call */
562 0, /* tp_str */
563 PyObject_GenericGetAttr, /* tp_getattro */
564 PyObject_GenericSetAttr, /* tp_setattro */
565 0, /* tp_as_buffer */
566 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
567 func_doc, /* tp_doc */
568 (traverseproc)func_traverse, /* tp_traverse */
569 0, /* tp_clear */
570 0, /* tp_richcompare */
571 offsetof(PyFunctionObject, func_weakreflist), /* tp_weaklistoffset */
572 0, /* tp_iter */
573 0, /* tp_iternext */
574 0, /* tp_methods */
575 func_memberlist, /* tp_members */
576 func_getsetlist, /* tp_getset */
577 0, /* tp_base */
578 0, /* tp_dict */
579 func_descr_get, /* tp_descr_get */
580 0, /* tp_descr_set */
581 offsetof(PyFunctionObject, func_dict), /* tp_dictoffset */
582 0, /* tp_init */
583 0, /* tp_alloc */
584 func_new, /* tp_new */
585};
586
587
588/* Class method object */
589
590/* A class method receives the class as implicit first argument,
591 just like an instance method receives the instance.
592 To declare a class method, use this idiom:
593
594 class C:
595 def f(cls, arg1, arg2, ...): ...
596 f = classmethod(f)
597
598 It can be called either on the class (e.g. C.f()) or on an instance
599 (e.g. C().f()); the instance is ignored except for its class.
600 If a class method is called for a derived class, the derived class
601 object is passed as the implied first argument.
602
603 Class methods are different than C++ or Java static methods.
604 If you want those, see static methods below.
605*/
606
607typedef struct {
608 PyObject_HEAD
609 PyObject *cm_callable;
610} classmethod;
611
612static void
613cm_dealloc(classmethod *cm)
614{
615 _PyObject_GC_UNTRACK((PyObject *)cm);
616 Py_XDECREF(cm->cm_callable);
617 Py_TYPE(cm)->tp_free((PyObject *)cm);
618}
619
620static int
621cm_traverse(classmethod *cm, visitproc visit, void *arg)
622{
623 Py_VISIT(cm->cm_callable);
624 return 0;
625}
626
627static int
628cm_clear(classmethod *cm)
629{
630 Py_CLEAR(cm->cm_callable);
631 return 0;
632}
633
634
635static PyObject *
636cm_descr_get(PyObject *self, PyObject *obj, PyObject *type)
637{
638 classmethod *cm = (classmethod *)self;
639
640 if (cm->cm_callable == NULL) {
641 PyErr_SetString(PyExc_RuntimeError,
642 "uninitialized classmethod object");
643 return NULL;
644 }
645 if (type == NULL)
646 type = (PyObject *)(Py_TYPE(obj));
647 return PyMethod_New(cm->cm_callable,
648 type, (PyObject *)(Py_TYPE(type)));
649}
650
651static int
652cm_init(PyObject *self, PyObject *args, PyObject *kwds)
653{
654 classmethod *cm = (classmethod *)self;
655 PyObject *callable;
656
657 if (!PyArg_UnpackTuple(args, "classmethod", 1, 1, &callable))
658 return -1;
659 if (!_PyArg_NoKeywords("classmethod", kwds))
660 return -1;
661 if (!PyCallable_Check(callable)) {
662 PyErr_Format(PyExc_TypeError, "'%s' object is not callable",
663 callable->ob_type->tp_name);
664 return -1;
665 }
666
667 Py_INCREF(callable);
668 cm->cm_callable = callable;
669 return 0;
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 0, /* 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
822PyDoc_STRVAR(staticmethod_doc,
823"staticmethod(function) -> method\n\
824\n\
825Convert a function to be a static method.\n\
826\n\
827A static method does not receive an implicit first argument.\n\
828To declare a static method, use this idiom:\n\
829\n\
830 class C:\n\
831 def f(arg1, arg2, ...): ...\n\
832 f = staticmethod(f)\n\
833\n\
834It can be called either on the class (e.g. C.f()) or on an instance\n\
835(e.g. C().f()). The instance is ignored except for its class.\n\
836\n\
837Static methods in Python are similar to those found in Java or C++.\n\
838For a more advanced concept, see the classmethod builtin.");
839
840PyTypeObject PyStaticMethod_Type = {
841 PyVarObject_HEAD_INIT(&PyType_Type, 0)
842 "staticmethod",
843 sizeof(staticmethod),
844 0,
845 (destructor)sm_dealloc, /* tp_dealloc */
846 0, /* tp_print */
847 0, /* tp_getattr */
848 0, /* tp_setattr */
849 0, /* tp_compare */
850 0, /* tp_repr */
851 0, /* tp_as_number */
852 0, /* tp_as_sequence */
853 0, /* tp_as_mapping */
854 0, /* tp_hash */
855 0, /* tp_call */
856 0, /* tp_str */
857 PyObject_GenericGetAttr, /* tp_getattro */
858 0, /* tp_setattro */
859 0, /* tp_as_buffer */
860 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
861 staticmethod_doc, /* tp_doc */
862 (traverseproc)sm_traverse, /* tp_traverse */
863 (inquiry)sm_clear, /* tp_clear */
864 0, /* tp_richcompare */
865 0, /* tp_weaklistoffset */
866 0, /* tp_iter */
867 0, /* tp_iternext */
868 0, /* tp_methods */
869 0, /* tp_members */
870 0, /* tp_getset */
871 0, /* tp_base */
872 0, /* tp_dict */
873 sm_descr_get, /* tp_descr_get */
874 0, /* tp_descr_set */
875 0, /* tp_dictoffset */
876 sm_init, /* tp_init */
877 PyType_GenericAlloc, /* tp_alloc */
878 PyType_GenericNew, /* tp_new */
879 PyObject_GC_Del, /* tp_free */
880};
881
882PyObject *
883PyStaticMethod_New(PyObject *callable)
884{
885 staticmethod *sm = (staticmethod *)
886 PyType_GenericAlloc(&PyStaticMethod_Type, 0);
887 if (sm != NULL) {
888 Py_INCREF(callable);
889 sm->sm_callable = callable;
890 }
891 return (PyObject *)sm;
892}
Note: See TracBrowser for help on using the repository browser.