Repository navigation
classobject.c
1
/* Class object implementation (dead now except for methods) */
3
#include "Python.h"
4
#include "structmember.h"
6
#define TP_DESCR_GET(t) ((t)->tp_descr_get)
8
/* Free list for method objects to safe malloc/free overhead
9
* The im_self element is used to chain the elements.
10
*/
11
static PyMethodObject *free_list;
12
static int numfree = 0;
13
#ifndef PyMethod_MAXFREELIST
14
#define PyMethod_MAXFREELIST 256
15
#endif
16
17
_Py_IDENTIFIER(__name__);
18
_Py_IDENTIFIER(__qualname__);
20
PyObject *
21
PyMethod_Function(PyObject *im)
22
{
23
if (!PyMethod_Check(im)) {
24
PyErr_BadInternalCall();
25
return NULL;
26
}
27
return ((PyMethodObject *)im)->im_func;
28
}
29
30
PyObject *
31
PyMethod_Self(PyObject *im)
32
{
33
if (!PyMethod_Check(im)) {
34
PyErr_BadInternalCall();
35
return NULL;
36
}
37
return ((PyMethodObject *)im)->im_self;
40
/* Method objects are used for bound instance methods returned by
41
instancename.methodname. ClassName.methodname returns an ordinary
42
function.
45
PyObject *
46
PyMethod_New(PyObject *func, PyObject *self)
48
PyMethodObject *im;
49
if (self == NULL) {
50
PyErr_BadInternalCall();
51
return NULL;
52
}
53
im = free_list;
54
if (im != NULL) {
55
free_list = (PyMethodObject *)(im->im_self);
56
(void)PyObject_INIT(im, &PyMethod_Type);
57
numfree--;
58
}
59
else {
60
im = PyObject_GC_New(PyMethodObject, &PyMethod_Type);
61
if (im == NULL)
62
return NULL;
63
}
64
im->im_weakreflist = NULL;
65
Py_INCREF(func);
66
im->im_func = func;
67
Py_XINCREF(self);
68
im->im_self = self;
69
_PyObject_GC_TRACK(im);
70
return (PyObject *)im;
71
}
72
73
static PyObject *
74
method_reduce(PyMethodObject *im)
75
{
76
PyObject *self = PyMethod_GET_SELF(im);
77
PyObject *func = PyMethod_GET_FUNCTION(im);
78
PyObject *builtins;
79
PyObject *getattr;
80
PyObject *funcname;
81
_Py_IDENTIFIER(getattr);
82
83
funcname = _PyObject_GetAttrId(func, &PyId___name__);
84
if (funcname == NULL) {
85
return NULL;
86
}
87
builtins = PyEval_GetBuiltins();
88
getattr = _PyDict_GetItemId(builtins, &PyId_getattr);
89
return Py_BuildValue("O(ON)", getattr, self, funcname);
90
}
91
92
static PyMethodDef method_methods[] = {
93
{"__reduce__", (PyCFunction)method_reduce, METH_NOARGS, NULL},
94
{NULL, NULL}
95
};
96
97
/* Descriptors for PyMethod attributes */
98
99
/* im_func and im_self are stored in the PyMethod object */
101
#define MO_OFF(x) offsetof(PyMethodObject, x)
103
static PyMemberDef method_memberlist[] = {
104
{"__func__", T_OBJECT, MO_OFF(im_func), READONLY|RESTRICTED,
105
"the function (or other callable) implementing a method"},
106
{"__self__", T_OBJECT, MO_OFF(im_self), READONLY|RESTRICTED,
107
"the instance to which a method is bound"},
108
{NULL} /* Sentinel */
109
};
110
111
/* Christian Tismer argued convincingly that method attributes should
112
(nearly) always override function attributes.
113
The one exception is __doc__; there's a default __doc__ which
114
should only be used for the class, not for instances */
115
116
static PyObject *
117
method_get_doc(PyMethodObject *im, void *context)
119
static PyObject *docstr;
120
if (docstr == NULL) {
121
docstr= PyUnicode_InternFromString("__doc__");
122
if (docstr == NULL)
123
return NULL;
124
}
125
return PyObject_GetAttr(im->im_func, docstr);
128
static PyGetSetDef method_getset[] = {
129
{"__doc__", (getter)method_get_doc, NULL, NULL},
130
{0}
133
static PyObject *
134
method_getattro(PyObject *obj, PyObject *name)
136
PyMethodObject *im = (PyMethodObject *)obj;
137
PyTypeObject *tp = obj->ob_type;
138
PyObject *descr = NULL;
139
140
{
141
if (tp->tp_dict == NULL) {
142
if (PyType_Ready(tp) < 0)
143
return NULL;
144
}
145
descr = _PyType_Lookup(tp, name);
146
}
147
148
if (descr != NULL) {
149
descrgetfunc f = TP_DESCR_GET(descr->ob_type);
150
if (f != NULL)
151
return f(descr, obj, (PyObject *)obj->ob_type);
152
else {
153
Py_INCREF(descr);
154
return descr;
155
}
156
}
157
158
return PyObject_GetAttr(im->im_func, name);
159
}
160
161
PyDoc_STRVAR(method_doc,
162
"method(function, instance)\n\
164
Create a bound instance method object.");
165
166
static PyObject *
167
method_new(PyTypeObject* type, PyObject* args, PyObject *kw)
169
PyObject *func;
170
PyObject *self;
171
172
if (!_PyArg_NoKeywords("method", kw))
173
return NULL;
174
if (!PyArg_UnpackTuple(args, "method", 2, 2,
175
&func, &self))
176
return NULL;
177
if (!PyCallable_Check(func)) {
178
PyErr_SetString(PyExc_TypeError,
179
"first argument must be callable");
180
return NULL;
181
}
182
if (self == NULL || self == Py_None) {
183
PyErr_SetString(PyExc_TypeError,
184
"self must not be None");
185
return NULL;
186
}
187
188
return PyMethod_New(func, self);
191
static void
192
method_dealloc(PyMethodObject *im)
193
{
194
_PyObject_GC_UNTRACK(im);
195
if (im->im_weakreflist != NULL)
196
PyObject_ClearWeakRefs((PyObject *)im);
197
Py_DECREF(im->im_func);
198
Py_XDECREF(im->im_self);
199
if (numfree < PyMethod_MAXFREELIST) {
200
im->im_self = (PyObject *)free_list;
201
free_list = im;
202
numfree++;
203
}
204
else {
205
PyObject_GC_Del(im);
206
}
207
}
208
209
static PyObject *
210
method_richcompare(PyObject *self, PyObject *other, int op)
212
PyMethodObject *a, *b;
213
PyObject *res;
214
int eq;
215
216
if ((op != Py_EQ && op != Py_NE) ||
217
!PyMethod_Check(self) ||
218
!PyMethod_Check(other))
219
{
220
Py_RETURN_NOTIMPLEMENTED;
221
}
222
a = (PyMethodObject *)self;
223
b = (PyMethodObject *)other;
224
eq = PyObject_RichCompareBool(a->im_func, b->im_func, Py_EQ);
225
if (eq == 1) {
226
if (a->im_self == NULL || b->im_self == NULL)
227
eq = a->im_self == b->im_self;
228
else
229
eq = PyObject_RichCompareBool(a->im_self, b->im_self,
230
Py_EQ);
231
}
232
if (eq < 0)
233
return NULL;
234
if (op == Py_EQ)
235
res = eq ? Py_True : Py_False;
236
else
237
res = eq ? Py_False : Py_True;
238
Py_INCREF(res);
239
return res;
242
static PyObject *
243
method_repr(PyMethodObject *a)
245
PyObject *self = a->im_self;
246
PyObject *func = a->im_func;
247
PyObject *funcname = NULL, *result = NULL;
248
const char *defname = "?";
250
funcname = _PyObject_GetAttrId(func, &PyId___qualname__);
251
if (funcname == NULL) {
252
if (!PyErr_ExceptionMatches(PyExc_AttributeError))
253
return NULL;
254
PyErr_Clear();
255
256
funcname = _PyObject_GetAttrId(func, &PyId___name__);
257
if (funcname == NULL) {
258
if (!PyErr_ExceptionMatches(PyExc_AttributeError))
259
return NULL;
260
PyErr_Clear();
261
}
264
if (funcname != NULL && !PyUnicode_Check(funcname)) {
265
Py_DECREF(funcname);
266
funcname = NULL;
267
}
268
269
/* XXX Shouldn't use repr()/%R here! */
270
result = PyUnicode_FromFormat("<bound method %V of %R>",
271
funcname, defname, self);
272
273
Py_XDECREF(funcname);
274
return result;
275
}
276
277
static Py_hash_t
278
method_hash(PyMethodObject *a)
280
Py_hash_t x, y;
281
if (a->im_self == NULL)
282
x = PyObject_Hash(Py_None);
283
else
284
x = PyObject_Hash(a->im_self);
285
if (x == -1)
286
return -1;
287
y = PyObject_Hash(a->im_func);
288
if (y == -1)
289
return -1;
290
x = x ^ y;
291
if (x == -1)
292
x = -2;
293
return x;
296
static int
297
method_traverse(PyMethodObject *im, visitproc visit, void *arg)
299
Py_VISIT(im->im_func);
300
Py_VISIT(im->im_self);
301
return 0;
304
static PyObject *
305
method_call(PyObject *method, PyObject *args, PyObject *kwargs)
307
PyObject *self, *func;
309
self = PyMethod_GET_SELF(method);
310
if (self == NULL) {
311
PyErr_BadInternalCall();
312
return NULL;
313
}
314
315
func = PyMethod_GET_FUNCTION(method);
316
317
return _PyObject_Call_Prepend(func, self, args, kwargs);
320
static PyObject *
321
method_descr_get(PyObject *meth, PyObject *obj, PyObject *cls)
323
/* Don't rebind an already bound method of a class that's not a base
324
class of cls. */
325
if (PyMethod_GET_SELF(meth) != NULL) {
326
/* Already bound */
327
Py_INCREF(meth);
328
return meth;
329
}
330
/* Bind it to obj */
331
return PyMethod_New(PyMethod_GET_FUNCTION(meth), obj);
334
PyTypeObject PyMethod_Type = {
335
PyVarObject_HEAD_INIT(&PyType_Type, 0)
336
"method",
337
sizeof(PyMethodObject),
338
0,
339
(destructor)method_dealloc, /* tp_dealloc */
340
0, /* tp_print */
341
0, /* tp_getattr */
342
0, /* tp_setattr */
343
0, /* tp_reserved */
344
(reprfunc)method_repr, /* tp_repr */
345
0, /* tp_as_number */
346
0, /* tp_as_sequence */
347
0, /* tp_as_mapping */
348
(hashfunc)method_hash, /* tp_hash */
349
method_call, /* tp_call */
350
0, /* tp_str */
351
method_getattro, /* tp_getattro */
352
PyObject_GenericSetAttr, /* tp_setattro */
353
0, /* tp_as_buffer */
354
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
355
method_doc, /* tp_doc */
356
(traverseproc)method_traverse, /* tp_traverse */
357
0, /* tp_clear */
358
method_richcompare, /* tp_richcompare */
359
offsetof(PyMethodObject, im_weakreflist), /* tp_weaklistoffset */
360
0, /* tp_iter */
361
0, /* tp_iternext */
362
method_methods, /* tp_methods */
363
method_memberlist, /* tp_members */
364
method_getset, /* tp_getset */
365
0, /* tp_base */
366
0, /* tp_dict */
367
method_descr_get, /* tp_descr_get */
368
0, /* tp_descr_set */
369
0, /* tp_dictoffset */
370
0, /* tp_init */
371
0, /* tp_alloc */
372
method_new, /* tp_new */
373
};
374
375
/* Clear out the free list */
376
377
int
378
PyMethod_ClearFreeList(void)
380
int freelist_size = numfree;
381
382
while (free_list) {
383
PyMethodObject *im = free_list;
384
free_list = (PyMethodObject *)(im->im_self);
385
PyObject_GC_Del(im);
386
numfree--;
387
}
388
assert(numfree == 0);
389
return freelist_size;
390
}
391
392
void
393
PyMethod_Fini(void)
394
{
395
(void)PyMethod_ClearFreeList();
398
/* Print summary info about the state of the optimized allocator */
399
void
400
_PyMethod_DebugMallocStats(FILE *out)
401
{
402
_PyDebugAllocatorStats(out,
403
"free PyMethodObject",
404
numfree, sizeof(PyMethodObject));
405
}
406
407
/* ------------------------------------------------------------------------
408
* instance method
409
*/
410
411
PyObject *
412
PyInstanceMethod_New(PyObject *func) {
413
PyInstanceMethodObject *method;
414
method = PyObject_GC_New(PyInstanceMethodObject,
415
&PyInstanceMethod_Type);
416
if (method == NULL) return NULL;
417
Py_INCREF(func);
418
method->func = func;
419
_PyObject_GC_TRACK(method);
420
return (PyObject *)method;
421
}
422
423
PyObject *
424
PyInstanceMethod_Function(PyObject *im)
425
{
426
if (!PyInstanceMethod_Check(im)) {
427
PyErr_BadInternalCall();
428
return NULL;
429
}
430
return PyInstanceMethod_GET_FUNCTION(im);
431
}
432
433
#define IMO_OFF(x) offsetof(PyInstanceMethodObject, x)
434
435
static PyMemberDef instancemethod_memberlist[] = {
436
{"__func__", T_OBJECT, IMO_OFF(func), READONLY|RESTRICTED,
437
"the function (or other callable) implementing a method"},
438
{NULL} /* Sentinel */
439
};
440
441
static PyObject *
442
instancemethod_get_doc(PyObject *self, void *context)
443
{
444
static PyObject *docstr;
445
if (docstr == NULL) {
446
docstr = PyUnicode_InternFromString("__doc__");
447
if (docstr == NULL)
448
return NULL;
449
}
450
return PyObject_GetAttr(PyInstanceMethod_GET_FUNCTION(self), docstr);
451
}
452
453
static PyGetSetDef instancemethod_getset[] = {
454
{"__doc__", (getter)instancemethod_get_doc, NULL, NULL},
455
{0}
456
};
457
458
static PyObject *
459
instancemethod_getattro(PyObject *self, PyObject *name)
460
{
461
PyTypeObject *tp = self->ob_type;
462
PyObject *descr = NULL;
463
464
if (tp->tp_dict == NULL) {
465
if (PyType_Ready(tp) < 0)
466
return NULL;
467
}
468
descr = _PyType_Lookup(tp, name);
469
470
if (descr != NULL) {
471
descrgetfunc f = TP_DESCR_GET(descr->ob_type);
472
if (f != NULL)
473
return f(descr, self, (PyObject *)self->ob_type);
474
else {
475
Py_INCREF(descr);
476
return descr;
477
}
478
}
479
480
return PyObject_GetAttr(PyInstanceMethod_GET_FUNCTION(self), name);
481
}
482
483
static void
484
instancemethod_dealloc(PyObject *self) {
485
_PyObject_GC_UNTRACK(self);
486
Py_DECREF(PyInstanceMethod_GET_FUNCTION(self));
487
PyObject_GC_Del(self);
488
}
489
490
static int
491
instancemethod_traverse(PyObject *self, visitproc visit, void *arg) {
492
Py_VISIT(PyInstanceMethod_GET_FUNCTION(self));
493
return 0;
494
}
495
496
static PyObject *
497
instancemethod_call(PyObject *self, PyObject *arg, PyObject *kw)
498
{
499
return PyObject_Call(PyMethod_GET_FUNCTION(self), arg, kw);
500
}
501
502
static PyObject *
503
instancemethod_descr_get(PyObject *descr, PyObject *obj, PyObject *type) {
504
PyObject *func = PyInstanceMethod_GET_FUNCTION(descr);
505
if (obj == NULL) {
506
Py_INCREF(func);
507
return func;
508
}
509
else
510
return PyMethod_New(func, obj);
511
}
512
513
static PyObject *
514
instancemethod_richcompare(PyObject *self, PyObject *other, int op)
515
{
516
PyInstanceMethodObject *a, *b;
517
PyObject *res;
518
int eq;
519
520
if ((op != Py_EQ && op != Py_NE) ||
521
!PyInstanceMethod_Check(self) ||
522
!PyInstanceMethod_Check(other))
523
{
524
Py_RETURN_NOTIMPLEMENTED;
525
}
526
a = (PyInstanceMethodObject *)self;
527
b = (PyInstanceMethodObject *)other;
528
eq = PyObject_RichCompareBool(a->func, b->func, Py_EQ);
529
if (eq < 0)
530
return NULL;
531
if (op == Py_EQ)
532
res = eq ? Py_True : Py_False;
533
else
534
res = eq ? Py_False : Py_True;
535
Py_INCREF(res);
536
return res;
537
}
538
539
static PyObject *
540
instancemethod_repr(PyObject *self)
541
{
542
PyObject *func = PyInstanceMethod_Function(self);
543
PyObject *funcname = NULL , *result = NULL;
544
char *defname = "?";
545
546
if (func == NULL) {
547
PyErr_BadInternalCall();
548
return NULL;
549
}
550
551
funcname = _PyObject_GetAttrId(func, &PyId___name__);
552
if (funcname == NULL) {
553
if (!PyErr_ExceptionMatches(PyExc_AttributeError))
554
return NULL;
555
PyErr_Clear();
556
}
557
else if (!PyUnicode_Check(funcname)) {
558
Py_DECREF(funcname);
559
funcname = NULL;
560
}
561
562
result = PyUnicode_FromFormat("<instancemethod %V at %p>",
563
funcname, defname, self);
564
565
Py_XDECREF(funcname);
566
return result;
567
}
568
569
/*
570
static long
571
instancemethod_hash(PyObject *self)
572
{
573
long x, y;
574
x = (long)self;
575
y = PyObject_Hash(PyInstanceMethod_GET_FUNCTION(self));
576
if (y == -1)
577
return -1;
578
x = x ^ y;
579
if (x == -1)
580
x = -2;
581
return x;
582
}
583
*/
584
585
PyDoc_STRVAR(instancemethod_doc,
586
"instancemethod(function)\n\
587
\n\
588
Bind a function to a class.");
589
590
static PyObject *
591
instancemethod_new(PyTypeObject* type, PyObject* args, PyObject *kw)
592
{
593
PyObject *func;
594
595
if (!_PyArg_NoKeywords("instancemethod", kw))
596
return NULL;
597
if (!PyArg_UnpackTuple(args, "instancemethod", 1, 1, &func))
598
return NULL;
599
if (!PyCallable_Check(func)) {
600
PyErr_SetString(PyExc_TypeError,
601
"first argument must be callable");
602
return NULL;
603
}
604
605
return PyInstanceMethod_New(func);
606
}
607
608
PyTypeObject PyInstanceMethod_Type = {
609
PyVarObject_HEAD_INIT(&PyType_Type, 0)
610
"instancemethod", /* tp_name */
611
sizeof(PyInstanceMethodObject), /* tp_basicsize */
612
0, /* tp_itemsize */
613
instancemethod_dealloc, /* tp_dealloc */
614
0, /* tp_print */
615
0, /* tp_getattr */
616
0, /* tp_setattr */
617
0, /* tp_reserved */
618
(reprfunc)instancemethod_repr, /* tp_repr */
619
0, /* tp_as_number */
620
0, /* tp_as_sequence */
621
0, /* tp_as_mapping */
622
0, /*(hashfunc)instancemethod_hash, tp_hash */
623
instancemethod_call, /* tp_call */
624
0, /* tp_str */
625
instancemethod_getattro, /* tp_getattro */
626
PyObject_GenericSetAttr, /* tp_setattro */
627
0, /* tp_as_buffer */
628
Py_TPFLAGS_DEFAULT
629
| Py_TPFLAGS_HAVE_GC, /* tp_flags */
630
instancemethod_doc, /* tp_doc */
631
instancemethod_traverse, /* tp_traverse */
632
0, /* tp_clear */
633
instancemethod_richcompare, /* tp_richcompare */
634
0, /* tp_weaklistoffset */
635
0, /* tp_iter */
636
0, /* tp_iternext */
637
0, /* tp_methods */
638
instancemethod_memberlist, /* tp_members */
639
instancemethod_getset, /* tp_getset */
640
0, /* tp_base */
641
0, /* tp_dict */
642
instancemethod_descr_get, /* tp_descr_get */
643
0, /* tp_descr_set */
644
0, /* tp_dictoffset */
645
0, /* tp_init */
646
0, /* tp_alloc */
647
instancemethod_new, /* tp_new */