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 /* undefine macro trampoline to PyCFunction_NewEx */
17 #undef PyCFunction_New
18
19 PyAPI_FUNC(PyObject *)
PyCFunction_New(PyMethodDef * ml,PyObject * self)20 PyCFunction_New(PyMethodDef *ml, PyObject *self)
21 {
22 return PyCFunction_NewEx(ml, self, NULL);
23 }
24
25 PyObject *
PyCFunction_NewEx(PyMethodDef * ml,PyObject * self,PyObject * module)26 PyCFunction_NewEx(PyMethodDef *ml, PyObject *self, PyObject *module)
27 {
28 PyCFunctionObject *op;
29 op = free_list;
30 if (op != NULL) {
31 free_list = (PyCFunctionObject *)(op->m_self);
32 (void)PyObject_INIT(op, &PyCFunction_Type);
33 numfree--;
34 }
35 else {
36 op = PyObject_GC_New(PyCFunctionObject, &PyCFunction_Type);
37 if (op == NULL)
38 return NULL;
39 }
40 op->m_weakreflist = NULL;
41 op->m_ml = ml;
42 Py_XINCREF(self);
43 op->m_self = self;
44 Py_XINCREF(module);
45 op->m_module = module;
46 _PyObject_GC_TRACK(op);
47 return (PyObject *)op;
48 }
49
50 PyCFunction
PyCFunction_GetFunction(PyObject * op)51 PyCFunction_GetFunction(PyObject *op)
52 {
53 if (!PyCFunction_Check(op)) {
54 PyErr_BadInternalCall();
55 return NULL;
56 }
57 return PyCFunction_GET_FUNCTION(op);
58 }
59
60 PyObject *
PyCFunction_GetSelf(PyObject * op)61 PyCFunction_GetSelf(PyObject *op)
62 {
63 if (!PyCFunction_Check(op)) {
64 PyErr_BadInternalCall();
65 return NULL;
66 }
67 return PyCFunction_GET_SELF(op);
68 }
69
70 int
PyCFunction_GetFlags(PyObject * op)71 PyCFunction_GetFlags(PyObject *op)
72 {
73 if (!PyCFunction_Check(op)) {
74 PyErr_BadInternalCall();
75 return -1;
76 }
77 return PyCFunction_GET_FLAGS(op);
78 }
79
80 PyObject *
PyCFunction_Call(PyObject * func,PyObject * args,PyObject * kwds)81 PyCFunction_Call(PyObject *func, PyObject *args, PyObject *kwds)
82 {
83 PyCFunctionObject* f = (PyCFunctionObject*)func;
84 PyCFunction meth = PyCFunction_GET_FUNCTION(func);
85 PyObject *self = PyCFunction_GET_SELF(func);
86 PyObject *arg, *res;
87 Py_ssize_t size;
88 int flags;
89
90 /* PyCFunction_Call() must not be called with an exception set,
91 because it may clear it (directly or indirectly) and so the
92 caller loses its exception */
93 assert(!PyErr_Occurred());
94
95 flags = PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
96
97 if (flags == (METH_VARARGS | METH_KEYWORDS)) {
98 res = (*(PyCFunctionWithKeywords)meth)(self, args, kwds);
99 }
100 else if (flags == METH_FASTCALL) {
101 PyObject **stack = &PyTuple_GET_ITEM(args, 0);
102 Py_ssize_t nargs = PyTuple_GET_SIZE(args);
103 res = _PyCFunction_FastCallDict(func, stack, nargs, kwds);
104 }
105 else {
106 if (kwds != NULL && PyDict_Size(kwds) != 0) {
107 PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
108 f->m_ml->ml_name);
109 return NULL;
110 }
111
112 switch (flags) {
113 case METH_VARARGS:
114 res = (*meth)(self, args);
115 break;
116
117 case METH_NOARGS:
118 size = PyTuple_GET_SIZE(args);
119 if (size != 0) {
120 PyErr_Format(PyExc_TypeError,
121 "%.200s() takes no arguments (%zd given)",
122 f->m_ml->ml_name, size);
123 return NULL;
124 }
125
126 res = (*meth)(self, NULL);
127 break;
128
129 case METH_O:
130 size = PyTuple_GET_SIZE(args);
131 if (size != 1) {
132 PyErr_Format(PyExc_TypeError,
133 "%.200s() takes exactly one argument (%zd given)",
134 f->m_ml->ml_name, size);
135 return NULL;
136 }
137
138 arg = PyTuple_GET_ITEM(args, 0);
139 res = (*meth)(self, arg);
140 break;
141
142 default:
143 PyErr_SetString(PyExc_SystemError,
144 "Bad call flags in PyCFunction_Call. "
145 "METH_OLDARGS is no longer supported!");
146 return NULL;
147 }
148 }
149
150 return _Py_CheckFunctionResult(func, res, NULL);
151 }
152
153 PyObject *
_PyCFunction_FastCallDict(PyObject * func_obj,PyObject ** args,Py_ssize_t nargs,PyObject * kwargs)154 _PyCFunction_FastCallDict(PyObject *func_obj, PyObject **args, Py_ssize_t nargs,
155 PyObject *kwargs)
156 {
157 PyCFunctionObject *func = (PyCFunctionObject*)func_obj;
158 PyCFunction meth = PyCFunction_GET_FUNCTION(func);
159 PyObject *self = PyCFunction_GET_SELF(func);
160 PyObject *result;
161 int flags;
162
163 assert(PyCFunction_Check(func));
164 assert(func != NULL);
165 assert(nargs >= 0);
166 assert(nargs == 0 || args != NULL);
167 assert(kwargs == NULL || PyDict_Check(kwargs));
168
169 /* _PyCFunction_FastCallDict() must not be called with an exception set,
170 because it may clear it (directly or indirectly) and so the
171 caller loses its exception */
172 assert(!PyErr_Occurred());
173
174 flags = PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST);
175
176 switch (flags)
177 {
178 case METH_NOARGS:
179 if (kwargs != NULL && PyDict_Size(kwargs) != 0) {
180 PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
181 func->m_ml->ml_name);
182 return NULL;
183 }
184
185 if (nargs != 0) {
186 PyErr_Format(PyExc_TypeError,
187 "%.200s() takes no arguments (%zd given)",
188 func->m_ml->ml_name, nargs);
189 return NULL;
190 }
191
192 result = (*meth) (self, NULL);
193 break;
194
195 case METH_O:
196 if (kwargs != NULL && PyDict_Size(kwargs) != 0) {
197 PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
198 func->m_ml->ml_name);
199 return NULL;
200 }
201
202 if (nargs != 1) {
203 PyErr_Format(PyExc_TypeError,
204 "%.200s() takes exactly one argument (%zd given)",
205 func->m_ml->ml_name, nargs);
206 return NULL;
207 }
208
209 result = (*meth) (self, args[0]);
210 break;
211
212 case METH_VARARGS:
213 case METH_VARARGS | METH_KEYWORDS:
214 {
215 /* Slow-path: create a temporary tuple */
216 PyObject *tuple;
217
218 if (!(flags & METH_KEYWORDS) && kwargs != NULL && PyDict_Size(kwargs) != 0) {
219 PyErr_Format(PyExc_TypeError,
220 "%.200s() takes no keyword arguments",
221 func->m_ml->ml_name);
222 return NULL;
223 }
224
225 tuple = _PyStack_AsTuple(args, nargs);
226 if (tuple == NULL) {
227 return NULL;
228 }
229
230 if (flags & METH_KEYWORDS) {
231 result = (*(PyCFunctionWithKeywords)meth) (self, tuple, kwargs);
232 }
233 else {
234 result = (*meth) (self, tuple);
235 }
236 Py_DECREF(tuple);
237 break;
238 }
239
240 case METH_FASTCALL:
241 {
242 PyObject **stack;
243 PyObject *kwnames;
244 _PyCFunctionFast fastmeth = (_PyCFunctionFast)meth;
245
246 stack = _PyStack_UnpackDict(args, nargs, kwargs, &kwnames, func_obj);
247 if (stack == NULL) {
248 return NULL;
249 }
250
251 result = (*fastmeth) (self, stack, nargs, kwnames);
252 if (stack != args) {
253 PyMem_Free(stack);
254 }
255 Py_XDECREF(kwnames);
256 break;
257 }
258
259 default:
260 PyErr_SetString(PyExc_SystemError,
261 "Bad call flags in PyCFunction_Call. "
262 "METH_OLDARGS is no longer supported!");
263 return NULL;
264 }
265
266 result = _Py_CheckFunctionResult(func_obj, result, NULL);
267
268 return result;
269 }
270
271 PyObject *
_PyCFunction_FastCallKeywords(PyObject * func,PyObject ** stack,Py_ssize_t nargs,PyObject * kwnames)272 _PyCFunction_FastCallKeywords(PyObject *func, PyObject **stack,
273 Py_ssize_t nargs, PyObject *kwnames)
274 {
275 PyObject *kwdict, *result;
276 Py_ssize_t nkwargs = (kwnames == NULL) ? 0 : PyTuple_GET_SIZE(kwnames);
277
278 assert(PyCFunction_Check(func));
279 assert(nargs >= 0);
280 assert(kwnames == NULL || PyTuple_CheckExact(kwnames));
281 assert((nargs == 0 && nkwargs == 0) || stack != NULL);
282 /* kwnames must only contains str strings, no subclass, and all keys must
283 be unique */
284
285 if (nkwargs > 0) {
286 kwdict = _PyStack_AsDict(stack + nargs, kwnames);
287 if (kwdict == NULL) {
288 return NULL;
289 }
290 }
291 else {
292 kwdict = NULL;
293 }
294
295 result = _PyCFunction_FastCallDict(func, stack, nargs, kwdict);
296 Py_XDECREF(kwdict);
297 return result;
298 }
299
300 /* Methods (the standard built-in methods, that is) */
301
302 static void
meth_dealloc(PyCFunctionObject * m)303 meth_dealloc(PyCFunctionObject *m)
304 {
305 _PyObject_GC_UNTRACK(m);
306 if (m->m_weakreflist != NULL) {
307 PyObject_ClearWeakRefs((PyObject*) m);
308 }
309 Py_XDECREF(m->m_self);
310 Py_XDECREF(m->m_module);
311 if (numfree < PyCFunction_MAXFREELIST) {
312 m->m_self = (PyObject *)free_list;
313 free_list = m;
314 numfree++;
315 }
316 else {
317 PyObject_GC_Del(m);
318 }
319 }
320
321 static PyObject *
meth_reduce(PyCFunctionObject * m)322 meth_reduce(PyCFunctionObject *m)
323 {
324 PyObject *builtins;
325 PyObject *getattr;
326 _Py_IDENTIFIER(getattr);
327
328 if (m->m_self == NULL || PyModule_Check(m->m_self))
329 return PyUnicode_FromString(m->m_ml->ml_name);
330
331 builtins = PyEval_GetBuiltins();
332 getattr = _PyDict_GetItemId(builtins, &PyId_getattr);
333 return Py_BuildValue("O(Os)", getattr, m->m_self, m->m_ml->ml_name);
334 }
335
336 static PyMethodDef meth_methods[] = {
337 {"__reduce__", (PyCFunction)meth_reduce, METH_NOARGS, NULL},
338 {NULL, NULL}
339 };
340
341 static PyObject *
meth_get__text_signature__(PyCFunctionObject * m,void * closure)342 meth_get__text_signature__(PyCFunctionObject *m, void *closure)
343 {
344 return _PyType_GetTextSignatureFromInternalDoc(m->m_ml->ml_name, m->m_ml->ml_doc);
345 }
346
347 static PyObject *
meth_get__doc__(PyCFunctionObject * m,void * closure)348 meth_get__doc__(PyCFunctionObject *m, void *closure)
349 {
350 return _PyType_GetDocFromInternalDoc(m->m_ml->ml_name, m->m_ml->ml_doc);
351 }
352
353 static PyObject *
meth_get__name__(PyCFunctionObject * m,void * closure)354 meth_get__name__(PyCFunctionObject *m, void *closure)
355 {
356 return PyUnicode_FromString(m->m_ml->ml_name);
357 }
358
359 static PyObject *
meth_get__qualname__(PyCFunctionObject * m,void * closure)360 meth_get__qualname__(PyCFunctionObject *m, void *closure)
361 {
362 /* If __self__ is a module or NULL, return m.__name__
363 (e.g. len.__qualname__ == 'len')
364
365 If __self__ is a type, return m.__self__.__qualname__ + '.' + m.__name__
366 (e.g. dict.fromkeys.__qualname__ == 'dict.fromkeys')
367
368 Otherwise return type(m.__self__).__qualname__ + '.' + m.__name__
369 (e.g. [].append.__qualname__ == 'list.append') */
370 PyObject *type, *type_qualname, *res;
371 _Py_IDENTIFIER(__qualname__);
372
373 if (m->m_self == NULL || PyModule_Check(m->m_self))
374 return PyUnicode_FromString(m->m_ml->ml_name);
375
376 type = PyType_Check(m->m_self) ? m->m_self : (PyObject*)Py_TYPE(m->m_self);
377
378 type_qualname = _PyObject_GetAttrId(type, &PyId___qualname__);
379 if (type_qualname == NULL)
380 return NULL;
381
382 if (!PyUnicode_Check(type_qualname)) {
383 PyErr_SetString(PyExc_TypeError, "<method>.__class__."
384 "__qualname__ is not a unicode object");
385 Py_XDECREF(type_qualname);
386 return NULL;
387 }
388
389 res = PyUnicode_FromFormat("%S.%s", type_qualname, m->m_ml->ml_name);
390 Py_DECREF(type_qualname);
391 return res;
392 }
393
394 static int
meth_traverse(PyCFunctionObject * m,visitproc visit,void * arg)395 meth_traverse(PyCFunctionObject *m, visitproc visit, void *arg)
396 {
397 Py_VISIT(m->m_self);
398 Py_VISIT(m->m_module);
399 return 0;
400 }
401
402 static PyObject *
meth_get__self__(PyCFunctionObject * m,void * closure)403 meth_get__self__(PyCFunctionObject *m, void *closure)
404 {
405 PyObject *self;
406
407 self = PyCFunction_GET_SELF(m);
408 if (self == NULL)
409 self = Py_None;
410 Py_INCREF(self);
411 return self;
412 }
413
414 static PyGetSetDef meth_getsets [] = {
415 {"__doc__", (getter)meth_get__doc__, NULL, NULL},
416 {"__name__", (getter)meth_get__name__, NULL, NULL},
417 {"__qualname__", (getter)meth_get__qualname__, NULL, NULL},
418 {"__self__", (getter)meth_get__self__, NULL, NULL},
419 {"__text_signature__", (getter)meth_get__text_signature__, NULL, NULL},
420 {0}
421 };
422
423 #define OFF(x) offsetof(PyCFunctionObject, x)
424
425 static PyMemberDef meth_members[] = {
426 {"__module__", T_OBJECT, OFF(m_module), PY_WRITE_RESTRICTED},
427 {NULL}
428 };
429
430 static PyObject *
meth_repr(PyCFunctionObject * m)431 meth_repr(PyCFunctionObject *m)
432 {
433 if (m->m_self == NULL || PyModule_Check(m->m_self))
434 return PyUnicode_FromFormat("<built-in function %s>",
435 m->m_ml->ml_name);
436 return PyUnicode_FromFormat("<built-in method %s of %s object at %p>",
437 m->m_ml->ml_name,
438 m->m_self->ob_type->tp_name,
439 m->m_self);
440 }
441
442 static PyObject *
meth_richcompare(PyObject * self,PyObject * other,int op)443 meth_richcompare(PyObject *self, PyObject *other, int op)
444 {
445 PyCFunctionObject *a, *b;
446 PyObject *res;
447 int eq;
448
449 if ((op != Py_EQ && op != Py_NE) ||
450 !PyCFunction_Check(self) ||
451 !PyCFunction_Check(other))
452 {
453 Py_RETURN_NOTIMPLEMENTED;
454 }
455 a = (PyCFunctionObject *)self;
456 b = (PyCFunctionObject *)other;
457 eq = a->m_self == b->m_self;
458 if (eq)
459 eq = a->m_ml->ml_meth == b->m_ml->ml_meth;
460 if (op == Py_EQ)
461 res = eq ? Py_True : Py_False;
462 else
463 res = eq ? Py_False : Py_True;
464 Py_INCREF(res);
465 return res;
466 }
467
468 static Py_hash_t
meth_hash(PyCFunctionObject * a)469 meth_hash(PyCFunctionObject *a)
470 {
471 Py_hash_t x, y;
472 if (a->m_self == NULL)
473 x = 0;
474 else {
475 x = PyObject_Hash(a->m_self);
476 if (x == -1)
477 return -1;
478 }
479 y = _Py_HashPointer((void*)(a->m_ml->ml_meth));
480 if (y == -1)
481 return -1;
482 x ^= y;
483 if (x == -1)
484 x = -2;
485 return x;
486 }
487
488
489 PyTypeObject PyCFunction_Type = {
490 PyVarObject_HEAD_INIT(&PyType_Type, 0)
491 "builtin_function_or_method",
492 sizeof(PyCFunctionObject),
493 0,
494 (destructor)meth_dealloc, /* tp_dealloc */
495 0, /* tp_print */
496 0, /* tp_getattr */
497 0, /* tp_setattr */
498 0, /* tp_reserved */
499 (reprfunc)meth_repr, /* tp_repr */
500 0, /* tp_as_number */
501 0, /* tp_as_sequence */
502 0, /* tp_as_mapping */
503 (hashfunc)meth_hash, /* tp_hash */
504 PyCFunction_Call, /* tp_call */
505 0, /* tp_str */
506 PyObject_GenericGetAttr, /* tp_getattro */
507 0, /* tp_setattro */
508 0, /* tp_as_buffer */
509 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
510 0, /* tp_doc */
511 (traverseproc)meth_traverse, /* tp_traverse */
512 0, /* tp_clear */
513 meth_richcompare, /* tp_richcompare */
514 offsetof(PyCFunctionObject, m_weakreflist), /* tp_weaklistoffset */
515 0, /* tp_iter */
516 0, /* tp_iternext */
517 meth_methods, /* tp_methods */
518 meth_members, /* tp_members */
519 meth_getsets, /* tp_getset */
520 0, /* tp_base */
521 0, /* tp_dict */
522 };
523
524 /* Clear out the free list */
525
526 int
PyCFunction_ClearFreeList(void)527 PyCFunction_ClearFreeList(void)
528 {
529 int freelist_size = numfree;
530
531 while (free_list) {
532 PyCFunctionObject *v = free_list;
533 free_list = (PyCFunctionObject *)(v->m_self);
534 PyObject_GC_Del(v);
535 numfree--;
536 }
537 assert(numfree == 0);
538 return freelist_size;
539 }
540
541 void
PyCFunction_Fini(void)542 PyCFunction_Fini(void)
543 {
544 (void)PyCFunction_ClearFreeList();
545 }
546
547 /* Print summary info about the state of the optimized allocator */
548 void
_PyCFunction_DebugMallocStats(FILE * out)549 _PyCFunction_DebugMallocStats(FILE *out)
550 {
551 _PyDebugAllocatorStats(out,
552 "free PyCFunctionObject",
553 numfree, sizeof(PyCFunctionObject));
554 }
555