2 /* Function object implementation */
7 #include "structmember.h"
10 PyFunction_New(PyObject
*code
, PyObject
*globals
)
12 PyFunctionObject
*op
= PyObject_GC_New(PyFunctionObject
,
14 static PyObject
*__name__
= 0;
19 op
->func_weakreflist
= NULL
;
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
))
39 op
->func_module
= NULL
;
41 /* __module__: If module name is in globals, use it.
45 __name__
= PyString_InternFromString("__name__");
51 module
= PyDict_GetItem(globals
, __name__
);
54 op
->func_module
= module
;
59 _PyObject_GC_TRACK(op
);
60 return (PyObject
*)op
;
64 PyFunction_GetCode(PyObject
*op
)
66 if (!PyFunction_Check(op
)) {
67 PyErr_BadInternalCall();
70 return ((PyFunctionObject
*) op
) -> func_code
;
74 PyFunction_GetGlobals(PyObject
*op
)
76 if (!PyFunction_Check(op
)) {
77 PyErr_BadInternalCall();
80 return ((PyFunctionObject
*) op
) -> func_globals
;
84 PyFunction_GetModule(PyObject
*op
)
86 if (!PyFunction_Check(op
)) {
87 PyErr_BadInternalCall();
90 return ((PyFunctionObject
*) op
) -> func_module
;
94 PyFunction_GetDefaults(PyObject
*op
)
96 if (!PyFunction_Check(op
)) {
97 PyErr_BadInternalCall();
100 return ((PyFunctionObject
*) op
) -> func_defaults
;
104 PyFunction_SetDefaults(PyObject
*op
, PyObject
*defaults
)
106 if (!PyFunction_Check(op
)) {
107 PyErr_BadInternalCall();
110 if (defaults
== Py_None
)
112 else if (defaults
&& PyTuple_Check(defaults
)) {
116 PyErr_SetString(PyExc_SystemError
, "non-tuple default args");
119 Py_XDECREF(((PyFunctionObject
*) op
) -> func_defaults
);
120 ((PyFunctionObject
*) op
) -> func_defaults
= defaults
;
125 PyFunction_GetClosure(PyObject
*op
)
127 if (!PyFunction_Check(op
)) {
128 PyErr_BadInternalCall();
131 return ((PyFunctionObject
*) op
) -> func_closure
;
135 PyFunction_SetClosure(PyObject
*op
, PyObject
*closure
)
137 if (!PyFunction_Check(op
)) {
138 PyErr_BadInternalCall();
141 if (closure
== Py_None
)
143 else if (PyTuple_Check(closure
)) {
147 PyErr_Format(PyExc_SystemError
,
148 "expected tuple for closure, got '%.100s'",
149 closure
->ob_type
->tp_name
);
152 Py_XDECREF(((PyFunctionObject
*) op
) -> func_closure
);
153 ((PyFunctionObject
*) op
) -> func_closure
= closure
;
159 #define OFF(x) offsetof(PyFunctionObject, x)
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 */
175 if (!PyEval_GetRestricted())
177 PyErr_SetString(PyExc_RuntimeError
,
178 "function attributes not accessible in restricted mode");
183 func_get_dict(PyFunctionObject
*op
)
187 if (op
->func_dict
== NULL
) {
188 op
->func_dict
= PyDict_New();
189 if (op
->func_dict
== NULL
)
192 Py_INCREF(op
->func_dict
);
193 return op
->func_dict
;
197 func_set_dict(PyFunctionObject
*op
, PyObject
*value
)
203 /* It is illegal to del f.func_dict */
205 PyErr_SetString(PyExc_TypeError
,
206 "function's dictionary may not be deleted");
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");
217 op
->func_dict
= value
;
223 func_get_code(PyFunctionObject
*op
)
227 Py_INCREF(op
->func_code
);
228 return op
->func_code
;
232 func_set_code(PyFunctionObject
*op
, PyObject
*value
)
235 Py_ssize_t nfree
, nclosure
;
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");
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,"
253 PyString_AsString(op
->func_name
),
259 op
->func_code
= value
;
265 func_get_name(PyFunctionObject
*op
)
267 Py_INCREF(op
->func_name
);
268 return op
->func_name
;
272 func_set_name(PyFunctionObject
*op
, PyObject
*value
)
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");
287 op
->func_name
= value
;
293 func_get_defaults(PyFunctionObject
*op
)
297 if (op
->func_defaults
== NULL
) {
301 Py_INCREF(op
->func_defaults
);
302 return op
->func_defaults
;
306 func_set_defaults(PyFunctionObject
*op
, PyObject
*value
)
312 /* Legal to del f.func_defaults.
313 * Can only set func_defaults to NULL or a tuple. */
314 if (value
== Py_None
)
316 if (value
!= NULL
&& !PyTuple_Check(value
)) {
317 PyErr_SetString(PyExc_TypeError
,
318 "func_defaults must be set to a tuple object");
321 tmp
= op
->func_defaults
;
323 op
->func_defaults
= value
;
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 */
339 PyDoc_STRVAR(func_doc
,
340 "function(code, globals[, name[, argdefs[, closure]]])\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.");
347 /* func_new() maintains the following invariants for closures. The
348 closure must correspond to the free variables of the code object.
350 if len(code.co_freevars) == 0:
353 len(closure) == len(code.co_freevars)
354 for every elt in closure, type(elt) == cell
358 func_new(PyTypeObject
* type
, PyObject
* args
, PyObject
* kw
)
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};
370 if (!PyArg_ParseTupleAndKeywords(args
, kw
, "O!O!|OOO:function",
373 &PyDict_Type
, &globals
,
374 &name
, &defaults
, &closure
))
376 if (name
!= Py_None
&& !PyString_Check(name
)) {
377 PyErr_SetString(PyExc_TypeError
,
378 "arg 3 (name) must be None or string");
381 if (defaults
!= Py_None
&& !PyTuple_Check(defaults
)) {
382 PyErr_SetString(PyExc_TypeError
,
383 "arg 4 (defaults) must be None or tuple");
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");
393 else if (closure
!= Py_None
) {
394 PyErr_SetString(PyExc_TypeError
,
395 "arg 5 (closure) must be None or tuple");
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
),
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
);
419 newfunc
= (PyFunctionObject
*)PyFunction_New((PyObject
*)code
,
424 if (name
!= Py_None
) {
426 Py_DECREF(newfunc
->func_name
);
427 newfunc
->func_name
= name
;
429 if (defaults
!= Py_None
) {
431 newfunc
->func_defaults
= defaults
;
433 if (closure
!= Py_None
) {
435 newfunc
->func_closure
= closure
;
438 return (PyObject
*)newfunc
;
442 func_dealloc(PyFunctionObject
*op
)
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
);
459 func_repr(PyFunctionObject
*op
)
461 return PyString_FromFormat("<function %s at %p>",
462 PyString_AsString(op
->func_name
),
467 func_traverse(PyFunctionObject
*f
, visitproc visit
, void *arg
)
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
);
481 function_call(PyObject
*func
, PyObject
*arg
, PyObject
*kw
)
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
);
498 if (kw
!= NULL
&& PyDict_Check(kw
)) {
500 nk
= PyDict_Size(kw
);
501 k
= PyMem_NEW(PyObject
*, 2*nk
);
507 while (PyDict_Next(kw
, &pos
, &k
[i
], &k
[i
+1]))
510 /* XXX This is broken if the caller deletes dict items! */
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
),
522 PyFunction_GET_CLOSURE(func
));
530 /* Bind a function to an object */
532 func_descr_get(PyObject
*func
, PyObject
*obj
, PyObject
*type
)
536 return PyMethod_New(func
, obj
, type
);
539 PyTypeObject PyFunction_Type
= {
540 PyObject_HEAD_INIT(&PyType_Type
)
543 sizeof(PyFunctionObject
),
545 (destructor
)func_dealloc
, /* tp_dealloc */
550 (reprfunc
)func_repr
, /* tp_repr */
551 0, /* tp_as_number */
552 0, /* tp_as_sequence */
553 0, /* tp_as_mapping */
555 function_call
, /* tp_call */
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 */
564 0, /* tp_richcompare */
565 offsetof(PyFunctionObject
, func_weakreflist
), /* tp_weaklistoffset */
569 func_memberlist
, /* tp_members */
570 func_getsetlist
, /* tp_getset */
573 func_descr_get
, /* tp_descr_get */
574 0, /* tp_descr_set */
575 offsetof(PyFunctionObject
, func_dict
), /* tp_dictoffset */
578 func_new
, /* tp_new */
582 /* Class method object */
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:
589 def f(cls, arg1, arg2, ...): ...
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.
597 Class methods are different than C++ or Java static methods.
598 If you want those, see static methods below.
603 PyObject
*cm_callable
;
607 cm_dealloc(classmethod
*cm
)
609 _PyObject_GC_UNTRACK((PyObject
*)cm
);
610 Py_XDECREF(cm
->cm_callable
);
611 cm
->ob_type
->tp_free((PyObject
*)cm
);
615 cm_traverse(classmethod
*cm
, visitproc visit
, void *arg
)
617 Py_VISIT(cm
->cm_callable
);
622 cm_clear(classmethod
*cm
)
624 Py_CLEAR(cm
->cm_callable
);
630 cm_descr_get(PyObject
*self
, PyObject
*obj
, PyObject
*type
)
632 classmethod
*cm
= (classmethod
*)self
;
634 if (cm
->cm_callable
== NULL
) {
635 PyErr_SetString(PyExc_RuntimeError
,
636 "uninitialized classmethod object");
640 type
= (PyObject
*)(obj
->ob_type
);
641 return PyMethod_New(cm
->cm_callable
,
642 type
, (PyObject
*)(type
->ob_type
));
646 cm_init(PyObject
*self
, PyObject
*args
, PyObject
*kwds
)
648 classmethod
*cm
= (classmethod
*)self
;
651 if (!PyArg_UnpackTuple(args
, "classmethod", 1, 1, &callable
))
653 if (!_PyArg_NoKeywords("classmethod", kwds
))
655 if (!PyCallable_Check(callable
)) {
656 PyErr_Format(PyExc_TypeError
, "'%s' object is not callable",
657 callable
->ob_type
->tp_name
);
662 cm
->cm_callable
= callable
;
666 PyDoc_STRVAR(classmethod_doc
,
667 "classmethod(function) -> method\n\
669 Convert a function to be a class method.\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\
676 def f(cls, arg1, arg2, ...): ...\n\
677 f = classmethod(f)\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\
684 Class methods are different than C++ or Java static methods.\n\
685 If you want those, see the staticmethod builtin.");
687 PyTypeObject PyClassMethod_Type
= {
688 PyObject_HEAD_INIT(&PyType_Type
)
693 (destructor
)cm_dealloc
, /* tp_dealloc */
699 0, /* tp_as_number */
700 0, /* tp_as_sequence */
701 0, /* tp_as_mapping */
705 PyObject_GenericGetAttr
, /* tp_getattro */
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 */
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 */
731 PyClassMethod_New(PyObject
*callable
)
733 classmethod
*cm
= (classmethod
*)
734 PyType_GenericAlloc(&PyClassMethod_Type
, 0);
737 cm
->cm_callable
= callable
;
739 return (PyObject
*)cm
;
743 /* Static method object */
745 /* A static method does not receive an implicit first argument.
746 To declare a static method, use this idiom:
749 def f(arg1, arg2, ...): ...
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.
755 Static methods in Python are similar to those found in Java or C++.
756 For a more advanced concept, see class methods above.
761 PyObject
*sm_callable
;
765 sm_dealloc(staticmethod
*sm
)
767 _PyObject_GC_UNTRACK((PyObject
*)sm
);
768 Py_XDECREF(sm
->sm_callable
);
769 sm
->ob_type
->tp_free((PyObject
*)sm
);
773 sm_traverse(staticmethod
*sm
, visitproc visit
, void *arg
)
775 Py_VISIT(sm
->sm_callable
);
780 sm_clear(staticmethod
*sm
)
782 Py_XDECREF(sm
->sm_callable
);
783 sm
->sm_callable
= NULL
;
789 sm_descr_get(PyObject
*self
, PyObject
*obj
, PyObject
*type
)
791 staticmethod
*sm
= (staticmethod
*)self
;
793 if (sm
->sm_callable
== NULL
) {
794 PyErr_SetString(PyExc_RuntimeError
,
795 "uninitialized staticmethod object");
798 Py_INCREF(sm
->sm_callable
);
799 return sm
->sm_callable
;
803 sm_init(PyObject
*self
, PyObject
*args
, PyObject
*kwds
)
805 staticmethod
*sm
= (staticmethod
*)self
;
808 if (!PyArg_UnpackTuple(args
, "staticmethod", 1, 1, &callable
))
810 if (!_PyArg_NoKeywords("staticmethod", kwds
))
813 sm
->sm_callable
= callable
;
817 PyDoc_STRVAR(staticmethod_doc
,
818 "staticmethod(function) -> method\n\
820 Convert a function to be a static method.\n\
822 A static method does not receive an implicit first argument.\n\
823 To declare a static method, use this idiom:\n\
826 def f(arg1, arg2, ...): ...\n\
827 f = staticmethod(f)\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\
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.");
835 PyTypeObject PyStaticMethod_Type
= {
836 PyObject_HEAD_INIT(&PyType_Type
)
839 sizeof(staticmethod
),
841 (destructor
)sm_dealloc
, /* tp_dealloc */
847 0, /* tp_as_number */
848 0, /* tp_as_sequence */
849 0, /* tp_as_mapping */
853 PyObject_GenericGetAttr
, /* tp_getattro */
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 */
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 */
879 PyStaticMethod_New(PyObject
*callable
)
881 staticmethod
*sm
= (staticmethod
*)
882 PyType_GenericAlloc(&PyStaticMethod_Type
, 0);
885 sm
->sm_callable
= callable
;
887 return (PyObject
*)sm
;