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         case METH_OLDARGS | METH_KEYWORDS:
  85                 return (*(PyCFunctionWithKeywords)meth)(self, arg, kw);
  86         case METH_NOARGS:
  87                 if (kw == NULL || PyDict_Size(kw) == 0) {
  88                         size = PyTuple_GET_SIZE(arg);
  89                         if (size == 0)
  90                                 return (*meth)(self, NULL);
  91                         PyErr_Format(PyExc_TypeError,
  92                             "%.200s() takes no arguments (%zd given)",
  93                             f->m_ml->ml_name, size);
  94                         return NULL;
  95                 }
  96                 break;
  97         case METH_O:
  98                 if (kw == NULL || PyDict_Size(kw) == 0) {
  99                         size = PyTuple_GET_SIZE(arg);
 100                         if (size == 1)
 101                                 return (*meth)(self, PyTuple_GET_ITEM(arg, 0));
 102                         PyErr_Format(PyExc_TypeError,
 103                             "%.200s() takes exactly one argument (%zd given)",
 104                             f->m_ml->ml_name, size);
 105                         return NULL;
 106                 }
 107                 break;
 108         case METH_OLDARGS:
 109                 /* the really old style */
 110                 if (kw == NULL || PyDict_Size(kw) == 0) {
 111                         size = PyTuple_GET_SIZE(arg);
 112                         if (size == 1)
 113                                 arg = PyTuple_GET_ITEM(arg, 0);
 114                         else if (size == 0)
 115                                 arg = NULL;
 116                         return (*meth)(self, arg);
 117                 }
 118                 break;
 119         default:
 120                 PyErr_BadInternalCall();
 121                 return NULL;
 122         }
 123         PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
 124                      f->m_ml->ml_name);
 125         return NULL;
 126 }
 127
 128 /* Methods (the standard built-in methods, that is) */
 129
 130 static void
 131 meth_dealloc(PyCFunctionObject *m)
 132 {
 133         _PyObject_GC_UNTRACK(m);
 134         Py_XDECREF(m->m_self);
 135         Py_XDECREF(m->m_module);
 136         if (numfree < PyCFunction_MAXFREELIST) {
 137                 m->m_self = (PyObject *)free_list;
 138                 free_list = m;
 139                 numfree++;
 140         }
 141         else {
 142                 PyObject_GC_Del(m);
 143         }
 144 }
 145
 146 static PyObject *
 147 meth_get__doc__(PyCFunctionObject *m, void *closure)
 148 {
 149         const char *doc = m->m_ml->ml_doc;
 150
 151         if (doc != NULL)
 152                 return PyString_FromString(doc);
 153         Py_INCREF(Py_None);
 154         return Py_None;
 155 }
 156
 157 static PyObject *
 158 meth_get__name__(PyCFunctionObject *m, void *closure)
 159 {
 160         return PyString_FromString(m->m_ml->ml_name);
 161 }
 162
 163 static int
 164 meth_traverse(PyCFunctionObject *m, visitproc visit, void *arg)
 165 {
 166         Py_VISIT(m->m_self);
 167         Py_VISIT(m->m_module);
 168         return 0;
 169 }
 170
 171 static PyObject *
 172 meth_get__self__(PyCFunctionObject *m, void *closure)
 173 {
 174         PyObject *self;
 175         if (PyEval_GetRestricted()) {
 176                 PyErr_SetString(PyExc_RuntimeError,
 177                         "method.__self__ not accessible in restricted mode");
 178                 return NULL;
 179         }
 180         self = m->m_self;
 181         if (self == NULL)
 182                 self = Py_None;
 183         Py_INCREF(self);
 184         return self;
 185 }
 186
 187 static PyGetSetDef meth_getsets [] = {
 188         {"__doc__",  (getter)meth_get__doc__,  NULL, NULL},
 189         {"__name__", (getter)meth_get__name__, NULL, NULL},
 190         {"__self__", (getter)meth_get__self__, NULL, NULL},
 191         {0}
 192 };
 193
 194 #define OFF(x) offsetof(PyCFunctionObject, x)
 195
 196 static PyMemberDef meth_members[] = {
 197         {"__module__",    T_OBJECT,     OFF(m_module), PY_WRITE_RESTRICTED},
 198         {NULL}
 199 };
 200
 201 static PyObject *
 202 meth_repr(PyCFunctionObject *m)
 203 {
 204         if (m->m_self == NULL)
 205                 return PyString_FromFormat("<built-in function %s>",
 206                                            m->m_ml->ml_name);
 207         return PyString_FromFormat("<built-in method %s of %s object at %p>",
 208                                    m->m_ml->ml_name,
 209                                    m->m_self->ob_type->tp_name,
 210                                    m->m_self);
 211 }
 212
 213 static int
 214 meth_compare(PyCFunctionObject *a, PyCFunctionObject *b)
 215 {
 216         if (a->m_self != b->m_self)
 217                 return (a->m_self < b->m_self) ? -1 : 1;
 218         if (a->m_ml->ml_meth == b->m_ml->ml_meth)
 219                 return 0;
 220         if (strcmp(a->m_ml->ml_name, b->m_ml->ml_name) < 0)
 221                 return -1;
 222         else
 223                 return 1;
 224 }
 225
 226 static PyObject *
 227 meth_richcompare(PyObject *self, PyObject *other, int op)
 228 {
 229         PyCFunctionObject *a, *b;
 230         PyObject *res;
 231         int eq;
 232
 233         if ((op != Py_EQ && op != Py_NE) ||
 234             !PyCFunction_Check(self) ||
 235             !PyCFunction_Check(other))
 236         {
 237                 /* Py3K warning if types are not equal and comparison isn't == or !=  */
 238                 if (PyErr_WarnPy3k("builtin_function_or_method inequality "
 239                                    "comparisons not supported in 3.x", 1) < 0) {
 240                         return NULL;
 241                 }
 242
 243                 Py_INCREF(Py_NotImplemented);
 244                 return Py_NotImplemented;
 245         }
 246         a = (PyCFunctionObject *)self;
 247         b = (PyCFunctionObject *)other;
 248         eq = a->m_self == b->m_self;
 249         if (eq)
 250                 eq = a->m_ml->ml_meth == b->m_ml->ml_meth;
 251         if (op == Py_EQ)
 252                 res = eq ? Py_True : Py_False;
 253         else
 254                 res = eq ? Py_False : Py_True;
 255         Py_INCREF(res);
 256         return res;
 257 }
 258
 259 static long
 260 meth_hash(PyCFunctionObject *a)
 261 {
 262         long x,y;
 263         if (a->m_self == NULL)
 264                 x = 0;
 265         else {
 266                 x = PyObject_Hash(a->m_self);
 267                 if (x == -1)
 268                         return -1;
 269         }
 270         y = _Py_HashPointer((void*)(a->m_ml->ml_meth));
 271         if (y == -1)
 272                 return -1;
 273         x ^= y;
 274         if (x == -1)
 275                 x = -2;
 276         return x;
 277 }
 278
 279
 280 PyTypeObject PyCFunction_Type = {
 281         PyVarObject_HEAD_INIT(&PyType_Type, 0)
 282         "builtin_function_or_method",
 283         sizeof(PyCFunctionObject),
 284         0,
 285         (destructor)meth_dealloc,               /* tp_dealloc */
 286         0,                                      /* tp_print */
 287         0,                                      /* tp_getattr */
 288         0,                                      /* tp_setattr */
 289         (cmpfunc)meth_compare,                  /* tp_compare */
 290         (reprfunc)meth_repr,                    /* tp_repr */
 291         0,                                      /* tp_as_number */
 292         0,                                      /* tp_as_sequence */
 293         0,                                      /* tp_as_mapping */
 294         (hashfunc)meth_hash,                    /* tp_hash */
 295         PyCFunction_Call,                       /* tp_call */
 296         0,                                      /* tp_str */
 297         PyObject_GenericGetAttr,                /* tp_getattro */
 298         0,                                      /* tp_setattro */
 299         0,                                      /* tp_as_buffer */
 300         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
 301         0,                                      /* tp_doc */
 302         (traverseproc)meth_traverse,            /* tp_traverse */
 303         0,                                      /* tp_clear */
 304         meth_richcompare,                                       /* tp_richcompare */
 305         0,                                      /* tp_weaklistoffset */
 306         0,                                      /* tp_iter */
 307         0,                                      /* tp_iternext */
 308         0,                                      /* tp_methods */
 309         meth_members,                           /* tp_members */
 310         meth_getsets,                           /* tp_getset */
 311         0,                                      /* tp_base */
 312         0,                                      /* tp_dict */
 313 };
 314
 315 /* List all methods in a chain -- helper for findmethodinchain */
 316
 317 static PyObject *
 318 listmethodchain(PyMethodChain *chain)
 319 {
 320         PyMethodChain *c;
 321         PyMethodDef *ml;
 322         int i, n;
 323         PyObject *v;
 324
 325         n = 0;
 326         for (c = chain; c != NULL; c = c->link) {
 327                 for (ml = c->methods; ml->ml_name != NULL; ml++)
 328                         n++;
 329         }
 330         v = PyList_New(n);
 331         if (v == NULL)
 332                 return NULL;
 333         i = 0;
 334         for (c = chain; c != NULL; c = c->link) {
 335                 for (ml = c->methods; ml->ml_name != NULL; ml++) {
 336                         PyList_SetItem(v, i, PyString_FromString(ml->ml_name));
 337                         i++;
 338                 }
 339         }
 340         if (PyErr_Occurred()) {
 341                 Py_DECREF(v);
 342                 return NULL;
 343         }
 344         PyList_Sort(v);
 345         return v;
 346 }
 347
 348 /* Find a method in a method chain */
 349
 350 PyObject *
 351 Py_FindMethodInChain(PyMethodChain *chain, PyObject *self, const char *name)
 352 {
 353         if (name[0] == '_' && name[1] == '_') {
 354                 if (strcmp(name, "__methods__") == 0) {
 355                         if (PyErr_WarnPy3k("__methods__ not supported in 3.x",
 356                                            1) < 0)
 357                                 return NULL;
 358                         return listmethodchain(chain);
 359                 }
 360                 if (strcmp(name, "__doc__") == 0) {
 361                         const char *doc = self->ob_type->tp_doc;
 362                         if (doc != NULL)
 363                                 return PyString_FromString(doc);
 364                 }
 365         }
 366         while (chain != NULL) {
 367                 PyMethodDef *ml = chain->methods;
 368                 for (; ml->ml_name != NULL; ml++) {
 369                         if (name[0] == ml->ml_name[0] &&
 370                             strcmp(name+1, ml->ml_name+1) == 0)
 371                                 /* XXX */
 372                                 return PyCFunction_New(ml, self);
 373                 }
 374                 chain = chain->link;
 375         }
 376         PyErr_SetString(PyExc_AttributeError, name);
 377         return NULL;
 378 }
 379
 380 /* Find a method in a single method list */
 381
 382 PyObject *
 383 Py_FindMethod(PyMethodDef *methods, PyObject *self, const char *name)
 384 {
 385         PyMethodChain chain;
 386         chain.methods = methods;
 387         chain.link = NULL;
 388         return Py_FindMethodInChain(&chain, self, name);
 389 }
 390
 391 /* Clear out the free list */
 392
 393 int
 394 PyCFunction_ClearFreeList(void)
 395 {
 396         int freelist_size = numfree;
 397
 398         while (free_list) {
 399                 PyCFunctionObject *v = free_list;
 400                 free_list = (PyCFunctionObject *)(v->m_self);
 401                 PyObject_GC_Del(v);
 402                 numfree--;
 403         }
 404         assert(numfree == 0);
 405         return freelist_size;
 406 }
 407
 408 void
 409 PyCFunction_Fini(void)
 410 {
 411         (void)PyCFunction_ClearFreeList();
 412 }
 413
 414 /* PyCFunction_New() is now just a macro that calls PyCFunction_NewEx(),
 415    but it's part of the API so we need to keep a function around that
 416    existing C extensions can call.
 417 */
 418
 419 #undef PyCFunction_New
 420 PyAPI_FUNC(PyObject *) PyCFunction_New(PyMethodDef *, PyObject *);
 421
 422 PyObject *
 423 PyCFunction_New(PyMethodDef *ml, PyObject *self)
 424 {
 425         return PyCFunction_NewEx(ml, self, NULL);
 426 }