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] |
13 | class mappingproxy "mappingproxyobject *" "&PyDictProxy_Type" |
14 | class property "propertyobject *" "&PyProperty_Type" |
15 | [clinic start generated code]*/ |
16 | /*[clinic end generated code: output=da39a3ee5e6b4b0d input=556352653fd4c02e]*/ |
17 | |
18 | static void |
19 | descr_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 | |
28 | static PyObject * |
29 | descr_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 | |
36 | static PyObject * |
37 | descr_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 | |
46 | static PyObject * |
47 | method_repr(PyMethodDescrObject *descr) |
48 | { |
49 | return descr_repr((PyDescrObject *)descr, |
50 | "<method '%V' of '%s' objects>" ); |
51 | } |
52 | |
53 | static PyObject * |
54 | member_repr(PyMemberDescrObject *descr) |
55 | { |
56 | return descr_repr((PyDescrObject *)descr, |
57 | "<member '%V' of '%s' objects>" ); |
58 | } |
59 | |
60 | static PyObject * |
61 | getset_repr(PyGetSetDescrObject *descr) |
62 | { |
63 | return descr_repr((PyDescrObject *)descr, |
64 | "<attribute '%V' of '%s' objects>" ); |
65 | } |
66 | |
67 | static PyObject * |
68 | wrapperdescr_repr(PyWrapperDescrObject *descr) |
69 | { |
70 | return descr_repr((PyDescrObject *)descr, |
71 | "<slot wrapper '%V' of '%s' objects>" ); |
72 | } |
73 | |
74 | static int |
75 | descr_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 | |
89 | static PyObject * |
90 | classmethod_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 | |
131 | static PyObject * |
132 | method_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 | |
155 | static PyObject * |
156 | member_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 | |
175 | static PyObject * |
176 | getset_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 | |
193 | static PyObject * |
194 | wrapperdescr_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 | |
205 | static int |
206 | descr_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 | |
221 | static int |
222 | member_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 | |
230 | static int |
231 | getset_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 | */ |
252 | static inline int |
253 | method_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 | |
281 | typedef void (*funcptr)(void); |
282 | |
283 | static inline funcptr |
284 | method_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 */ |
293 | static PyObject * |
294 | method_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 | |
317 | static PyObject * |
318 | method_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); |
346 | exit: |
347 | Py_DECREF(argstuple); |
348 | Py_XDECREF(kwdict); |
349 | return result; |
350 | } |
351 | |
352 | static PyObject * |
353 | method_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 | |
372 | static PyObject * |
373 | method_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 | |
391 | static PyObject * |
392 | method_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 | |
410 | static PyObject * |
411 | method_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 | |
437 | static PyObject * |
438 | method_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 | */ |
474 | static PyObject * |
475 | classmethoddescr_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 | |
498 | Py_LOCAL_INLINE(PyObject *) |
499 | wrapperdescr_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 | |
518 | static PyObject * |
519 | wrapperdescr_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 | |
558 | static PyObject * |
559 | method_get_doc(PyMethodDescrObject *descr, void *closure) |
560 | { |
561 | return _PyType_GetDocFromInternalDoc(descr->d_method->ml_name, descr->d_method->ml_doc); |
562 | } |
563 | |
564 | static PyObject * |
565 | method_get_text_signature(PyMethodDescrObject *descr, void *closure) |
566 | { |
567 | return _PyType_GetTextSignatureFromInternalDoc(descr->d_method->ml_name, descr->d_method->ml_doc); |
568 | } |
569 | |
570 | static PyObject * |
571 | calculate_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 | |
599 | static PyObject * |
600 | descr_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 | |
608 | static PyObject * |
609 | descr_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 | |
615 | static PyMethodDef descr_methods[] = { |
616 | {"__reduce__" , (PyCFunction)descr_reduce, METH_NOARGS, NULL}, |
617 | {NULL, NULL} |
618 | }; |
619 | |
620 | static 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 | |
626 | static 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 | |
633 | static PyObject * |
634 | member_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 | |
642 | static PyGetSetDef member_getset[] = { |
643 | {"__doc__" , (getter)member_get_doc}, |
644 | {"__qualname__" , (getter)descr_get_qualname}, |
645 | {0} |
646 | }; |
647 | |
648 | static PyObject * |
649 | getset_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 | |
657 | static PyGetSetDef getset_getset[] = { |
658 | {"__doc__" , (getter)getset_get_doc}, |
659 | {"__qualname__" , (getter)descr_get_qualname}, |
660 | {0} |
661 | }; |
662 | |
663 | static PyObject * |
664 | wrapperdescr_get_doc(PyWrapperDescrObject *descr, void *closure) |
665 | { |
666 | return _PyType_GetDocFromInternalDoc(descr->d_base->name, descr->d_base->doc); |
667 | } |
668 | |
669 | static PyObject * |
670 | wrapperdescr_get_text_signature(PyWrapperDescrObject *descr, void *closure) |
671 | { |
672 | return _PyType_GetTextSignatureFromInternalDoc(descr->d_base->name, descr->d_base->doc); |
673 | } |
674 | |
675 | static 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 | |
682 | static int |
683 | descr_traverse(PyObject *self, visitproc visit, void *arg) |
684 | { |
685 | PyDescrObject *descr = (PyDescrObject *)self; |
686 | Py_VISIT(descr->d_type); |
687 | return 0; |
688 | } |
689 | |
690 | PyTypeObject 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! */ |
730 | PyTypeObject 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 | |
767 | PyTypeObject 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 | |
804 | PyTypeObject 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 | |
841 | PyTypeObject 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 | |
879 | static PyDescrObject * |
880 | descr_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 | |
900 | PyObject * |
901 | PyDescr_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 | |
946 | PyObject * |
947 | PyDescr_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 | |
958 | PyObject * |
959 | PyDescr_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 | |
970 | PyObject * |
971 | PyDescr_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 | |
982 | PyObject * |
983 | PyDescr_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 | |
996 | int |
997 | PyDescr_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 | |
1007 | typedef struct { |
1008 | PyObject_HEAD |
1009 | PyObject *mapping; |
1010 | } mappingproxyobject; |
1011 | |
1012 | static Py_ssize_t |
1013 | mappingproxy_len(mappingproxyobject *pp) |
1014 | { |
1015 | return PyObject_Size(pp->mapping); |
1016 | } |
1017 | |
1018 | static PyObject * |
1019 | mappingproxy_getitem(mappingproxyobject *pp, PyObject *key) |
1020 | { |
1021 | return PyObject_GetItem(pp->mapping, key); |
1022 | } |
1023 | |
1024 | static PyMappingMethods mappingproxy_as_mapping = { |
1025 | (lenfunc)mappingproxy_len, /* mp_length */ |
1026 | (binaryfunc)mappingproxy_getitem, /* mp_subscript */ |
1027 | 0, /* mp_ass_subscript */ |
1028 | }; |
1029 | |
1030 | static PyObject * |
1031 | mappingproxy_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 | |
1042 | static PyObject * |
1043 | mappingproxy_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 | |
1049 | static PyNumberMethods mappingproxy_as_number = { |
1050 | .nb_or = mappingproxy_or, |
1051 | .nb_inplace_or = mappingproxy_ior, |
1052 | }; |
1053 | |
1054 | static int |
1055 | mappingproxy_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 | |
1063 | static 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 | |
1076 | static PyObject * |
1077 | mappingproxy_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 | |
1095 | static PyObject * |
1096 | mappingproxy_keys(mappingproxyobject *pp, PyObject *Py_UNUSED(ignored)) |
1097 | { |
1098 | _Py_IDENTIFIER(keys); |
1099 | return _PyObject_CallMethodIdNoArgs(pp->mapping, &PyId_keys); |
1100 | } |
1101 | |
1102 | static PyObject * |
1103 | mappingproxy_values(mappingproxyobject *pp, PyObject *Py_UNUSED(ignored)) |
1104 | { |
1105 | _Py_IDENTIFIER(values); |
1106 | return _PyObject_CallMethodIdNoArgs(pp->mapping, &PyId_values); |
1107 | } |
1108 | |
1109 | static PyObject * |
1110 | mappingproxy_items(mappingproxyobject *pp, PyObject *Py_UNUSED(ignored)) |
1111 | { |
1112 | _Py_IDENTIFIER(items); |
1113 | return _PyObject_CallMethodIdNoArgs(pp->mapping, &PyId_items); |
1114 | } |
1115 | |
1116 | static PyObject * |
1117 | mappingproxy_copy(mappingproxyobject *pp, PyObject *Py_UNUSED(ignored)) |
1118 | { |
1119 | _Py_IDENTIFIER(copy); |
1120 | return _PyObject_CallMethodIdNoArgs(pp->mapping, &PyId_copy); |
1121 | } |
1122 | |
1123 | static PyObject * |
1124 | mappingproxy_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 | |
1133 | static 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 | |
1152 | static void |
1153 | mappingproxy_dealloc(mappingproxyobject *pp) |
1154 | { |
1155 | _PyObject_GC_UNTRACK(pp); |
1156 | Py_DECREF(pp->mapping); |
1157 | PyObject_GC_Del(pp); |
1158 | } |
1159 | |
1160 | static PyObject * |
1161 | mappingproxy_getiter(mappingproxyobject *pp) |
1162 | { |
1163 | return PyObject_GetIter(pp->mapping); |
1164 | } |
1165 | |
1166 | static PyObject * |
1167 | mappingproxy_str(mappingproxyobject *pp) |
1168 | { |
1169 | return PyObject_Str(pp->mapping); |
1170 | } |
1171 | |
1172 | static PyObject * |
1173 | mappingproxy_repr(mappingproxyobject *pp) |
1174 | { |
1175 | return PyUnicode_FromFormat("mappingproxy(%R)" , pp->mapping); |
1176 | } |
1177 | |
1178 | static int |
1179 | mappingproxy_traverse(PyObject *self, visitproc visit, void *arg) |
1180 | { |
1181 | mappingproxyobject *pp = (mappingproxyobject *)self; |
1182 | Py_VISIT(pp->mapping); |
1183 | return 0; |
1184 | } |
1185 | |
1186 | static PyObject * |
1187 | mappingproxy_richcompare(mappingproxyobject *v, PyObject *w, int op) |
1188 | { |
1189 | return PyObject_RichCompare(v->mapping, w, op); |
1190 | } |
1191 | |
1192 | static int |
1193 | mappingproxy_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 |
1208 | mappingproxy.__new__ as mappingproxy_new |
1209 | |
1210 | mapping: object |
1211 | |
1212 | [clinic start generated code]*/ |
1213 | |
1214 | static PyObject * |
1215 | mappingproxy_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 | |
1232 | PyObject * |
1233 | PyDictProxy_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 | |
1255 | typedef 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 | |
1263 | static void |
1264 | wrapper_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 | |
1274 | static PyObject * |
1275 | wrapper_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 | |
1300 | static Py_hash_t |
1301 | wrapper_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 | |
1312 | static PyObject * |
1313 | wrapper_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 | |
1321 | static PyObject * |
1322 | wrapper_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 | |
1328 | static PyMethodDef wrapper_methods[] = { |
1329 | {"__reduce__" , (PyCFunction)wrapper_reduce, METH_NOARGS, NULL}, |
1330 | {NULL, NULL} |
1331 | }; |
1332 | |
1333 | static PyMemberDef wrapper_members[] = { |
1334 | {"__self__" , T_OBJECT, offsetof(wrapperobject, self), READONLY}, |
1335 | {0} |
1336 | }; |
1337 | |
1338 | static PyObject * |
1339 | wrapper_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 | |
1347 | static PyObject * |
1348 | wrapper_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 | |
1355 | static PyObject * |
1356 | wrapper_doc(wrapperobject *wp, void *Py_UNUSED(ignored)) |
1357 | { |
1358 | return _PyType_GetDocFromInternalDoc(wp->descr->d_base->name, wp->descr->d_base->doc); |
1359 | } |
1360 | |
1361 | static PyObject * |
1362 | wrapper_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 | |
1367 | static PyObject * |
1368 | wrapper_qualname(wrapperobject *wp, void *Py_UNUSED(ignored)) |
1369 | { |
1370 | return descr_get_qualname((PyDescrObject *)wp->descr, NULL); |
1371 | } |
1372 | |
1373 | static 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 | |
1382 | static PyObject * |
1383 | wrapper_call(wrapperobject *wp, PyObject *args, PyObject *kwds) |
1384 | { |
1385 | return wrapperdescr_raw_call(wp->descr, wp->self, args, kwds); |
1386 | } |
1387 | |
1388 | static int |
1389 | wrapper_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 | |
1397 | PyTypeObject _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 | |
1435 | PyObject * |
1436 | PyWrapper_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 | /* |
1461 | class 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 | |
1490 | typedef 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 | |
1500 | static PyObject * property_copy(PyObject *, PyObject *, PyObject *, |
1501 | PyObject *); |
1502 | |
1503 | static 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 | |
1512 | PyDoc_STRVAR(getter_doc, |
1513 | "Descriptor to obtain a copy of the property with a different getter." ); |
1514 | |
1515 | static PyObject * |
1516 | property_getter(PyObject *self, PyObject *getter) |
1517 | { |
1518 | return property_copy(self, getter, NULL, NULL); |
1519 | } |
1520 | |
1521 | |
1522 | PyDoc_STRVAR(setter_doc, |
1523 | "Descriptor to obtain a copy of the property with a different setter." ); |
1524 | |
1525 | static PyObject * |
1526 | property_setter(PyObject *self, PyObject *setter) |
1527 | { |
1528 | return property_copy(self, NULL, setter, NULL); |
1529 | } |
1530 | |
1531 | |
1532 | PyDoc_STRVAR(deleter_doc, |
1533 | "Descriptor to obtain a copy of the property with a different deleter." ); |
1534 | |
1535 | static PyObject * |
1536 | property_deleter(PyObject *self, PyObject *deleter) |
1537 | { |
1538 | return property_copy(self, NULL, NULL, deleter); |
1539 | } |
1540 | |
1541 | |
1542 | PyDoc_STRVAR(set_name_doc, |
1543 | "Method to set name of a property." ); |
1544 | |
1545 | static PyObject * |
1546 | property_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 | |
1564 | static 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 | |
1573 | static void |
1574 | property_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 | |
1587 | static PyObject * |
1588 | property_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 | |
1609 | static int |
1610 | property_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 | |
1644 | static PyObject * |
1645 | property_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] |
1685 | property.__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 | |
1696 | Property attribute. |
1697 | |
1698 | Typical use is to define a managed attribute x: |
1699 | |
1700 | class 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 | |
1706 | Decorators make defining new properties or modifying existing ones easy: |
1707 | |
1708 | class 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 | |
1721 | static int |
1722 | property_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 | |
1773 | static PyObject * |
1774 | property_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 | |
1802 | static PyGetSetDef property_getsetlist[] = { |
1803 | {"__isabstractmethod__" , |
1804 | (getter)property_get___isabstractmethod__, NULL, |
1805 | NULL, |
1806 | NULL}, |
1807 | {NULL} /* Sentinel */ |
1808 | }; |
1809 | |
1810 | static int |
1811 | property_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 | |
1822 | static int |
1823 | property_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 | |
1832 | PyTypeObject 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 | |
1875 | PyTypeObject 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 | |