/Objects/funcobject.c

  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}