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  */
  10 static PyCFunctionObject *free_list = NULL;
  11 static int numfree = 0;
  12 #ifndef PyCFunction_MAXFREELIST
  13 #define PyCFunction_MAXFREELIST 256
  14 #endif
  15
  16 PyObject *
  17 PyCFunction_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
  40 PyCFunction
  41 PyCFunction_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
  50 PyObject *
  51 PyCFunction_GetSelf(PyObject *op)
  52 {
  53         if (!PyCFunction_Check(op)) {
  54                 PyErr_BadInternalCall();
  55                 return NULL;
  56         }
  57         return ((PyCFunctionObject *)op) -> m_self;
  58 }
  59
  60 int
  61 PyCFunction_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
  70 PyObject *
  71 PyCFunction_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
 121 static void
 122 meth_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
 137 static PyObject *
 138 meth_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
 148 static PyObject *
 149 meth_get__name__(PyCFunctionObject *m, void *closure)
 150 {
 151         return PyUnicode_FromString(m->m_ml->ml_name);
 152 }
 153
 154 static int
 155 meth_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
 162 static PyObject *
 163 meth_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
 174 static 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
 183 static PyMemberDef meth_members[] = {
 184         {"__module__",    T_OBJECT,     OFF(m_module), PY_WRITE_RESTRICTED},
 185         {NULL}
 186 };
 187
 188 static PyObject *
 189 meth_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
 200 static PyObject *
 201 meth_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
 227 static long
 228 meth_hash(PyCFunctionObject *a)
 229 {
 230         long 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
 248 PyTypeObject 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
 285 int
 286 PyCFunction_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
 300 void
 301 PyCFunction_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
 312 PyAPI_FUNC(PyObject *) PyCFunction_New(PyMethodDef *, PyObject *);
 313
 314 PyObject *
 315 PyCFunction_New(PyMethodDef *ml, PyObject *self)
 316 {
 317         return PyCFunction_NewEx(ml, self, NULL);
 318 }