#include "Python.h"

#include "structmember.h"

static PyCFunctionObject *free_list = NULL;

static int numfree = 0;

#ifndef PyCFunction_MAXFREELIST

#define PyCFunction_MAXFREELIST 256

#undef PyCFunction_New

PyAPI_FUNC(PyObject *)

PyCFunction_New(PyMethodDef *ml, PyObject *self)

{

return PyCFunction_NewEx(ml, self, NULL);

}

PyObject *

PyCFunction_NewEx(PyMethodDef *ml, PyObject *self, PyObject *module)

{

PyCFunctionObject *op;

op = free_list;

if (op != NULL) {

free_list = (PyCFunctionObject *)(op->m_self);

(void)PyObject_INIT(op, &PyCFunction_Type);

numfree--;

}

else {

op = PyObject_GC_New(PyCFunctionObject, &PyCFunction_Type);

if (op == NULL)

return NULL;

}

op->m_weakreflist = NULL;

op->m_ml = ml;

Py_XINCREF(self);

op->m_self = self;

Py_XINCREF(module);

op->m_module = module;

_PyObject_GC_TRACK(op);

return (PyObject *)op;

}

PyCFunction_GetFunction(PyObject *op)

{

if (!PyCFunction_Check(op)) {

PyErr_BadInternalCall();

return NULL;

}

return PyCFunction_GET_FUNCTION(op);

}

PyObject *

PyCFunction_GetSelf(PyObject *op)

{

if (!PyCFunction_Check(op)) {

PyErr_BadInternalCall();

return NULL;

}

return PyCFunction_GET_SELF(op);

}

PyCFunction_GetFlags(PyObject *op)

{

if (!PyCFunction_Check(op)) {

PyErr_BadInternalCall();

return -1;

}

return PyCFunction_GET_FLAGS(op);

}

static void

meth_dealloc(PyCFunctionObject *m)

{

_PyObject_GC_UNTRACK(m);

if (m->m_weakreflist != NULL) {

PyObject_ClearWeakRefs((PyObject*) m);

}

Py_XDECREF(m->m_self);

Py_XDECREF(m->m_module);

if (numfree < PyCFunction_MAXFREELIST) {

m->m_self = (PyObject *)free_list;

free_list = m;

numfree++;

}

else {

PyObject_GC_Del(m);

}

}

static PyObject *

meth_reduce(PyCFunctionObject *m)

{

PyObject *builtins;

PyObject *getattr;

_Py_IDENTIFIER(getattr);

if (m->m_self == NULL || PyModule_Check(m->m_self))

return PyUnicode_FromString(m->m_ml->ml_name);

builtins = PyEval_GetBuiltins();

getattr = _PyDict_GetItemId(builtins, &PyId_getattr);

return Py_BuildValue("O(Os)", getattr, m->m_self, m->m_ml->ml_name);

}

static PyMethodDef meth_methods[] = {

{"__reduce__", (PyCFunction)meth_reduce, METH_NOARGS, NULL},

{NULL, NULL}

};

static PyObject *

meth_get__text_signature__(PyCFunctionObject *m, void *closure)

{

return _PyType_GetTextSignatureFromInternalDoc(m->m_ml->ml_name, m->m_ml->ml_doc);

}

static PyObject *

meth_get__doc__(PyCFunctionObject *m, void *closure)

{

return _PyType_GetDocFromInternalDoc(m->m_ml->ml_name, m->m_ml->ml_doc);

}

static PyObject *

meth_get__name__(PyCFunctionObject *m, void *closure)

{

return PyUnicode_FromString(m->m_ml->ml_name);

}

static PyObject *

meth_get__qualname__(PyCFunctionObject *m, void *closure)

{

/* If __self__ is a module or NULL, return m.__name__

PyObject *type, *type_qualname, *res;

_Py_IDENTIFIER(__qualname__);

if (m->m_self == NULL || PyModule_Check(m->m_self))

return PyUnicode_FromString(m->m_ml->ml_name);

type = PyType_Check(m->m_self) ? m->m_self : (PyObject*)Py_TYPE(m->m_self);

type_qualname = _PyObject_GetAttrId(type, &PyId___qualname__);

if (type_qualname == NULL)

return NULL;

if (!PyUnicode_Check(type_qualname)) {

PyErr_SetString(PyExc_TypeError, "<method>.__class__."

"__qualname__ is not a unicode object");

Py_XDECREF(type_qualname);

return NULL;

}

res = PyUnicode_FromFormat("%S.%s", type_qualname, m->m_ml->ml_name);

Py_DECREF(type_qualname);

return res;

}

static int

meth_traverse(PyCFunctionObject *m, visitproc visit, void *arg)

{

Py_VISIT(m->m_self);

Py_VISIT(m->m_module);

return 0;

}

static PyObject *

meth_get__self__(PyCFunctionObject *m, void *closure)

{

PyObject *self;

self = PyCFunction_GET_SELF(m);

if (self == NULL)

self = Py_None;

Py_INCREF(self);

return self;

}

static PyGetSetDef meth_getsets [] = {

{"__doc__", (getter)meth_get__doc__, NULL, NULL},

{"__name__", (getter)meth_get__name__, NULL, NULL},

{"__qualname__", (getter)meth_get__qualname__, NULL, NULL},

{"__self__", (getter)meth_get__self__, NULL, NULL},

{"__text_signature__", (getter)meth_get__text_signature__, NULL, NULL},

{0}

};

#define OFF(x) offsetof(PyCFunctionObject, x)

static PyMemberDef meth_members[] = {

{"__module__", T_OBJECT, OFF(m_module), PY_WRITE_RESTRICTED},

{NULL}

};

static PyObject *

meth_repr(PyCFunctionObject *m)

{

if (m->m_self == NULL || PyModule_Check(m->m_self))

return PyUnicode_FromFormat("<built-in function %s>",

m->m_ml->ml_name);

return PyUnicode_FromFormat("<built-in method %s of %s object at %p>",

m->m_ml->ml_name,

m->m_self->ob_type->tp_name,

m->m_self);

}

static PyObject *

meth_richcompare(PyObject *self, PyObject *other, int op)

{

PyCFunctionObject *a, *b;

PyObject *res;

int eq;

if ((op != Py_EQ && op != Py_NE) ||

!PyCFunction_Check(self) ||

!PyCFunction_Check(other))

{

Py_RETURN_NOTIMPLEMENTED;

}

a = (PyCFunctionObject *)self;

b = (PyCFunctionObject *)other;

eq = a->m_self == b->m_self;

if (eq)

eq = a->m_ml->ml_meth == b->m_ml->ml_meth;

if (op == Py_EQ)

res = eq ? Py_True : Py_False;

else

res = eq ? Py_False : Py_True;

Py_INCREF(res);

return res;

}

static Py_hash_t

meth_hash(PyCFunctionObject *a)

{

Py_hash_t x, y;

if (a->m_self == NULL)

x = 0;

else {

x = PyObject_Hash(a->m_self);

if (x == -1)

return -1;

}

y = _Py_HashPointer((void*)(a->m_ml->ml_meth));

if (y == -1)

return -1;

x ^= y;

if (x == -1)

x = -2;

return x;

}

PyTypeObject PyCFunction_Type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"builtin_function_or_method",

sizeof(PyCFunctionObject),

0,

(destructor)meth_dealloc, /* tp_dealloc */

0, /* tp_print */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_reserved */

(reprfunc)meth_repr, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

(hashfunc)meth_hash, /* tp_hash */

PyCFunction_Call, /* tp_call */

0, /* tp_str */

PyObject_GenericGetAttr, /* tp_getattro */

0, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */

0, /* tp_doc */

(traverseproc)meth_traverse, /* tp_traverse */

0, /* tp_clear */

meth_richcompare, /* tp_richcompare */

offsetof(PyCFunctionObject, m_weakreflist), /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

meth_methods, /* tp_methods */

meth_members, /* tp_members */

meth_getsets, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

};

PyCFunction_ClearFreeList(void)

{

int freelist_size = numfree;

while (free_list) {

PyCFunctionObject *v = free_list;

free_list = (PyCFunctionObject *)(v->m_self);

PyObject_GC_Del(v);

numfree--;

}

assert(numfree == 0);

return freelist_size;

}

PyCFunction_Fini(void)

{

(void)PyCFunction_ClearFreeList();

}

_PyCFunction_DebugMallocStats(FILE *out)

{

_PyDebugAllocatorStats(out,

"free PyCFunctionObject",

numfree, sizeof(PyCFunctionObject));

}