History

add hg and python

cinap_lenrek committed 15 years ago

Commit 4bb9e221 parent 987265c3706 files · +1228772 −-233Browse files

Showing the changes to sys/src/cmd/python/Objects/funcobject.c (1 of 3706 files). Show all

Unified · Split

sys/src/cmd/python/Objects/funcobject.c+888−0
@@ -0,0 +1,888 @@
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 *
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 *
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 *
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 *
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 *
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
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_XDECREF(((PyFunctionObject *) op) -> func_defaults);
120+ ((PyFunctionObject *) op) -> func_defaults = defaults;
121+ return 0;
122+}
123+
124+PyObject *
125+PyFunction_GetClosure(PyObject *op)
126+{
127+ if (!PyFunction_Check(op)) {
128+ PyErr_BadInternalCall();
129+ return NULL;
130+ }
131+ return ((PyFunctionObject *) op) -> func_closure;
132+}
133+
134+int
135+PyFunction_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+
161+static 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+
172+static int
173+restricted(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+
182+static PyObject *
183+func_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+
196+static int
197+func_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+
222+static PyObject *
223+func_get_code(PyFunctionObject *op)
224+{
225+ if (restricted())
226+ return NULL;
227+ Py_INCREF(op->func_code);
228+ return op->func_code;
229+}
230+
231+static int
232+func_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+
264+static PyObject *
265+func_get_name(PyFunctionObject *op)
266+{
267+ Py_INCREF(op->func_name);
268+ return op->func_name;
269+}
270+
271+static int
272+func_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+
292+static PyObject *
293+func_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+
305+static int
306+func_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+
328+static 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+
339+PyDoc_STRVAR(func_doc,
340+"function(code, globals[, name[, argdefs[, closure]]])\n\
341+\n\
342+Create a function object from a code object and a dictionary.\n\
343+The optional name string overrides the name from the code object.\n\
344+The optional argdefs tuple specifies the default argument values.\n\
345+The 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+
357+static PyObject *
358+func_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+
441+static void
442+func_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+
458+static PyObject*
459+func_repr(PyFunctionObject *op)
460+{
461+ return PyString_FromFormat("<function %s at %p>",
462+ PyString_AsString(op->func_name),
463+ op);
464+}
465+
466+static int
467+func_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+
480+static PyObject *
481+function_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 */
531+static PyObject *
532+func_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+
539+PyTypeObject 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+
601+typedef struct {
602+ PyObject_HEAD
603+ PyObject *cm_callable;
604+} classmethod;
605+
606+static void
607+cm_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+
614+static int
615+cm_traverse(classmethod *cm, visitproc visit, void *arg)
616+{
617+ Py_VISIT(cm->cm_callable);
618+ return 0;
619+}
620+
621+static int
622+cm_clear(classmethod *cm)
623+{
624+ Py_CLEAR(cm->cm_callable);
625+ return 0;
626+}
627+
628+
629+static PyObject *
630+cm_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+
645+static int
646+cm_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+
666+PyDoc_STRVAR(classmethod_doc,
667+"classmethod(function) -> method\n\
668+\n\
669+Convert a function to be a class method.\n\
670+\n\
671+A class method receives the class as implicit first argument,\n\
672+just like an instance method receives the instance.\n\
673+To 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\
679+It 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\
681+If a class method is called for a derived class, the derived class\n\
682+object is passed as the implied first argument.\n\
683+\n\
684+Class methods are different than C++ or Java static methods.\n\
685+If you want those, see the staticmethod builtin.");
686+
687+PyTypeObject 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+
730+PyObject *
731+PyClassMethod_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+
759+typedef struct {
760+ PyObject_HEAD
761+ PyObject *sm_callable;
762+} staticmethod;
763+
764+static void
765+sm_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+
772+static int
773+sm_traverse(staticmethod *sm, visitproc visit, void *arg)
774+{
775+ Py_VISIT(sm->sm_callable);
776+ return 0;
777+}
778+
779+static int
780+sm_clear(staticmethod *sm)
781+{
782+ Py_XDECREF(sm->sm_callable);
783+ sm->sm_callable = NULL;
784+
785+ return 0;
786+}
787+
788+static PyObject *
789+sm_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+
802+static int
803+sm_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+
817+PyDoc_STRVAR(staticmethod_doc,
818+"staticmethod(function) -> method\n\
819+\n\
820+Convert a function to be a static method.\n\
821+\n\
822+A static method does not receive an implicit first argument.\n\
823+To 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\
829+It 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\
832+Static methods in Python are similar to those found in Java or C++.\n\
833+For a more advanced concept, see the classmethod builtin.");
834+
835+PyTypeObject 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+
878+PyObject *
879+PyStaticMethod_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+}