k = PyMem_NEW(PyObject *, 2*nk);		if (k == NULL) {			PyErr_NoMemory();			return NULL;		}		pos = i = 0;		while (PyDict_Next(kw, &pos, &k[i], &k[i+1]))			i += 2;		nk = i/2;		/* XXX This is broken if the caller deletes dict items! */	}	else {		k = NULL;		nk = 0;	} 	result = PyEval_EvalCodeEx(		(PyCodeObject *)PyFunction_GET_CODE(func),		PyFunction_GET_GLOBALS(func), (PyObject *)NULL,		&PyTuple_GET_ITEM(arg, 0), PyTuple_Size(arg),		k, nk, d, nd,		PyFunction_GET_CLOSURE(func)); 	if (k != NULL)		PyMem_DEL(k); 	return result;} /* Bind a function to an object */static PyObject *func_descr_get(PyObject *func, PyObject *obj, PyObject *type){	if (obj == Py_None)		obj = NULL;	return PyMethod_New(func, obj, type);} PyTypeObject PyFunction_Type = {	PyObject_HEAD_INIT(&PyType_Type)	0,	"function",	sizeof(PyFunctionObject),	0,	(destructor)func_dealloc,		/* tp_dealloc */	0,					/* tp_print */	0,					/* tp_getattr */	0,					/* tp_setattr */	0,					/* tp_compare */	(reprfunc)func_repr,			/* tp_repr */	0,					/* tp_as_number */	0,					/* tp_as_sequence */	0,					/* tp_as_mapping */	0,					/* tp_hash */	function_call,				/* tp_call */	0,					/* tp_str */	PyObject_GenericGetAttr,		/* tp_getattro */	PyObject_GenericSetAttr,		/* tp_setattro */	0,					/* tp_as_buffer */	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */	func_doc,				/* tp_doc */	(traverseproc)func_traverse,		/* tp_traverse */	0,					/* tp_clear */	0,					/* tp_richcompare */	offsetof(PyFunctionObject, func_weakreflist), /* tp_weaklistoffset */	0,					/* tp_iter */	0,					/* tp_iternext */	0,					/* tp_methods */	func_memberlist,			/* tp_members */	func_getsetlist,			/* tp_getset */	0,					/* tp_base */	0,					/* tp_dict */	func_descr_get,				/* tp_descr_get */	0,					/* tp_descr_set */	offsetof(PyFunctionObject, func_dict),	/* tp_dictoffset */	0,					/* tp_init */	0,					/* tp_alloc */	func_new,				/* tp_new */};  /* Class method object */ /* A class method receives the class as implicit first argument,   just like an instance method receives the instance.   To declare a class method, use this idiom:      class C:         def f(cls, arg1, arg2, ...): ...	 f = classmethod(f)      It can be called either on the class (e.g. C.f()) or on an instance   (e.g. C().f()); the instance is ignored except for its class.   If a class method is called for a derived class, the derived class   object is passed as the implied first argument.    Class methods are different than C++ or Java static methods.   If you want those, see static methods below.*/ typedef struct {	PyObject_HEAD	PyObject *cm_callable;} classmethod; static voidcm_dealloc(classmethod *cm){	_PyObject_GC_UNTRACK((PyObject *)cm);	Py_XDECREF(cm->cm_callable);	cm->ob_type->tp_free((PyObject *)cm);} static intcm_traverse(classmethod *cm, visitproc visit, void *arg){	Py_VISIT(cm->cm_callable);	return 0;} static intcm_clear(classmethod *cm){	Py_CLEAR(cm->cm_callable);	return 0;}  static PyObject *cm_descr_get(PyObject *self, PyObject *obj, PyObject *type){	classmethod *cm = (classmethod *)self; 	if (cm->cm_callable == NULL) {		PyErr_SetString(PyExc_RuntimeError,				"uninitialized classmethod object");		return NULL;	}	if (type == NULL)		type = (PyObject *)(obj->ob_type); 	return PyMethod_New(cm->cm_callable,			    type, (PyObject *)(type->ob_type));} static intcm_init(PyObject *self, PyObject *args, PyObject *kwds){	classmethod *cm = (classmethod *)self;	PyObject *callable; 	if (!PyArg_UnpackTuple(args, "classmethod", 1, 1, &callable))		return -1;	if (!_PyArg_NoKeywords("classmethod", kwds))		return -1;	if (!PyCallable_Check(callable)) {		PyErr_Format(PyExc_TypeError, "'%s' object is not callable",		     callable->ob_type->tp_name);		return -1;	}		Py_INCREF(callable);	cm->cm_callable = callable;	return 0;} PyDoc_STRVAR(classmethod_doc,"classmethod(function) -> method\n\\n\Convert a function to be a class method.\n\\n\A class method receives the class as implicit first argument,\n\just like an instance method receives the instance.\n\To declare a class method, use this idiom:\n\\n\  class C:\n\      def f(cls, arg1, arg2, ...): ...\n\      f = classmethod(f)\n\\n\It can be called either on the class (e.g. C.f()) or on an instance\n\(e.g. C().f()).  The instance is ignored except for its class.\n\If a class method is called for a derived class, the derived class\n\object is passed as the implied first argument.\n\\n\Class methods are different than C++ or Java static methods.\n\If you want those, see the staticmethod builtin."); PyTypeObject PyClassMethod_Type = {	PyObject_HEAD_INIT(&PyType_Type)	0,	"classmethod",	sizeof(classmethod),	0,	(destructor)cm_dealloc,			/* tp_dealloc */	0,					/* tp_print */	0,					/* tp_getattr */	0,					/* tp_setattr */	0,					/* tp_compare */	0,					/* tp_repr */	0,					/* tp_as_number */	0,					/* tp_as_sequence */	0,					/* tp_as_mapping */	0,					/* tp_hash */	0,					/* tp_call */	0,					/* tp_str */	PyObject_GenericGetAttr,		/* tp_getattro */	0,					/* tp_setattro */	0,					/* tp_as_buffer */	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,	classmethod_doc,			/* tp_doc */	(traverseproc)cm_traverse,		/* tp_traverse */	(inquiry)cm_clear,			/* tp_clear */	0,					/* tp_richcompare */	0,					/* tp_weaklistoffset */	0,					/* tp_iter */	0,					/* tp_iternext */	0,					/* tp_methods */	0,					/* tp_members */	0,					/* tp_getset */	0,					/* tp_base */	0,					/* tp_dict */	cm_descr_get,				/* tp_descr_get */	0,					/* tp_descr_set */	0,					/* tp_dictoffset */	cm_init,				/* tp_init */	PyType_GenericAlloc,			/* tp_alloc */	PyType_GenericNew,			/* tp_new */	PyObject_GC_Del,	                /* tp_free */}; PyObject *PyClassMethod_New(PyObject *callable){	classmethod *cm = (classmethod *)		PyType_GenericAlloc(&PyClassMethod_Type, 0);	if (cm != NULL) {		Py_INCREF(callable);		cm->cm_callable = callable;	}	return (PyObject *)cm;}  /* Static method object */ /* A static method does not receive an implicit first argument.   To declare a static method, use this idiom:      class C:         def f(arg1, arg2, ...): ...	 f = staticmethod(f)    It can be called either on the class (e.g. C.f()) or on an instance   (e.g. C().f()); the instance is ignored except for its class.    Static methods in Python are similar to those found in Java or C++.   For a more advanced concept, see class methods above.*/ typedef struct {	PyObject_HEAD	PyObject *sm_callable;} staticmethod; static voidsm_dealloc(staticmethod *sm){	_PyObject_GC_UNTRACK((PyObject *)sm);	Py_XDECREF(sm->sm_callable);	sm->ob_type->tp_free((PyObject *)sm);} static intsm_traverse(staticmethod *sm, visitproc visit, void *arg){	Py_VISIT(sm->sm_callable);	return 0;} static intsm_clear(staticmethod *sm){	Py_XDECREF(sm->sm_callable);	sm->sm_callable = NULL; 	return 0;} static PyObject *sm_descr_get(PyObject *self, PyObject *obj, PyObject *type){	staticmethod *sm = (staticmethod *)self; 	if (sm->sm_callable == NULL) {		PyErr_SetString(PyExc_RuntimeError,				"uninitialized staticmethod object");		return NULL;	}	Py_INCREF(sm->sm_callable);	return sm->sm_callable;} static intsm_init(PyObject *self, PyObject *args, PyObject *kwds){	staticmethod *sm = (staticmethod *)self;	PyObject *callable; 	if (!PyArg_UnpackTuple(args, "staticmethod", 1, 1, &callable))		return -1;	if (!_PyArg_NoKeywords("staticmethod", kwds))		return -1;	Py_INCREF(callable);	sm->sm_callable = callable;	return 0;} PyDoc_STRVAR(staticmethod_doc,"staticmethod(function) -> method\n\\n\Convert a function to be a static method.\n\\n\A static method does not receive an implicit first argument.\n\To declare a static method, use this idiom:\n\\n\     class C:\n\         def f(arg1, arg2, ...): ...\n\	 f = staticmethod(f)\n\\n\It can be called either on the class (e.g. C.f()) or on an instance\n\(e.g. C().f()).  The instance is ignored except for its class.\n\\n\Static methods in Python are similar to those found in Java or C++.\n\For a more advanced concept, see the classmethod builtin."); PyTypeObject PyStaticMethod_Type = {	PyObject_HEAD_INIT(&PyType_Type)	0,	"staticmethod",	sizeof(staticmethod),	0,	(destructor)sm_dealloc,			/* tp_dealloc */	0,					/* tp_print */	0,					/* tp_getattr */	0,					/* tp_setattr */	0,					/* tp_compare */	0,					/* tp_repr */	0,					/* tp_as_number */	0,					/* tp_as_sequence */	0,					/* tp_as_mapping */	0,					/* tp_hash */	0,					/* tp_call */	0,					/* tp_str */	PyObject_GenericGetAttr,		/* tp_getattro */	0,					/* tp_setattro */	0,					/* tp_as_buffer */	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,	staticmethod_doc,			/* tp_doc */	(traverseproc)sm_traverse,		/* tp_traverse */	(inquiry)sm_clear,			/* tp_clear */	0,					/* tp_richcompare */	0,					/* tp_weaklistoffset */	0,					/* tp_iter */	0,					/* tp_iternext */	0,					/* tp_methods */	0,					/* tp_members */	0,					/* tp_getset */	0,					/* tp_base */	0,					/* tp_dict */	sm_descr_get,				/* tp_descr_get */	0,					/* tp_descr_set */	0,					/* tp_dictoffset */	sm_init,				/* tp_init */	PyType_GenericAlloc,			/* tp_alloc */	PyType_GenericNew,			/* tp_new */	PyObject_GC_Del,           		/* tp_free */}; PyObject *PyStaticMethod_New(PyObject *callable){	staticmethod *sm = (staticmethod *)		PyType_GenericAlloc(&PyStaticMethod_Type, 0);	if (sm != NULL) {		Py_INCREF(callable);		sm->sm_callable = callable;	}	return (PyObject *)sm;}

Lines 501–888 of 888. Previous lines