/kbe/src/lib/python/Objects/methodobject.c

  1
  2/* Method object implementation */
  3
  4#include "Python.h"
  5#include "structmember.h"
  6
  7/* Free list for method objects to safe malloc/free overhead
  8 * The m_self element is used to chain the objects.
  9 */
 10static PyCFunctionObject *free_list = NULL;
 11static int numfree = 0;
 12#ifndef PyCFunction_MAXFREELIST
 13#define PyCFunction_MAXFREELIST 256
 14#endif
 15
 16PyObject *
 17PyCFunction_NewEx(PyMethodDef *ml, PyObject *self, PyObject *module)
 18{
 19    PyCFunctionObject *op;
 20    op = free_list;
 21    if (op != NULL) {
 22        free_list = (PyCFunctionObject *)(op->m_self);
 23        PyObject_INIT(op, &PyCFunction_Type);
 24        numfree--;
 25    }
 26    else {
 27        op = PyObject_GC_New(PyCFunctionObject, &PyCFunction_Type);
 28        if (op == NULL)
 29            return NULL;
 30    }
 31    op->m_ml = ml;
 32    Py_XINCREF(self);
 33    op->m_self = self;
 34    Py_XINCREF(module);
 35    op->m_module = module;
 36    _PyObject_GC_TRACK(op);
 37    return (PyObject *)op;
 38}
 39
 40PyCFunction
 41PyCFunction_GetFunction(PyObject *op)
 42{
 43    if (!PyCFunction_Check(op)) {
 44        PyErr_BadInternalCall();
 45        return NULL;
 46    }
 47    return ((PyCFunctionObject *)op) -> m_ml -> ml_meth;
 48}
 49
 50PyObject *
 51PyCFunction_GetSelf(PyObject *op)
 52{
 53    if (!PyCFunction_Check(op)) {
 54        PyErr_BadInternalCall();
 55        return NULL;
 56    }
 57    return ((PyCFunctionObject *)op) -> m_self;
 58}
 59
 60int
 61PyCFunction_GetFlags(PyObject *op)
 62{
 63    if (!PyCFunction_Check(op)) {
 64        PyErr_BadInternalCall();
 65        return -1;
 66    }
 67    return ((PyCFunctionObject *)op) -> m_ml -> ml_flags;
 68}
 69
 70PyObject *
 71PyCFunction_Call(PyObject *func, PyObject *arg, PyObject *kw)
 72{
 73    PyCFunctionObject* f = (PyCFunctionObject*)func;
 74    PyCFunction meth = PyCFunction_GET_FUNCTION(func);
 75    PyObject *self = PyCFunction_GET_SELF(func);
 76    Py_ssize_t size;
 77
 78    switch (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST)) {
 79    case METH_VARARGS:
 80        if (kw == NULL || PyDict_Size(kw) == 0)
 81            return (*meth)(self, arg);
 82        break;
 83    case METH_VARARGS | METH_KEYWORDS:
 84        return (*(PyCFunctionWithKeywords)meth)(self, arg, kw);
 85    case METH_NOARGS:
 86        if (kw == NULL || PyDict_Size(kw) == 0) {
 87            size = PyTuple_GET_SIZE(arg);
 88            if (size == 0)
 89                return (*meth)(self, NULL);
 90            PyErr_Format(PyExc_TypeError,
 91                "%.200s() takes no arguments (%zd given)",
 92                f->m_ml->ml_name, size);
 93            return NULL;
 94        }
 95        break;
 96    case METH_O:
 97        if (kw == NULL || PyDict_Size(kw) == 0) {
 98            size = PyTuple_GET_SIZE(arg);
 99            if (size == 1)
100                return (*meth)(self, PyTuple_GET_ITEM(arg, 0));
101            PyErr_Format(PyExc_TypeError,
102                "%.200s() takes exactly one argument (%zd given)",
103                f->m_ml->ml_name, size);
104            return NULL;
105        }
106        break;
107    default:
108        PyErr_SetString(PyExc_SystemError, "Bad call flags in "
109                        "PyCFunction_Call. METH_OLDARGS is no "
110                        "longer supported!");
111
112        return NULL;
113    }
114    PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
115                 f->m_ml->ml_name);
116    return NULL;
117}
118
119/* Methods (the standard built-in methods, that is) */
120
121static void
122meth_dealloc(PyCFunctionObject *m)
123{
124    _PyObject_GC_UNTRACK(m);
125    Py_XDECREF(m->m_self);
126    Py_XDECREF(m->m_module);
127    if (numfree < PyCFunction_MAXFREELIST) {
128        m->m_self = (PyObject *)free_list;
129        free_list = m;
130        numfree++;
131    }
132    else {
133        PyObject_GC_Del(m);
134    }
135}
136
137static PyObject *
138meth_get__doc__(PyCFunctionObject *m, void *closure)
139{
140    const char *doc = m->m_ml->ml_doc;
141
142    if (doc != NULL)
143        return PyUnicode_FromString(doc);
144    Py_INCREF(Py_None);
145    return Py_None;
146}
147
148static PyObject *
149meth_get__name__(PyCFunctionObject *m, void *closure)
150{
151    return PyUnicode_FromString(m->m_ml->ml_name);
152}
153
154static int
155meth_traverse(PyCFunctionObject *m, visitproc visit, void *arg)
156{
157    Py_VISIT(m->m_self);
158    Py_VISIT(m->m_module);
159    return 0;
160}
161
162static PyObject *
163meth_get__self__(PyCFunctionObject *m, void *closure)
164{
165    PyObject *self;
166
167    self = m->m_self;
168    if (self == NULL)
169        self = Py_None;
170    Py_INCREF(self);
171    return self;
172}
173
174static PyGetSetDef meth_getsets [] = {
175    {"__doc__",  (getter)meth_get__doc__,  NULL, NULL},
176    {"__name__", (getter)meth_get__name__, NULL, NULL},
177    {"__self__", (getter)meth_get__self__, NULL, NULL},
178    {0}
179};
180
181#define OFF(x) offsetof(PyCFunctionObject, x)
182
183static PyMemberDef meth_members[] = {
184    {"__module__",    T_OBJECT,     OFF(m_module), PY_WRITE_RESTRICTED},
185    {NULL}
186};
187
188static PyObject *
189meth_repr(PyCFunctionObject *m)
190{
191    if (m->m_self == NULL || PyModule_Check(m->m_self))
192        return PyUnicode_FromFormat("<built-in function %s>",
193                                   m->m_ml->ml_name);
194    return PyUnicode_FromFormat("<built-in method %s of %s object at %p>",
195                               m->m_ml->ml_name,
196                               m->m_self->ob_type->tp_name,
197                               m->m_self);
198}
199
200static PyObject *
201meth_richcompare(PyObject *self, PyObject *other, int op)
202{
203    PyCFunctionObject *a, *b;
204    PyObject *res;
205    int eq;
206
207    if ((op != Py_EQ && op != Py_NE) ||
208        !PyCFunction_Check(self) ||
209        !PyCFunction_Check(other))
210    {
211        Py_INCREF(Py_NotImplemented);
212        return Py_NotImplemented;
213    }
214    a = (PyCFunctionObject *)self;
215    b = (PyCFunctionObject *)other;
216    eq = a->m_self == b->m_self;
217    if (eq)
218        eq = a->m_ml->ml_meth == b->m_ml->ml_meth;
219    if (op == Py_EQ)
220        res = eq ? Py_True : Py_False;
221    else
222        res = eq ? Py_False : Py_True;
223    Py_INCREF(res);
224    return res;
225}
226
227static Py_hash_t
228meth_hash(PyCFunctionObject *a)
229{
230    Py_hash_t x, y;
231    if (a->m_self == NULL)
232        x = 0;
233    else {
234        x = PyObject_Hash(a->m_self);
235        if (x == -1)
236            return -1;
237    }
238    y = _Py_HashPointer((void*)(a->m_ml->ml_meth));
239    if (y == -1)
240        return -1;
241    x ^= y;
242    if (x == -1)
243        x = -2;
244    return x;
245}
246
247
248PyTypeObject PyCFunction_Type = {
249    PyVarObject_HEAD_INIT(&PyType_Type, 0)
250    "builtin_function_or_method",
251    sizeof(PyCFunctionObject),
252    0,
253    (destructor)meth_dealloc,                   /* tp_dealloc */
254    0,                                          /* tp_print */
255    0,                                          /* tp_getattr */
256    0,                                          /* tp_setattr */
257    0,                                          /* tp_reserved */
258    (reprfunc)meth_repr,                        /* tp_repr */
259    0,                                          /* tp_as_number */
260    0,                                          /* tp_as_sequence */
261    0,                                          /* tp_as_mapping */
262    (hashfunc)meth_hash,                        /* tp_hash */
263    PyCFunction_Call,                           /* tp_call */
264    0,                                          /* tp_str */
265    PyObject_GenericGetAttr,                    /* tp_getattro */
266    0,                                          /* tp_setattro */
267    0,                                          /* tp_as_buffer */
268    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
269    0,                                          /* tp_doc */
270    (traverseproc)meth_traverse,                /* tp_traverse */
271    0,                                          /* tp_clear */
272    meth_richcompare,                           /* tp_richcompare */
273    0,                                          /* tp_weaklistoffset */
274    0,                                          /* tp_iter */
275    0,                                          /* tp_iternext */
276    0,                                          /* tp_methods */
277    meth_members,                               /* tp_members */
278    meth_getsets,                               /* tp_getset */
279    0,                                          /* tp_base */
280    0,                                          /* tp_dict */
281};
282
283/* Clear out the free list */
284
285int
286PyCFunction_ClearFreeList(void)
287{
288    int freelist_size = numfree;
289
290    while (free_list) {
291        PyCFunctionObject *v = free_list;
292        free_list = (PyCFunctionObject *)(v->m_self);
293        PyObject_GC_Del(v);
294        numfree--;
295    }
296    assert(numfree == 0);
297    return freelist_size;
298}
299
300void
301PyCFunction_Fini(void)
302{
303    (void)PyCFunction_ClearFreeList();
304}
305
306/* PyCFunction_New() is now just a macro that calls PyCFunction_NewEx(),
307   but it's part of the API so we need to keep a function around that
308   existing C extensions can call.
309*/
310
311#undef PyCFunction_New
312PyAPI_FUNC(PyObject *) PyCFunction_New(PyMethodDef *, PyObject *);
313
314PyObject *
315PyCFunction_New(PyMethodDef *ml, PyObject *self)
316{
317    return PyCFunction_NewEx(ml, self, NULL);
318}