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 }