1/* Descriptors -- a new, flexible way to describe attributes */
2
3#include "Python.h"
4#include "pycore_ceval.h" // _Py_EnterRecursiveCall()
5#include "pycore_object.h" // _PyObject_GC_UNTRACK()
6#include "pycore_pystate.h" // _PyThreadState_GET()
7#include "pycore_tuple.h" // _PyTuple_ITEMS()
8#include "structmember.h" // PyMemberDef
9
10_Py_IDENTIFIER(getattr);
11
12/*[clinic input]
13class mappingproxy "mappingproxyobject *" "&PyDictProxy_Type"
14class property "propertyobject *" "&PyProperty_Type"
15[clinic start generated code]*/
16/*[clinic end generated code: output=da39a3ee5e6b4b0d input=556352653fd4c02e]*/
17
18static void
19descr_dealloc(PyDescrObject *descr)
20{
21 _PyObject_GC_UNTRACK(descr);
22 Py_XDECREF(descr->d_type);
23 Py_XDECREF(descr->d_name);
24 Py_XDECREF(descr->d_qualname);
25 PyObject_GC_Del(descr);
26}
27
28static PyObject *
29descr_name(PyDescrObject *descr)
30{
31 if (descr->d_name != NULL && PyUnicode_Check(descr->d_name))
32 return descr->d_name;
33 return NULL;
34}
35
36static PyObject *
37descr_repr(PyDescrObject *descr, const char *format)
38{
39 PyObject *name = NULL;
40 if (descr->d_name != NULL && PyUnicode_Check(descr->d_name))
41 name = descr->d_name;
42
43 return PyUnicode_FromFormat(format, name, "?", descr->d_type->tp_name);
44}
45
46static PyObject *
47method_repr(PyMethodDescrObject *descr)
48{
49 return descr_repr((PyDescrObject *)descr,
50 "<method '%V' of '%s' objects>");
51}
52
53static PyObject *
54member_repr(PyMemberDescrObject *descr)
55{
56 return descr_repr((PyDescrObject *)descr,
57 "<member '%V' of '%s' objects>");
58}
59
60static PyObject *
61getset_repr(PyGetSetDescrObject *descr)
62{
63 return descr_repr((PyDescrObject *)descr,
64 "<attribute '%V' of '%s' objects>");
65}
66
67static PyObject *
68wrapperdescr_repr(PyWrapperDescrObject *descr)
69{
70 return descr_repr((PyDescrObject *)descr,
71 "<slot wrapper '%V' of '%s' objects>");
72}
73
74static int
75descr_check(PyDescrObject *descr, PyObject *obj)
76{
77 if (!PyObject_TypeCheck(obj, descr->d_type)) {
78 PyErr_Format(PyExc_TypeError,
79 "descriptor '%V' for '%.100s' objects "
80 "doesn't apply to a '%.100s' object",
81 descr_name((PyDescrObject *)descr), "?",
82 descr->d_type->tp_name,
83 Py_TYPE(obj)->tp_name);
84 return -1;
85 }
86 return 0;
87}
88
89static PyObject *
90classmethod_get(PyMethodDescrObject *descr, PyObject *obj, PyObject *type)
91{
92 /* Ensure a valid type. Class methods ignore obj. */
93 if (type == NULL) {
94 if (obj != NULL)
95 type = (PyObject *)Py_TYPE(obj);
96 else {
97 /* Wot - no type?! */
98 PyErr_Format(PyExc_TypeError,
99 "descriptor '%V' for type '%.100s' "
100 "needs either an object or a type",
101 descr_name((PyDescrObject *)descr), "?",
102 PyDescr_TYPE(descr)->tp_name);
103 return NULL;
104 }
105 }
106 if (!PyType_Check(type)) {
107 PyErr_Format(PyExc_TypeError,
108 "descriptor '%V' for type '%.100s' "
109 "needs a type, not a '%.100s' as arg 2",
110 descr_name((PyDescrObject *)descr), "?",
111 PyDescr_TYPE(descr)->tp_name,
112 Py_TYPE(type)->tp_name);
113 return NULL;
114 }
115 if (!PyType_IsSubtype((PyTypeObject *)type, PyDescr_TYPE(descr))) {
116 PyErr_Format(PyExc_TypeError,
117 "descriptor '%V' requires a subtype of '%.100s' "
118 "but received '%.100s'",
119 descr_name((PyDescrObject *)descr), "?",
120 PyDescr_TYPE(descr)->tp_name,
121 ((PyTypeObject *)type)->tp_name);
122 return NULL;
123 }
124 PyTypeObject *cls = NULL;
125 if (descr->d_method->ml_flags & METH_METHOD) {
126 cls = descr->d_common.d_type;
127 }
128 return PyCMethod_New(descr->d_method, type, NULL, cls);
129}
130
131static PyObject *
132method_get(PyMethodDescrObject *descr, PyObject *obj, PyObject *type)
133{
134 if (obj == NULL) {
135 return Py_NewRef(descr);
136 }
137 if (descr_check((PyDescrObject *)descr, obj) < 0) {
138 return NULL;
139 }
140 if (descr->d_method->ml_flags & METH_METHOD) {
141 if (PyType_Check(type)) {
142 return PyCMethod_New(descr->d_method, obj, NULL, descr->d_common.d_type);
143 } else {
144 PyErr_Format(PyExc_TypeError,
145 "descriptor '%V' needs a type, not '%s', as arg 2",
146 descr_name((PyDescrObject *)descr),
147 Py_TYPE(type)->tp_name);
148 return NULL;
149 }
150 } else {
151 return PyCFunction_NewEx(descr->d_method, obj, NULL);
152 }
153}
154
155static PyObject *
156member_get(PyMemberDescrObject *descr, PyObject *obj, PyObject *type)
157{
158 if (obj == NULL) {
159 return Py_NewRef(descr);
160 }
161 if (descr_check((PyDescrObject *)descr, obj) < 0) {
162 return NULL;
163 }
164
165 if (descr->d_member->flags & PY_AUDIT_READ) {
166 if (PySys_Audit("object.__getattr__", "Os",
167 obj ? obj : Py_None, descr->d_member->name) < 0) {
168 return NULL;
169 }
170 }
171
172 return PyMember_GetOne((char *)obj, descr->d_member);
173}
174
175static PyObject *
176getset_get(PyGetSetDescrObject *descr, PyObject *obj, PyObject *type)
177{
178 if (obj == NULL) {
179 return Py_NewRef(descr);
180 }
181 if (descr_check((PyDescrObject *)descr, obj) < 0) {
182 return NULL;
183 }
184 if (descr->d_getset->get != NULL)
185 return descr->d_getset->get(obj, descr->d_getset->closure);
186 PyErr_Format(PyExc_AttributeError,
187 "attribute '%V' of '%.100s' objects is not readable",
188 descr_name((PyDescrObject *)descr), "?",
189 PyDescr_TYPE(descr)->tp_name);
190 return NULL;
191}
192
193static PyObject *
194wrapperdescr_get(PyWrapperDescrObject *descr, PyObject *obj, PyObject *type)
195{
196 if (obj == NULL) {
197 return Py_NewRef(descr);
198 }
199 if (descr_check((PyDescrObject *)descr, obj) < 0) {
200 return NULL;
201 }
202 return PyWrapper_New((PyObject *)descr, obj);
203}
204
205static int
206descr_setcheck(PyDescrObject *descr, PyObject *obj, PyObject *value)
207{
208 assert(obj != NULL);
209 if (!PyObject_TypeCheck(obj, descr->d_type)) {
210 PyErr_Format(PyExc_TypeError,
211 "descriptor '%V' for '%.100s' objects "
212 "doesn't apply to a '%.100s' object",
213 descr_name(descr), "?",
214 descr->d_type->tp_name,
215 Py_TYPE(obj)->tp_name);
216 return -1;
217 }
218 return 0;
219}
220
221static int
222member_set(PyMemberDescrObject *descr, PyObject *obj, PyObject *value)
223{
224 if (descr_setcheck((PyDescrObject *)descr, obj, value) < 0) {
225 return -1;
226 }
227 return PyMember_SetOne((char *)obj, descr->d_member, value);
228}
229
230static int
231getset_set(PyGetSetDescrObject *descr, PyObject *obj, PyObject *value)
232{
233 if (descr_setcheck((PyDescrObject *)descr, obj, value) < 0) {
234 return -1;
235 }
236 if (descr->d_getset->set != NULL) {
237 return descr->d_getset->set(obj, value,
238 descr->d_getset->closure);
239 }
240 PyErr_Format(PyExc_AttributeError,
241 "attribute '%V' of '%.100s' objects is not writable",
242 descr_name((PyDescrObject *)descr), "?",
243 PyDescr_TYPE(descr)->tp_name);
244 return -1;
245}
246
247
248/* Vectorcall functions for each of the PyMethodDescr calling conventions.
249 *
250 * First, common helpers
251 */
252static inline int
253method_check_args(PyObject *func, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
254{
255 assert(!PyErr_Occurred());
256 if (nargs < 1) {
257 PyObject *funcstr = _PyObject_FunctionStr(func);
258 if (funcstr != NULL) {
259 PyErr_Format(PyExc_TypeError,
260 "unbound method %U needs an argument", funcstr);
261 Py_DECREF(funcstr);
262 }
263 return -1;
264 }
265 PyObject *self = args[0];
266 if (descr_check((PyDescrObject *)func, self) < 0) {
267 return -1;
268 }
269 if (kwnames && PyTuple_GET_SIZE(kwnames)) {
270 PyObject *funcstr = _PyObject_FunctionStr(func);
271 if (funcstr != NULL) {
272 PyErr_Format(PyExc_TypeError,
273 "%U takes no keyword arguments", funcstr);
274 Py_DECREF(funcstr);
275 }
276 return -1;
277 }
278 return 0;
279}
280
281typedef void (*funcptr)(void);
282
283static inline funcptr
284method_enter_call(PyThreadState *tstate, PyObject *func)
285{
286 if (_Py_EnterRecursiveCall(tstate, " while calling a Python object")) {
287 return NULL;
288 }
289 return (funcptr)((PyMethodDescrObject *)func)->d_method->ml_meth;
290}
291
292/* Now the actual vectorcall functions */
293static PyObject *
294method_vectorcall_VARARGS(
295 PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
296{
297 PyThreadState *tstate = _PyThreadState_GET();
298 Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
299 if (method_check_args(func, args, nargs, kwnames)) {
300 return NULL;
301 }
302 PyObject *argstuple = _PyTuple_FromArray(args+1, nargs-1);
303 if (argstuple == NULL) {
304 return NULL;
305 }
306 PyCFunction meth = (PyCFunction)method_enter_call(tstate, func);
307 if (meth == NULL) {
308 Py_DECREF(argstuple);
309 return NULL;
310 }
311 PyObject *result = meth(args[0], argstuple);
312 Py_DECREF(argstuple);
313 _Py_LeaveRecursiveCall(tstate);
314 return result;
315}
316
317static PyObject *
318method_vectorcall_VARARGS_KEYWORDS(
319 PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
320{
321 PyThreadState *tstate = _PyThreadState_GET();
322 Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
323 if (method_check_args(func, args, nargs, NULL)) {
324 return NULL;
325 }
326 PyObject *argstuple = _PyTuple_FromArray(args+1, nargs-1);
327 if (argstuple == NULL) {
328 return NULL;
329 }
330 PyObject *result = NULL;
331 /* Create a temporary dict for keyword arguments */
332 PyObject *kwdict = NULL;
333 if (kwnames != NULL && PyTuple_GET_SIZE(kwnames) > 0) {
334 kwdict = _PyStack_AsDict(args + nargs, kwnames);
335 if (kwdict == NULL) {
336 goto exit;
337 }
338 }
339 PyCFunctionWithKeywords meth = (PyCFunctionWithKeywords)
340 method_enter_call(tstate, func);
341 if (meth == NULL) {
342 goto exit;
343 }
344 result = meth(args[0], argstuple, kwdict);
345 _Py_LeaveRecursiveCall(tstate);
346exit:
347 Py_DECREF(argstuple);
348 Py_XDECREF(kwdict);
349 return result;
350}
351
352static PyObject *
353method_vectorcall_FASTCALL_KEYWORDS_METHOD(
354 PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
355{
356 PyThreadState *tstate = _PyThreadState_GET();
357 Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
358 if (method_check_args(func, args, nargs, NULL)) {
359 return NULL;
360 }
361 PyCMethod meth = (PyCMethod) method_enter_call(tstate, func);
362 if (meth == NULL) {
363 return NULL;
364 }
365 PyObject *result = meth(args[0],
366 ((PyMethodDescrObject *)func)->d_common.d_type,
367 args+1, nargs-1, kwnames);
368 Py_LeaveRecursiveCall();
369 return result;
370}
371
372static PyObject *
373method_vectorcall_FASTCALL(
374 PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
375{
376 PyThreadState *tstate = _PyThreadState_GET();
377 Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
378 if (method_check_args(func, args, nargs, kwnames)) {
379 return NULL;
380 }
381 _PyCFunctionFast meth = (_PyCFunctionFast)
382 method_enter_call(tstate, func);
383 if (meth == NULL) {
384 return NULL;
385 }
386 PyObject *result = meth(args[0], args+1, nargs-1);
387 _Py_LeaveRecursiveCall(tstate);
388 return result;
389}
390
391static PyObject *
392method_vectorcall_FASTCALL_KEYWORDS(
393 PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
394{
395 PyThreadState *tstate = _PyThreadState_GET();
396 Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
397 if (method_check_args(func, args, nargs, NULL)) {
398 return NULL;
399 }
400 _PyCFunctionFastWithKeywords meth = (_PyCFunctionFastWithKeywords)
401 method_enter_call(tstate, func);
402 if (meth == NULL) {
403 return NULL;
404 }
405 PyObject *result = meth(args[0], args+1, nargs-1, kwnames);
406 _Py_LeaveRecursiveCall(tstate);
407 return result;
408}
409
410static PyObject *
411method_vectorcall_NOARGS(
412 PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
413{
414 PyThreadState *tstate = _PyThreadState_GET();
415 Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
416 if (method_check_args(func, args, nargs, kwnames)) {
417 return NULL;
418 }
419 if (nargs != 1) {
420 PyObject *funcstr = _PyObject_FunctionStr(func);
421 if (funcstr != NULL) {
422 PyErr_Format(PyExc_TypeError,
423 "%U takes no arguments (%zd given)", funcstr, nargs-1);
424 Py_DECREF(funcstr);
425 }
426 return NULL;
427 }
428 PyCFunction meth = (PyCFunction)method_enter_call(tstate, func);
429 if (meth == NULL) {
430 return NULL;
431 }
432 PyObject *result = meth(args[0], NULL);
433 _Py_LeaveRecursiveCall(tstate);
434 return result;
435}
436
437static PyObject *
438method_vectorcall_O(
439 PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
440{
441 PyThreadState *tstate = _PyThreadState_GET();
442 Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
443 if (method_check_args(func, args, nargs, kwnames)) {
444 return NULL;
445 }
446 if (nargs != 2) {
447 PyObject *funcstr = _PyObject_FunctionStr(func);
448 if (funcstr != NULL) {
449 PyErr_Format(PyExc_TypeError,
450 "%U takes exactly one argument (%zd given)",
451 funcstr, nargs-1);
452 Py_DECREF(funcstr);
453 }
454 return NULL;
455 }
456 PyCFunction meth = (PyCFunction)method_enter_call(tstate, func);
457 if (meth == NULL) {
458 return NULL;
459 }
460 PyObject *result = meth(args[0], args[1]);
461 _Py_LeaveRecursiveCall(tstate);
462 return result;
463}
464
465
466/* Instances of classmethod_descriptor are unlikely to be called directly.
467 For one, the analogous class "classmethod" (for Python classes) is not
468 callable. Second, users are not likely to access a classmethod_descriptor
469 directly, since it means pulling it from the class __dict__.
470
471 This is just an excuse to say that this doesn't need to be optimized:
472 we implement this simply by calling __get__ and then calling the result.
473*/
474static PyObject *
475classmethoddescr_call(PyMethodDescrObject *descr, PyObject *args,
476 PyObject *kwds)
477{
478 Py_ssize_t argc = PyTuple_GET_SIZE(args);
479 if (argc < 1) {
480 PyErr_Format(PyExc_TypeError,
481 "descriptor '%V' of '%.100s' "
482 "object needs an argument",
483 descr_name((PyDescrObject *)descr), "?",
484 PyDescr_TYPE(descr)->tp_name);
485 return NULL;
486 }
487 PyObject *self = PyTuple_GET_ITEM(args, 0);
488 PyObject *bound = classmethod_get(descr, NULL, self);
489 if (bound == NULL) {
490 return NULL;
491 }
492 PyObject *res = PyObject_VectorcallDict(bound, _PyTuple_ITEMS(args)+1,
493 argc-1, kwds);
494 Py_DECREF(bound);
495 return res;
496}
497
498Py_LOCAL_INLINE(PyObject *)
499wrapperdescr_raw_call(PyWrapperDescrObject *descr, PyObject *self,
500 PyObject *args, PyObject *kwds)
501{
502 wrapperfunc wrapper = descr->d_base->wrapper;
503
504 if (descr->d_base->flags & PyWrapperFlag_KEYWORDS) {
505 wrapperfunc_kwds wk = (wrapperfunc_kwds)(void(*)(void))wrapper;
506 return (*wk)(self, args, descr->d_wrapped, kwds);
507 }
508
509 if (kwds != NULL && (!PyDict_Check(kwds) || PyDict_GET_SIZE(kwds) != 0)) {
510 PyErr_Format(PyExc_TypeError,
511 "wrapper %s() takes no keyword arguments",
512 descr->d_base->name);
513 return NULL;
514 }
515 return (*wrapper)(self, args, descr->d_wrapped);
516}
517
518static PyObject *
519wrapperdescr_call(PyWrapperDescrObject *descr, PyObject *args, PyObject *kwds)
520{
521 Py_ssize_t argc;
522 PyObject *self, *result;
523
524 /* Make sure that the first argument is acceptable as 'self' */
525 assert(PyTuple_Check(args));
526 argc = PyTuple_GET_SIZE(args);
527 if (argc < 1) {
528 PyErr_Format(PyExc_TypeError,
529 "descriptor '%V' of '%.100s' "
530 "object needs an argument",
531 descr_name((PyDescrObject *)descr), "?",
532 PyDescr_TYPE(descr)->tp_name);
533 return NULL;
534 }
535 self = PyTuple_GET_ITEM(args, 0);
536 if (!_PyObject_RealIsSubclass((PyObject *)Py_TYPE(self),
537 (PyObject *)PyDescr_TYPE(descr))) {
538 PyErr_Format(PyExc_TypeError,
539 "descriptor '%V' "
540 "requires a '%.100s' object "
541 "but received a '%.100s'",
542 descr_name((PyDescrObject *)descr), "?",
543 PyDescr_TYPE(descr)->tp_name,
544 Py_TYPE(self)->tp_name);
545 return NULL;
546 }
547
548 args = PyTuple_GetSlice(args, 1, argc);
549 if (args == NULL) {
550 return NULL;
551 }
552 result = wrapperdescr_raw_call(descr, self, args, kwds);
553 Py_DECREF(args);
554 return result;
555}
556
557
558static PyObject *
559method_get_doc(PyMethodDescrObject *descr, void *closure)
560{
561 return _PyType_GetDocFromInternalDoc(descr->d_method->ml_name, descr->d_method->ml_doc);
562}
563
564static PyObject *
565method_get_text_signature(PyMethodDescrObject *descr, void *closure)
566{
567 return _PyType_GetTextSignatureFromInternalDoc(descr->d_method->ml_name, descr->d_method->ml_doc);
568}
569
570static PyObject *
571calculate_qualname(PyDescrObject *descr)
572{
573 PyObject *type_qualname, *res;
574 _Py_IDENTIFIER(__qualname__);
575
576 if (descr->d_name == NULL || !PyUnicode_Check(descr->d_name)) {
577 PyErr_SetString(PyExc_TypeError,
578 "<descriptor>.__name__ is not a unicode object");
579 return NULL;
580 }
581
582 type_qualname = _PyObject_GetAttrId((PyObject *)descr->d_type,
583 &PyId___qualname__);
584 if (type_qualname == NULL)
585 return NULL;
586
587 if (!PyUnicode_Check(type_qualname)) {
588 PyErr_SetString(PyExc_TypeError, "<descriptor>.__objclass__."
589 "__qualname__ is not a unicode object");
590 Py_XDECREF(type_qualname);
591 return NULL;
592 }
593
594 res = PyUnicode_FromFormat("%S.%S", type_qualname, descr->d_name);
595 Py_DECREF(type_qualname);
596 return res;
597}
598
599static PyObject *
600descr_get_qualname(PyDescrObject *descr, void *Py_UNUSED(ignored))
601{
602 if (descr->d_qualname == NULL)
603 descr->d_qualname = calculate_qualname(descr);
604 Py_XINCREF(descr->d_qualname);
605 return descr->d_qualname;
606}
607
608static PyObject *
609descr_reduce(PyDescrObject *descr, PyObject *Py_UNUSED(ignored))
610{
611 return Py_BuildValue("N(OO)", _PyEval_GetBuiltinId(&PyId_getattr),
612 PyDescr_TYPE(descr), PyDescr_NAME(descr));
613}
614
615static PyMethodDef descr_methods[] = {
616 {"__reduce__", (PyCFunction)descr_reduce, METH_NOARGS, NULL},
617 {NULL, NULL}
618};
619
620static PyMemberDef descr_members[] = {
621 {"__objclass__", T_OBJECT, offsetof(PyDescrObject, d_type), READONLY},
622 {"__name__", T_OBJECT, offsetof(PyDescrObject, d_name), READONLY},
623 {0}
624};
625
626static PyGetSetDef method_getset[] = {
627 {"__doc__", (getter)method_get_doc},
628 {"__qualname__", (getter)descr_get_qualname},
629 {"__text_signature__", (getter)method_get_text_signature},
630 {0}
631};
632
633static PyObject *
634member_get_doc(PyMemberDescrObject *descr, void *closure)
635{
636 if (descr->d_member->doc == NULL) {
637 Py_RETURN_NONE;
638 }
639 return PyUnicode_FromString(descr->d_member->doc);
640}
641
642static PyGetSetDef member_getset[] = {
643 {"__doc__", (getter)member_get_doc},
644 {"__qualname__", (getter)descr_get_qualname},
645 {0}
646};
647
648static PyObject *
649getset_get_doc(PyGetSetDescrObject *descr, void *closure)
650{
651 if (descr->d_getset->doc == NULL) {
652 Py_RETURN_NONE;
653 }
654 return PyUnicode_FromString(descr->d_getset->doc);
655}
656
657static PyGetSetDef getset_getset[] = {
658 {"__doc__", (getter)getset_get_doc},
659 {"__qualname__", (getter)descr_get_qualname},
660 {0}
661};
662
663static PyObject *
664wrapperdescr_get_doc(PyWrapperDescrObject *descr, void *closure)
665{
666 return _PyType_GetDocFromInternalDoc(descr->d_base->name, descr->d_base->doc);
667}
668
669static PyObject *
670wrapperdescr_get_text_signature(PyWrapperDescrObject *descr, void *closure)
671{
672 return _PyType_GetTextSignatureFromInternalDoc(descr->d_base->name, descr->d_base->doc);
673}
674
675static PyGetSetDef wrapperdescr_getset[] = {
676 {"__doc__", (getter)wrapperdescr_get_doc},
677 {"__qualname__", (getter)descr_get_qualname},
678 {"__text_signature__", (getter)wrapperdescr_get_text_signature},
679 {0}
680};
681
682static int
683descr_traverse(PyObject *self, visitproc visit, void *arg)
684{
685 PyDescrObject *descr = (PyDescrObject *)self;
686 Py_VISIT(descr->d_type);
687 return 0;
688}
689
690PyTypeObject PyMethodDescr_Type = {
691 PyVarObject_HEAD_INIT(&PyType_Type, 0)
692 "method_descriptor",
693 sizeof(PyMethodDescrObject),
694 0,
695 (destructor)descr_dealloc, /* tp_dealloc */
696 offsetof(PyMethodDescrObject, vectorcall), /* tp_vectorcall_offset */
697 0, /* tp_getattr */
698 0, /* tp_setattr */
699 0, /* tp_as_async */
700 (reprfunc)method_repr, /* tp_repr */
701 0, /* tp_as_number */
702 0, /* tp_as_sequence */
703 0, /* tp_as_mapping */
704 0, /* tp_hash */
705 PyVectorcall_Call, /* tp_call */
706 0, /* tp_str */
707 PyObject_GenericGetAttr, /* tp_getattro */
708 0, /* tp_setattro */
709 0, /* tp_as_buffer */
710 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
711 Py_TPFLAGS_HAVE_VECTORCALL |
712 Py_TPFLAGS_METHOD_DESCRIPTOR, /* tp_flags */
713 0, /* tp_doc */
714 descr_traverse, /* tp_traverse */
715 0, /* tp_clear */
716 0, /* tp_richcompare */
717 0, /* tp_weaklistoffset */
718 0, /* tp_iter */
719 0, /* tp_iternext */
720 descr_methods, /* tp_methods */
721 descr_members, /* tp_members */
722 method_getset, /* tp_getset */
723 0, /* tp_base */
724 0, /* tp_dict */
725 (descrgetfunc)method_get, /* tp_descr_get */
726 0, /* tp_descr_set */
727};
728
729/* This is for METH_CLASS in C, not for "f = classmethod(f)" in Python! */
730PyTypeObject PyClassMethodDescr_Type = {
731 PyVarObject_HEAD_INIT(&PyType_Type, 0)
732 "classmethod_descriptor",
733 sizeof(PyMethodDescrObject),
734 0,
735 (destructor)descr_dealloc, /* tp_dealloc */
736 0, /* tp_vectorcall_offset */
737 0, /* tp_getattr */
738 0, /* tp_setattr */
739 0, /* tp_as_async */
740 (reprfunc)method_repr, /* tp_repr */
741 0, /* tp_as_number */
742 0, /* tp_as_sequence */
743 0, /* tp_as_mapping */
744 0, /* tp_hash */
745 (ternaryfunc)classmethoddescr_call, /* tp_call */
746 0, /* tp_str */
747 PyObject_GenericGetAttr, /* tp_getattro */
748 0, /* tp_setattro */
749 0, /* tp_as_buffer */
750 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
751 0, /* tp_doc */
752 descr_traverse, /* tp_traverse */
753 0, /* tp_clear */
754 0, /* tp_richcompare */
755 0, /* tp_weaklistoffset */
756 0, /* tp_iter */
757 0, /* tp_iternext */
758 descr_methods, /* tp_methods */
759 descr_members, /* tp_members */
760 method_getset, /* tp_getset */
761 0, /* tp_base */
762 0, /* tp_dict */
763 (descrgetfunc)classmethod_get, /* tp_descr_get */
764 0, /* tp_descr_set */
765};
766
767PyTypeObject PyMemberDescr_Type = {
768 PyVarObject_HEAD_INIT(&PyType_Type, 0)
769 "member_descriptor",
770 sizeof(PyMemberDescrObject),
771 0,
772 (destructor)descr_dealloc, /* tp_dealloc */
773 0, /* tp_vectorcall_offset */
774 0, /* tp_getattr */
775 0, /* tp_setattr */
776 0, /* tp_as_async */
777 (reprfunc)member_repr, /* tp_repr */
778 0, /* tp_as_number */
779 0, /* tp_as_sequence */
780 0, /* tp_as_mapping */
781 0, /* tp_hash */
782 0, /* tp_call */
783 0, /* tp_str */
784 PyObject_GenericGetAttr, /* tp_getattro */
785 0, /* tp_setattro */
786 0, /* tp_as_buffer */
787 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
788 0, /* tp_doc */
789 descr_traverse, /* tp_traverse */
790 0, /* tp_clear */
791 0, /* tp_richcompare */
792 0, /* tp_weaklistoffset */
793 0, /* tp_iter */
794 0, /* tp_iternext */
795 descr_methods, /* tp_methods */
796 descr_members, /* tp_members */
797 member_getset, /* tp_getset */
798 0, /* tp_base */
799 0, /* tp_dict */
800 (descrgetfunc)member_get, /* tp_descr_get */
801 (descrsetfunc)member_set, /* tp_descr_set */
802};
803
804PyTypeObject PyGetSetDescr_Type = {
805 PyVarObject_HEAD_INIT(&PyType_Type, 0)
806 "getset_descriptor",
807 sizeof(PyGetSetDescrObject),
808 0,
809 (destructor)descr_dealloc, /* tp_dealloc */
810 0, /* tp_vectorcall_offset */
811 0, /* tp_getattr */
812 0, /* tp_setattr */
813 0, /* tp_as_async */
814 (reprfunc)getset_repr, /* tp_repr */
815 0, /* tp_as_number */
816 0, /* tp_as_sequence */
817 0, /* tp_as_mapping */
818 0, /* tp_hash */
819 0, /* tp_call */
820 0, /* tp_str */
821 PyObject_GenericGetAttr, /* tp_getattro */
822 0, /* tp_setattro */
823 0, /* tp_as_buffer */
824 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
825 0, /* tp_doc */
826 descr_traverse, /* tp_traverse */
827 0, /* tp_clear */
828 0, /* tp_richcompare */
829 0, /* tp_weaklistoffset */
830 0, /* tp_iter */
831 0, /* tp_iternext */
832 0, /* tp_methods */
833 descr_members, /* tp_members */
834 getset_getset, /* tp_getset */
835 0, /* tp_base */
836 0, /* tp_dict */
837 (descrgetfunc)getset_get, /* tp_descr_get */
838 (descrsetfunc)getset_set, /* tp_descr_set */
839};
840
841PyTypeObject PyWrapperDescr_Type = {
842 PyVarObject_HEAD_INIT(&PyType_Type, 0)
843 "wrapper_descriptor",
844 sizeof(PyWrapperDescrObject),
845 0,
846 (destructor)descr_dealloc, /* tp_dealloc */
847 0, /* tp_vectorcall_offset */
848 0, /* tp_getattr */
849 0, /* tp_setattr */
850 0, /* tp_as_async */
851 (reprfunc)wrapperdescr_repr, /* tp_repr */
852 0, /* tp_as_number */
853 0, /* tp_as_sequence */
854 0, /* tp_as_mapping */
855 0, /* tp_hash */
856 (ternaryfunc)wrapperdescr_call, /* tp_call */
857 0, /* tp_str */
858 PyObject_GenericGetAttr, /* tp_getattro */
859 0, /* tp_setattro */
860 0, /* tp_as_buffer */
861 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
862 Py_TPFLAGS_METHOD_DESCRIPTOR, /* tp_flags */
863 0, /* tp_doc */
864 descr_traverse, /* tp_traverse */
865 0, /* tp_clear */
866 0, /* tp_richcompare */
867 0, /* tp_weaklistoffset */
868 0, /* tp_iter */
869 0, /* tp_iternext */
870 descr_methods, /* tp_methods */
871 descr_members, /* tp_members */
872 wrapperdescr_getset, /* tp_getset */
873 0, /* tp_base */
874 0, /* tp_dict */
875 (descrgetfunc)wrapperdescr_get, /* tp_descr_get */
876 0, /* tp_descr_set */
877};
878
879static PyDescrObject *
880descr_new(PyTypeObject *descrtype, PyTypeObject *type, const char *name)
881{
882 PyDescrObject *descr;
883
884 descr = (PyDescrObject *)PyType_GenericAlloc(descrtype, 0);
885 if (descr != NULL) {
886 Py_XINCREF(type);
887 descr->d_type = type;
888 descr->d_name = PyUnicode_InternFromString(name);
889 if (descr->d_name == NULL) {
890 Py_DECREF(descr);
891 descr = NULL;
892 }
893 else {
894 descr->d_qualname = NULL;
895 }
896 }
897 return descr;
898}
899
900PyObject *
901PyDescr_NewMethod(PyTypeObject *type, PyMethodDef *method)
902{
903 /* Figure out correct vectorcall function to use */
904 vectorcallfunc vectorcall;
905 switch (method->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS |
906 METH_O | METH_KEYWORDS | METH_METHOD))
907 {
908 case METH_VARARGS:
909 vectorcall = method_vectorcall_VARARGS;
910 break;
911 case METH_VARARGS | METH_KEYWORDS:
912 vectorcall = method_vectorcall_VARARGS_KEYWORDS;
913 break;
914 case METH_FASTCALL:
915 vectorcall = method_vectorcall_FASTCALL;
916 break;
917 case METH_FASTCALL | METH_KEYWORDS:
918 vectorcall = method_vectorcall_FASTCALL_KEYWORDS;
919 break;
920 case METH_NOARGS:
921 vectorcall = method_vectorcall_NOARGS;
922 break;
923 case METH_O:
924 vectorcall = method_vectorcall_O;
925 break;
926 case METH_METHOD | METH_FASTCALL | METH_KEYWORDS:
927 vectorcall = method_vectorcall_FASTCALL_KEYWORDS_METHOD;
928 break;
929 default:
930 PyErr_Format(PyExc_SystemError,
931 "%s() method: bad call flags", method->ml_name);
932 return NULL;
933 }
934
935 PyMethodDescrObject *descr;
936
937 descr = (PyMethodDescrObject *)descr_new(&PyMethodDescr_Type,
938 type, method->ml_name);
939 if (descr != NULL) {
940 descr->d_method = method;
941 descr->vectorcall = vectorcall;
942 }
943 return (PyObject *)descr;
944}
945
946PyObject *
947PyDescr_NewClassMethod(PyTypeObject *type, PyMethodDef *method)
948{
949 PyMethodDescrObject *descr;
950
951 descr = (PyMethodDescrObject *)descr_new(&PyClassMethodDescr_Type,
952 type, method->ml_name);
953 if (descr != NULL)
954 descr->d_method = method;
955 return (PyObject *)descr;
956}
957
958PyObject *
959PyDescr_NewMember(PyTypeObject *type, PyMemberDef *member)
960{
961 PyMemberDescrObject *descr;
962
963 descr = (PyMemberDescrObject *)descr_new(&PyMemberDescr_Type,
964 type, member->name);
965 if (descr != NULL)
966 descr->d_member = member;
967 return (PyObject *)descr;
968}
969
970PyObject *
971PyDescr_NewGetSet(PyTypeObject *type, PyGetSetDef *getset)
972{
973 PyGetSetDescrObject *descr;
974
975 descr = (PyGetSetDescrObject *)descr_new(&PyGetSetDescr_Type,
976 type, getset->name);
977 if (descr != NULL)
978 descr->d_getset = getset;
979 return (PyObject *)descr;
980}
981
982PyObject *
983PyDescr_NewWrapper(PyTypeObject *type, struct wrapperbase *base, void *wrapped)
984{
985 PyWrapperDescrObject *descr;
986
987 descr = (PyWrapperDescrObject *)descr_new(&PyWrapperDescr_Type,
988 type, base->name);
989 if (descr != NULL) {
990 descr->d_base = base;
991 descr->d_wrapped = wrapped;
992 }
993 return (PyObject *)descr;
994}
995
996int
997PyDescr_IsData(PyObject *ob)
998{
999 return Py_TYPE(ob)->tp_descr_set != NULL;
1000}
1001
1002/* --- mappingproxy: read-only proxy for mappings --- */
1003
1004/* This has no reason to be in this file except that adding new files is a
1005 bit of a pain */
1006
1007typedef struct {
1008 PyObject_HEAD
1009 PyObject *mapping;
1010} mappingproxyobject;
1011
1012static Py_ssize_t
1013mappingproxy_len(mappingproxyobject *pp)
1014{
1015 return PyObject_Size(pp->mapping);
1016}
1017
1018static PyObject *
1019mappingproxy_getitem(mappingproxyobject *pp, PyObject *key)
1020{
1021 return PyObject_GetItem(pp->mapping, key);
1022}
1023
1024static PyMappingMethods mappingproxy_as_mapping = {
1025 (lenfunc)mappingproxy_len, /* mp_length */
1026 (binaryfunc)mappingproxy_getitem, /* mp_subscript */
1027 0, /* mp_ass_subscript */
1028};
1029
1030static PyObject *
1031mappingproxy_or(PyObject *left, PyObject *right)
1032{
1033 if (PyObject_TypeCheck(left, &PyDictProxy_Type)) {
1034 left = ((mappingproxyobject*)left)->mapping;
1035 }
1036 if (PyObject_TypeCheck(right, &PyDictProxy_Type)) {
1037 right = ((mappingproxyobject*)right)->mapping;
1038 }
1039 return PyNumber_Or(left, right);
1040}
1041
1042static PyObject *
1043mappingproxy_ior(PyObject *self, PyObject *Py_UNUSED(other))
1044{
1045 return PyErr_Format(PyExc_TypeError,
1046 "'|=' is not supported by %s; use '|' instead", Py_TYPE(self)->tp_name);
1047}
1048
1049static PyNumberMethods mappingproxy_as_number = {
1050 .nb_or = mappingproxy_or,
1051 .nb_inplace_or = mappingproxy_ior,
1052};
1053
1054static int
1055mappingproxy_contains(mappingproxyobject *pp, PyObject *key)
1056{
1057 if (PyDict_CheckExact(pp->mapping))
1058 return PyDict_Contains(pp->mapping, key);
1059 else
1060 return PySequence_Contains(pp->mapping, key);
1061}
1062
1063static PySequenceMethods mappingproxy_as_sequence = {
1064 0, /* sq_length */
1065 0, /* sq_concat */
1066 0, /* sq_repeat */
1067 0, /* sq_item */
1068 0, /* sq_slice */
1069 0, /* sq_ass_item */
1070 0, /* sq_ass_slice */
1071 (objobjproc)mappingproxy_contains, /* sq_contains */
1072 0, /* sq_inplace_concat */
1073 0, /* sq_inplace_repeat */
1074};
1075
1076static PyObject *
1077mappingproxy_get(mappingproxyobject *pp, PyObject *const *args, Py_ssize_t nargs)
1078{
1079 /* newargs: mapping, key, default=None */
1080 PyObject *newargs[3];
1081 newargs[0] = pp->mapping;
1082 newargs[2] = Py_None;
1083
1084 if (!_PyArg_UnpackStack(args, nargs, "get", 1, 2,
1085 &newargs[1], &newargs[2]))
1086 {
1087 return NULL;
1088 }
1089 _Py_IDENTIFIER(get);
1090 return _PyObject_VectorcallMethodId(&PyId_get, newargs,
1091 3 | PY_VECTORCALL_ARGUMENTS_OFFSET,
1092 NULL);
1093}
1094
1095static PyObject *
1096mappingproxy_keys(mappingproxyobject *pp, PyObject *Py_UNUSED(ignored))
1097{
1098 _Py_IDENTIFIER(keys);
1099 return _PyObject_CallMethodIdNoArgs(pp->mapping, &PyId_keys);
1100}
1101
1102static PyObject *
1103mappingproxy_values(mappingproxyobject *pp, PyObject *Py_UNUSED(ignored))
1104{
1105 _Py_IDENTIFIER(values);
1106 return _PyObject_CallMethodIdNoArgs(pp->mapping, &PyId_values);
1107}
1108
1109static PyObject *
1110mappingproxy_items(mappingproxyobject *pp, PyObject *Py_UNUSED(ignored))
1111{
1112 _Py_IDENTIFIER(items);
1113 return _PyObject_CallMethodIdNoArgs(pp->mapping, &PyId_items);
1114}
1115
1116static PyObject *
1117mappingproxy_copy(mappingproxyobject *pp, PyObject *Py_UNUSED(ignored))
1118{
1119 _Py_IDENTIFIER(copy);
1120 return _PyObject_CallMethodIdNoArgs(pp->mapping, &PyId_copy);
1121}
1122
1123static PyObject *
1124mappingproxy_reversed(mappingproxyobject *pp, PyObject *Py_UNUSED(ignored))
1125{
1126 _Py_IDENTIFIER(__reversed__);
1127 return _PyObject_CallMethodIdNoArgs(pp->mapping, &PyId___reversed__);
1128}
1129
1130/* WARNING: mappingproxy methods must not give access
1131 to the underlying mapping */
1132
1133static PyMethodDef mappingproxy_methods[] = {
1134 {"get", (PyCFunction)(void(*)(void))mappingproxy_get, METH_FASTCALL,
1135 PyDoc_STR("D.get(k[,d]) -> D[k] if k in D, else d."
1136 " d defaults to None.")},
1137 {"keys", (PyCFunction)mappingproxy_keys, METH_NOARGS,
1138 PyDoc_STR("D.keys() -> a set-like object providing a view on D's keys")},
1139 {"values", (PyCFunction)mappingproxy_values, METH_NOARGS,
1140 PyDoc_STR("D.values() -> an object providing a view on D's values")},
1141 {"items", (PyCFunction)mappingproxy_items, METH_NOARGS,
1142 PyDoc_STR("D.items() -> a set-like object providing a view on D's items")},
1143 {"copy", (PyCFunction)mappingproxy_copy, METH_NOARGS,
1144 PyDoc_STR("D.copy() -> a shallow copy of D")},
1145 {"__class_getitem__", (PyCFunction)Py_GenericAlias, METH_O|METH_CLASS,
1146 PyDoc_STR("See PEP 585")},
1147 {"__reversed__", (PyCFunction)mappingproxy_reversed, METH_NOARGS,
1148 PyDoc_STR("D.__reversed__() -> reverse iterator")},
1149 {0}
1150};
1151
1152static void
1153mappingproxy_dealloc(mappingproxyobject *pp)
1154{
1155 _PyObject_GC_UNTRACK(pp);
1156 Py_DECREF(pp->mapping);
1157 PyObject_GC_Del(pp);
1158}
1159
1160static PyObject *
1161mappingproxy_getiter(mappingproxyobject *pp)
1162{
1163 return PyObject_GetIter(pp->mapping);
1164}
1165
1166static PyObject *
1167mappingproxy_str(mappingproxyobject *pp)
1168{
1169 return PyObject_Str(pp->mapping);
1170}
1171
1172static PyObject *
1173mappingproxy_repr(mappingproxyobject *pp)
1174{
1175 return PyUnicode_FromFormat("mappingproxy(%R)", pp->mapping);
1176}
1177
1178static int
1179mappingproxy_traverse(PyObject *self, visitproc visit, void *arg)
1180{
1181 mappingproxyobject *pp = (mappingproxyobject *)self;
1182 Py_VISIT(pp->mapping);
1183 return 0;
1184}
1185
1186static PyObject *
1187mappingproxy_richcompare(mappingproxyobject *v, PyObject *w, int op)
1188{
1189 return PyObject_RichCompare(v->mapping, w, op);
1190}
1191
1192static int
1193mappingproxy_check_mapping(PyObject *mapping)
1194{
1195 if (!PyMapping_Check(mapping)
1196 || PyList_Check(mapping)
1197 || PyTuple_Check(mapping)) {
1198 PyErr_Format(PyExc_TypeError,
1199 "mappingproxy() argument must be a mapping, not %s",
1200 Py_TYPE(mapping)->tp_name);
1201 return -1;
1202 }
1203 return 0;
1204}
1205
1206/*[clinic input]
1207@classmethod
1208mappingproxy.__new__ as mappingproxy_new
1209
1210 mapping: object
1211
1212[clinic start generated code]*/
1213
1214static PyObject *
1215mappingproxy_new_impl(PyTypeObject *type, PyObject *mapping)
1216/*[clinic end generated code: output=65f27f02d5b68fa7 input=d2d620d4f598d4f8]*/
1217{
1218 mappingproxyobject *mappingproxy;
1219
1220 if (mappingproxy_check_mapping(mapping) == -1)
1221 return NULL;
1222
1223 mappingproxy = PyObject_GC_New(mappingproxyobject, &PyDictProxy_Type);
1224 if (mappingproxy == NULL)
1225 return NULL;
1226 Py_INCREF(mapping);
1227 mappingproxy->mapping = mapping;
1228 _PyObject_GC_TRACK(mappingproxy);
1229 return (PyObject *)mappingproxy;
1230}
1231
1232PyObject *
1233PyDictProxy_New(PyObject *mapping)
1234{
1235 mappingproxyobject *pp;
1236
1237 if (mappingproxy_check_mapping(mapping) == -1)
1238 return NULL;
1239
1240 pp = PyObject_GC_New(mappingproxyobject, &PyDictProxy_Type);
1241 if (pp != NULL) {
1242 Py_INCREF(mapping);
1243 pp->mapping = mapping;
1244 _PyObject_GC_TRACK(pp);
1245 }
1246 return (PyObject *)pp;
1247}
1248
1249
1250/* --- Wrapper object for "slot" methods --- */
1251
1252/* This has no reason to be in this file except that adding new files is a
1253 bit of a pain */
1254
1255typedef struct {
1256 PyObject_HEAD
1257 PyWrapperDescrObject *descr;
1258 PyObject *self;
1259} wrapperobject;
1260
1261#define Wrapper_Check(v) Py_IS_TYPE(v, &_PyMethodWrapper_Type)
1262
1263static void
1264wrapper_dealloc(wrapperobject *wp)
1265{
1266 PyObject_GC_UnTrack(wp);
1267 Py_TRASHCAN_BEGIN(wp, wrapper_dealloc)
1268 Py_XDECREF(wp->descr);
1269 Py_XDECREF(wp->self);
1270 PyObject_GC_Del(wp);
1271 Py_TRASHCAN_END
1272}
1273
1274static PyObject *
1275wrapper_richcompare(PyObject *a, PyObject *b, int op)
1276{
1277 wrapperobject *wa, *wb;
1278 int eq;
1279
1280 assert(a != NULL && b != NULL);
1281
1282 /* both arguments should be wrapperobjects */
1283 if ((op != Py_EQ && op != Py_NE)
1284 || !Wrapper_Check(a) || !Wrapper_Check(b))
1285 {
1286 Py_RETURN_NOTIMPLEMENTED;
1287 }
1288
1289 wa = (wrapperobject *)a;
1290 wb = (wrapperobject *)b;
1291 eq = (wa->descr == wb->descr && wa->self == wb->self);
1292 if (eq == (op == Py_EQ)) {
1293 Py_RETURN_TRUE;
1294 }
1295 else {
1296 Py_RETURN_FALSE;
1297 }
1298}
1299
1300static Py_hash_t
1301wrapper_hash(wrapperobject *wp)
1302{
1303 Py_hash_t x, y;
1304 x = _Py_HashPointer(wp->self);
1305 y = _Py_HashPointer(wp->descr);
1306 x = x ^ y;
1307 if (x == -1)
1308 x = -2;
1309 return x;
1310}
1311
1312static PyObject *
1313wrapper_repr(wrapperobject *wp)
1314{
1315 return PyUnicode_FromFormat("<method-wrapper '%s' of %s object at %p>",
1316 wp->descr->d_base->name,
1317 Py_TYPE(wp->self)->tp_name,
1318 wp->self);
1319}
1320
1321static PyObject *
1322wrapper_reduce(wrapperobject *wp, PyObject *Py_UNUSED(ignored))
1323{
1324 return Py_BuildValue("N(OO)", _PyEval_GetBuiltinId(&PyId_getattr),
1325 wp->self, PyDescr_NAME(wp->descr));
1326}
1327
1328static PyMethodDef wrapper_methods[] = {
1329 {"__reduce__", (PyCFunction)wrapper_reduce, METH_NOARGS, NULL},
1330 {NULL, NULL}
1331};
1332
1333static PyMemberDef wrapper_members[] = {
1334 {"__self__", T_OBJECT, offsetof(wrapperobject, self), READONLY},
1335 {0}
1336};
1337
1338static PyObject *
1339wrapper_objclass(wrapperobject *wp, void *Py_UNUSED(ignored))
1340{
1341 PyObject *c = (PyObject *)PyDescr_TYPE(wp->descr);
1342
1343 Py_INCREF(c);
1344 return c;
1345}
1346
1347static PyObject *
1348wrapper_name(wrapperobject *wp, void *Py_UNUSED(ignored))
1349{
1350 const char *s = wp->descr->d_base->name;
1351
1352 return PyUnicode_FromString(s);
1353}
1354
1355static PyObject *
1356wrapper_doc(wrapperobject *wp, void *Py_UNUSED(ignored))
1357{
1358 return _PyType_GetDocFromInternalDoc(wp->descr->d_base->name, wp->descr->d_base->doc);
1359}
1360
1361static PyObject *
1362wrapper_text_signature(wrapperobject *wp, void *Py_UNUSED(ignored))
1363{
1364 return _PyType_GetTextSignatureFromInternalDoc(wp->descr->d_base->name, wp->descr->d_base->doc);
1365}
1366
1367static PyObject *
1368wrapper_qualname(wrapperobject *wp, void *Py_UNUSED(ignored))
1369{
1370 return descr_get_qualname((PyDescrObject *)wp->descr, NULL);
1371}
1372
1373static PyGetSetDef wrapper_getsets[] = {
1374 {"__objclass__", (getter)wrapper_objclass},
1375 {"__name__", (getter)wrapper_name},
1376 {"__qualname__", (getter)wrapper_qualname},
1377 {"__doc__", (getter)wrapper_doc},
1378 {"__text_signature__", (getter)wrapper_text_signature},
1379 {0}
1380};
1381
1382static PyObject *
1383wrapper_call(wrapperobject *wp, PyObject *args, PyObject *kwds)
1384{
1385 return wrapperdescr_raw_call(wp->descr, wp->self, args, kwds);
1386}
1387
1388static int
1389wrapper_traverse(PyObject *self, visitproc visit, void *arg)
1390{
1391 wrapperobject *wp = (wrapperobject *)self;
1392 Py_VISIT(wp->descr);
1393 Py_VISIT(wp->self);
1394 return 0;
1395}
1396
1397PyTypeObject _PyMethodWrapper_Type = {
1398 PyVarObject_HEAD_INIT(&PyType_Type, 0)
1399 "method-wrapper", /* tp_name */
1400 sizeof(wrapperobject), /* tp_basicsize */
1401 0, /* tp_itemsize */
1402 /* methods */
1403 (destructor)wrapper_dealloc, /* tp_dealloc */
1404 0, /* tp_vectorcall_offset */
1405 0, /* tp_getattr */
1406 0, /* tp_setattr */
1407 0, /* tp_as_async */
1408 (reprfunc)wrapper_repr, /* tp_repr */
1409 0, /* tp_as_number */
1410 0, /* tp_as_sequence */
1411 0, /* tp_as_mapping */
1412 (hashfunc)wrapper_hash, /* tp_hash */
1413 (ternaryfunc)wrapper_call, /* tp_call */
1414 0, /* tp_str */
1415 PyObject_GenericGetAttr, /* tp_getattro */
1416 0, /* tp_setattro */
1417 0, /* tp_as_buffer */
1418 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
1419 0, /* tp_doc */
1420 wrapper_traverse, /* tp_traverse */
1421 0, /* tp_clear */
1422 wrapper_richcompare, /* tp_richcompare */
1423 0, /* tp_weaklistoffset */
1424 0, /* tp_iter */
1425 0, /* tp_iternext */
1426 wrapper_methods, /* tp_methods */
1427 wrapper_members, /* tp_members */
1428 wrapper_getsets, /* tp_getset */
1429 0, /* tp_base */
1430 0, /* tp_dict */
1431 0, /* tp_descr_get */
1432 0, /* tp_descr_set */
1433};
1434
1435PyObject *
1436PyWrapper_New(PyObject *d, PyObject *self)
1437{
1438 wrapperobject *wp;
1439 PyWrapperDescrObject *descr;
1440
1441 assert(PyObject_TypeCheck(d, &PyWrapperDescr_Type));
1442 descr = (PyWrapperDescrObject *)d;
1443 assert(_PyObject_RealIsSubclass((PyObject *)Py_TYPE(self),
1444 (PyObject *)PyDescr_TYPE(descr)));
1445
1446 wp = PyObject_GC_New(wrapperobject, &_PyMethodWrapper_Type);
1447 if (wp != NULL) {
1448 Py_INCREF(descr);
1449 wp->descr = descr;
1450 Py_INCREF(self);
1451 wp->self = self;
1452 _PyObject_GC_TRACK(wp);
1453 }
1454 return (PyObject *)wp;
1455}
1456
1457
1458/* A built-in 'property' type */
1459
1460/*
1461class property(object):
1462
1463 def __init__(self, fget=None, fset=None, fdel=None, doc=None):
1464 if doc is None and fget is not None and hasattr(fget, "__doc__"):
1465 doc = fget.__doc__
1466 self.__get = fget
1467 self.__set = fset
1468 self.__del = fdel
1469 self.__doc__ = doc
1470
1471 def __get__(self, inst, type=None):
1472 if inst is None:
1473 return self
1474 if self.__get is None:
1475 raise AttributeError, "unreadable attribute"
1476 return self.__get(inst)
1477
1478 def __set__(self, inst, value):
1479 if self.__set is None:
1480 raise AttributeError, "can't set attribute"
1481 return self.__set(inst, value)
1482
1483 def __delete__(self, inst):
1484 if self.__del is None:
1485 raise AttributeError, "can't delete attribute"
1486 return self.__del(inst)
1487
1488*/
1489
1490typedef struct {
1491 PyObject_HEAD
1492 PyObject *prop_get;
1493 PyObject *prop_set;
1494 PyObject *prop_del;
1495 PyObject *prop_doc;
1496 PyObject *prop_name;
1497 int getter_doc;
1498} propertyobject;
1499
1500static PyObject * property_copy(PyObject *, PyObject *, PyObject *,
1501 PyObject *);
1502
1503static PyMemberDef property_members[] = {
1504 {"fget", T_OBJECT, offsetof(propertyobject, prop_get), READONLY},
1505 {"fset", T_OBJECT, offsetof(propertyobject, prop_set), READONLY},
1506 {"fdel", T_OBJECT, offsetof(propertyobject, prop_del), READONLY},
1507 {"__doc__", T_OBJECT, offsetof(propertyobject, prop_doc), 0},
1508 {0}
1509};
1510
1511
1512PyDoc_STRVAR(getter_doc,
1513 "Descriptor to obtain a copy of the property with a different getter.");
1514
1515static PyObject *
1516property_getter(PyObject *self, PyObject *getter)
1517{
1518 return property_copy(self, getter, NULL, NULL);
1519}
1520
1521
1522PyDoc_STRVAR(setter_doc,
1523 "Descriptor to obtain a copy of the property with a different setter.");
1524
1525static PyObject *
1526property_setter(PyObject *self, PyObject *setter)
1527{
1528 return property_copy(self, NULL, setter, NULL);
1529}
1530
1531
1532PyDoc_STRVAR(deleter_doc,
1533 "Descriptor to obtain a copy of the property with a different deleter.");
1534
1535static PyObject *
1536property_deleter(PyObject *self, PyObject *deleter)
1537{
1538 return property_copy(self, NULL, NULL, deleter);
1539}
1540
1541
1542PyDoc_STRVAR(set_name_doc,
1543 "Method to set name of a property.");
1544
1545static PyObject *
1546property_set_name(PyObject *self, PyObject *args) {
1547 if (PyTuple_GET_SIZE(args) != 2) {
1548 PyErr_Format(
1549 PyExc_TypeError,
1550 "__set_name__() takes 2 positional arguments but %d were given",
1551 PyTuple_GET_SIZE(args));
1552 return NULL;
1553 }
1554
1555 propertyobject *prop = (propertyobject *)self;
1556 PyObject *name = PyTuple_GET_ITEM(args, 1);
1557
1558 Py_XINCREF(name);
1559 Py_XSETREF(prop->prop_name, name);
1560
1561 Py_RETURN_NONE;
1562}
1563
1564static PyMethodDef property_methods[] = {
1565 {"getter", property_getter, METH_O, getter_doc},
1566 {"setter", property_setter, METH_O, setter_doc},
1567 {"deleter", property_deleter, METH_O, deleter_doc},
1568 {"__set_name__", property_set_name, METH_VARARGS, set_name_doc},
1569 {0}
1570};
1571
1572
1573static void
1574property_dealloc(PyObject *self)
1575{
1576 propertyobject *gs = (propertyobject *)self;
1577
1578 _PyObject_GC_UNTRACK(self);
1579 Py_XDECREF(gs->prop_get);
1580 Py_XDECREF(gs->prop_set);
1581 Py_XDECREF(gs->prop_del);
1582 Py_XDECREF(gs->prop_doc);
1583 Py_XDECREF(gs->prop_name);
1584 Py_TYPE(self)->tp_free(self);
1585}
1586
1587static PyObject *
1588property_descr_get(PyObject *self, PyObject *obj, PyObject *type)
1589{
1590 if (obj == NULL || obj == Py_None) {
1591 Py_INCREF(self);
1592 return self;
1593 }
1594
1595 propertyobject *gs = (propertyobject *)self;
1596 if (gs->prop_get == NULL) {
1597 if (gs->prop_name != NULL) {
1598 PyErr_Format(PyExc_AttributeError, "unreadable attribute %R", gs->prop_name);
1599 } else {
1600 PyErr_SetString(PyExc_AttributeError, "unreadable attribute");
1601 }
1602
1603 return NULL;
1604 }
1605
1606 return PyObject_CallOneArg(gs->prop_get, obj);
1607}
1608
1609static int
1610property_descr_set(PyObject *self, PyObject *obj, PyObject *value)
1611{
1612 propertyobject *gs = (propertyobject *)self;
1613 PyObject *func, *res;
1614
1615 if (value == NULL)
1616 func = gs->prop_del;
1617 else
1618 func = gs->prop_set;
1619 if (func == NULL) {
1620 if (gs->prop_name != NULL) {
1621 PyErr_Format(PyExc_AttributeError,
1622 value == NULL ?
1623 "can't delete attribute %R" :
1624 "can't set attribute %R",
1625 gs->prop_name);
1626 } else {
1627 PyErr_SetString(PyExc_AttributeError,
1628 value == NULL ?
1629 "can't delete attribute" :
1630 "can't set attribute");
1631 }
1632 return -1;
1633 }
1634 if (value == NULL)
1635 res = PyObject_CallOneArg(func, obj);
1636 else
1637 res = PyObject_CallFunctionObjArgs(func, obj, value, NULL);
1638 if (res == NULL)
1639 return -1;
1640 Py_DECREF(res);
1641 return 0;
1642}
1643
1644static PyObject *
1645property_copy(PyObject *old, PyObject *get, PyObject *set, PyObject *del)
1646{
1647 propertyobject *pold = (propertyobject *)old;
1648 PyObject *new, *type, *doc;
1649
1650 type = PyObject_Type(old);
1651 if (type == NULL)
1652 return NULL;
1653
1654 if (get == NULL || get == Py_None) {
1655 Py_XDECREF(get);
1656 get = pold->prop_get ? pold->prop_get : Py_None;
1657 }
1658 if (set == NULL || set == Py_None) {
1659 Py_XDECREF(set);
1660 set = pold->prop_set ? pold->prop_set : Py_None;
1661 }
1662 if (del == NULL || del == Py_None) {
1663 Py_XDECREF(del);
1664 del = pold->prop_del ? pold->prop_del : Py_None;
1665 }
1666 if (pold->getter_doc && get != Py_None) {
1667 /* make _init use __doc__ from getter */
1668 doc = Py_None;
1669 }
1670 else {
1671 doc = pold->prop_doc ? pold->prop_doc : Py_None;
1672 }
1673
1674 new = PyObject_CallFunctionObjArgs(type, get, set, del, doc, NULL);
1675 Py_DECREF(type);
1676 if (new == NULL)
1677 return NULL;
1678
1679 Py_XINCREF(pold->prop_name);
1680 Py_XSETREF(((propertyobject *) new)->prop_name, pold->prop_name);
1681 return new;
1682}
1683
1684/*[clinic input]
1685property.__init__ as property_init
1686
1687 fget: object(c_default="NULL") = None
1688 function to be used for getting an attribute value
1689 fset: object(c_default="NULL") = None
1690 function to be used for setting an attribute value
1691 fdel: object(c_default="NULL") = None
1692 function to be used for del'ing an attribute
1693 doc: object(c_default="NULL") = None
1694 docstring
1695
1696Property attribute.
1697
1698Typical use is to define a managed attribute x:
1699
1700class C(object):
1701 def getx(self): return self._x
1702 def setx(self, value): self._x = value
1703 def delx(self): del self._x
1704 x = property(getx, setx, delx, "I'm the 'x' property.")
1705
1706Decorators make defining new properties or modifying existing ones easy:
1707
1708class C(object):
1709 @property
1710 def x(self):
1711 "I am the 'x' property."
1712 return self._x
1713 @x.setter
1714 def x(self, value):
1715 self._x = value
1716 @x.deleter
1717 def x(self):
1718 del self._x
1719[clinic start generated code]*/
1720
1721static int
1722property_init_impl(propertyobject *self, PyObject *fget, PyObject *fset,
1723 PyObject *fdel, PyObject *doc)
1724/*[clinic end generated code: output=01a960742b692b57 input=dfb5dbbffc6932d5]*/
1725{
1726 if (fget == Py_None)
1727 fget = NULL;
1728 if (fset == Py_None)
1729 fset = NULL;
1730 if (fdel == Py_None)
1731 fdel = NULL;
1732
1733 Py_XINCREF(fget);
1734 Py_XINCREF(fset);
1735 Py_XINCREF(fdel);
1736 Py_XINCREF(doc);
1737
1738 Py_XSETREF(self->prop_get, fget);
1739 Py_XSETREF(self->prop_set, fset);
1740 Py_XSETREF(self->prop_del, fdel);
1741 Py_XSETREF(self->prop_doc, doc);
1742 Py_XSETREF(self->prop_name, NULL);
1743
1744 self->getter_doc = 0;
1745
1746 /* if no docstring given and the getter has one, use that one */
1747 if ((doc == NULL || doc == Py_None) && fget != NULL) {
1748 _Py_IDENTIFIER(__doc__);
1749 PyObject *get_doc;
1750 int rc = _PyObject_LookupAttrId(fget, &PyId___doc__, &get_doc);
1751 if (rc <= 0) {
1752 return rc;
1753 }
1754 if (Py_IS_TYPE(self, &PyProperty_Type)) {
1755 Py_XSETREF(self->prop_doc, get_doc);
1756 }
1757 else {
1758 /* If this is a property subclass, put __doc__
1759 in dict of the subclass instance instead,
1760 otherwise it gets shadowed by __doc__ in the
1761 class's dict. */
1762 int err = _PyObject_SetAttrId((PyObject *)self, &PyId___doc__, get_doc);
1763 Py_DECREF(get_doc);
1764 if (err < 0)
1765 return -1;
1766 }
1767 self->getter_doc = 1;
1768 }
1769
1770 return 0;
1771}
1772
1773static PyObject *
1774property_get___isabstractmethod__(propertyobject *prop, void *closure)
1775{
1776 int res = _PyObject_IsAbstract(prop->prop_get);
1777 if (res == -1) {
1778 return NULL;
1779 }
1780 else if (res) {
1781 Py_RETURN_TRUE;
1782 }
1783
1784 res = _PyObject_IsAbstract(prop->prop_set);
1785 if (res == -1) {
1786 return NULL;
1787 }
1788 else if (res) {
1789 Py_RETURN_TRUE;
1790 }
1791
1792 res = _PyObject_IsAbstract(prop->prop_del);
1793 if (res == -1) {
1794 return NULL;
1795 }
1796 else if (res) {
1797 Py_RETURN_TRUE;
1798 }
1799 Py_RETURN_FALSE;
1800}
1801
1802static PyGetSetDef property_getsetlist[] = {
1803 {"__isabstractmethod__",
1804 (getter)property_get___isabstractmethod__, NULL,
1805 NULL,
1806 NULL},
1807 {NULL} /* Sentinel */
1808};
1809
1810static int
1811property_traverse(PyObject *self, visitproc visit, void *arg)
1812{
1813 propertyobject *pp = (propertyobject *)self;
1814 Py_VISIT(pp->prop_get);
1815 Py_VISIT(pp->prop_set);
1816 Py_VISIT(pp->prop_del);
1817 Py_VISIT(pp->prop_doc);
1818 Py_VISIT(pp->prop_name);
1819 return 0;
1820}
1821
1822static int
1823property_clear(PyObject *self)
1824{
1825 propertyobject *pp = (propertyobject *)self;
1826 Py_CLEAR(pp->prop_doc);
1827 return 0;
1828}
1829
1830#include "clinic/descrobject.c.h"
1831
1832PyTypeObject PyDictProxy_Type = {
1833 PyVarObject_HEAD_INIT(&PyType_Type, 0)
1834 "mappingproxy", /* tp_name */
1835 sizeof(mappingproxyobject), /* tp_basicsize */
1836 0, /* tp_itemsize */
1837 /* methods */
1838 (destructor)mappingproxy_dealloc, /* tp_dealloc */
1839 0, /* tp_vectorcall_offset */
1840 0, /* tp_getattr */
1841 0, /* tp_setattr */
1842 0, /* tp_as_async */
1843 (reprfunc)mappingproxy_repr, /* tp_repr */
1844 &mappingproxy_as_number, /* tp_as_number */
1845 &mappingproxy_as_sequence, /* tp_as_sequence */
1846 &mappingproxy_as_mapping, /* tp_as_mapping */
1847 0, /* tp_hash */
1848 0, /* tp_call */
1849 (reprfunc)mappingproxy_str, /* tp_str */
1850 PyObject_GenericGetAttr, /* tp_getattro */
1851 0, /* tp_setattro */
1852 0, /* tp_as_buffer */
1853 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
1854 Py_TPFLAGS_MAPPING, /* tp_flags */
1855 0, /* tp_doc */
1856 mappingproxy_traverse, /* tp_traverse */
1857 0, /* tp_clear */
1858 (richcmpfunc)mappingproxy_richcompare, /* tp_richcompare */
1859 0, /* tp_weaklistoffset */
1860 (getiterfunc)mappingproxy_getiter, /* tp_iter */
1861 0, /* tp_iternext */
1862 mappingproxy_methods, /* tp_methods */
1863 0, /* tp_members */
1864 0, /* tp_getset */
1865 0, /* tp_base */
1866 0, /* tp_dict */
1867 0, /* tp_descr_get */
1868 0, /* tp_descr_set */
1869 0, /* tp_dictoffset */
1870 0, /* tp_init */
1871 0, /* tp_alloc */
1872 mappingproxy_new, /* tp_new */
1873};
1874
1875PyTypeObject PyProperty_Type = {
1876 PyVarObject_HEAD_INIT(&PyType_Type, 0)
1877 "property", /* tp_name */
1878 sizeof(propertyobject), /* tp_basicsize */
1879 0, /* tp_itemsize */
1880 /* methods */
1881 property_dealloc, /* tp_dealloc */
1882 0, /* tp_vectorcall_offset */
1883 0, /* tp_getattr */
1884 0, /* tp_setattr */
1885 0, /* tp_as_async */
1886 0, /* tp_repr */
1887 0, /* tp_as_number */
1888 0, /* tp_as_sequence */
1889 0, /* tp_as_mapping */
1890 0, /* tp_hash */
1891 0, /* tp_call */
1892 0, /* tp_str */
1893 PyObject_GenericGetAttr, /* tp_getattro */
1894 0, /* tp_setattro */
1895 0, /* tp_as_buffer */
1896 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
1897 Py_TPFLAGS_BASETYPE, /* tp_flags */
1898 property_init__doc__, /* tp_doc */
1899 property_traverse, /* tp_traverse */
1900 (inquiry)property_clear, /* tp_clear */
1901 0, /* tp_richcompare */
1902 0, /* tp_weaklistoffset */
1903 0, /* tp_iter */
1904 0, /* tp_iternext */
1905 property_methods, /* tp_methods */
1906 property_members, /* tp_members */
1907 property_getsetlist, /* tp_getset */
1908 0, /* tp_base */
1909 0, /* tp_dict */
1910 property_descr_get, /* tp_descr_get */
1911 property_descr_set, /* tp_descr_set */
1912 0, /* tp_dictoffset */
1913 property_init, /* tp_init */
1914 PyType_GenericAlloc, /* tp_alloc */
1915 PyType_GenericNew, /* tp_new */
1916 PyObject_GC_Del, /* tp_free */
1917};
1918