1 /* Abstract Object Interface (many thanks to Jim Fulton) */
2
3 #include "Python.h"
4 #include "pycore_pystate.h"
5 #include <ctype.h>
6 #include "structmember.h" /* we need the offsetof() macro from there */
7 #include "longintrepr.h"
8
9
10
11 /* Shorthands to return certain errors */
12
13 static PyObject *
type_error(const char * msg,PyObject * obj)14 type_error(const char *msg, PyObject *obj)
15 {
16 PyErr_Format(PyExc_TypeError, msg, obj->ob_type->tp_name);
17 return NULL;
18 }
19
20 static PyObject *
null_error(void)21 null_error(void)
22 {
23 if (!PyErr_Occurred())
24 PyErr_SetString(PyExc_SystemError,
25 "null argument to internal routine");
26 return NULL;
27 }
28
29 /* Operations on any object */
30
31 PyObject *
PyObject_Type(PyObject * o)32 PyObject_Type(PyObject *o)
33 {
34 PyObject *v;
35
36 if (o == NULL) {
37 return null_error();
38 }
39
40 v = (PyObject *)o->ob_type;
41 Py_INCREF(v);
42 return v;
43 }
44
45 Py_ssize_t
PyObject_Size(PyObject * o)46 PyObject_Size(PyObject *o)
47 {
48 PySequenceMethods *m;
49
50 if (o == NULL) {
51 null_error();
52 return -1;
53 }
54
55 m = o->ob_type->tp_as_sequence;
56 if (m && m->sq_length) {
57 Py_ssize_t len = m->sq_length(o);
58 assert(len >= 0 || PyErr_Occurred());
59 return len;
60 }
61
62 return PyMapping_Size(o);
63 }
64
65 #undef PyObject_Length
66 Py_ssize_t
PyObject_Length(PyObject * o)67 PyObject_Length(PyObject *o)
68 {
69 return PyObject_Size(o);
70 }
71 #define PyObject_Length PyObject_Size
72
73 int
_PyObject_HasLen(PyObject * o)74 _PyObject_HasLen(PyObject *o) {
75 return (Py_TYPE(o)->tp_as_sequence && Py_TYPE(o)->tp_as_sequence->sq_length) ||
76 (Py_TYPE(o)->tp_as_mapping && Py_TYPE(o)->tp_as_mapping->mp_length);
77 }
78
79 /* The length hint function returns a non-negative value from o.__len__()
80 or o.__length_hint__(). If those methods aren't found the defaultvalue is
81 returned. If one of the calls fails with an exception other than TypeError
82 this function returns -1.
83 */
84
85 Py_ssize_t
PyObject_LengthHint(PyObject * o,Py_ssize_t defaultvalue)86 PyObject_LengthHint(PyObject *o, Py_ssize_t defaultvalue)
87 {
88 PyObject *hint, *result;
89 Py_ssize_t res;
90 _Py_IDENTIFIER(__length_hint__);
91 if (_PyObject_HasLen(o)) {
92 res = PyObject_Length(o);
93 if (res < 0) {
94 assert(PyErr_Occurred());
95 if (!PyErr_ExceptionMatches(PyExc_TypeError)) {
96 return -1;
97 }
98 PyErr_Clear();
99 }
100 else {
101 return res;
102 }
103 }
104 hint = _PyObject_LookupSpecial(o, &PyId___length_hint__);
105 if (hint == NULL) {
106 if (PyErr_Occurred()) {
107 return -1;
108 }
109 return defaultvalue;
110 }
111 result = _PyObject_CallNoArg(hint);
112 Py_DECREF(hint);
113 if (result == NULL) {
114 if (PyErr_ExceptionMatches(PyExc_TypeError)) {
115 PyErr_Clear();
116 return defaultvalue;
117 }
118 return -1;
119 }
120 else if (result == Py_NotImplemented) {
121 Py_DECREF(result);
122 return defaultvalue;
123 }
124 if (!PyLong_Check(result)) {
125 PyErr_Format(PyExc_TypeError, "__length_hint__ must be an integer, not %.100s",
126 Py_TYPE(result)->tp_name);
127 Py_DECREF(result);
128 return -1;
129 }
130 res = PyLong_AsSsize_t(result);
131 Py_DECREF(result);
132 if (res < 0 && PyErr_Occurred()) {
133 return -1;
134 }
135 if (res < 0) {
136 PyErr_Format(PyExc_ValueError, "__length_hint__() should return >= 0");
137 return -1;
138 }
139 return res;
140 }
141
142 PyObject *
PyObject_GetItem(PyObject * o,PyObject * key)143 PyObject_GetItem(PyObject *o, PyObject *key)
144 {
145 PyMappingMethods *m;
146 PySequenceMethods *ms;
147
148 if (o == NULL || key == NULL) {
149 return null_error();
150 }
151
152 m = o->ob_type->tp_as_mapping;
153 if (m && m->mp_subscript) {
154 PyObject *item = m->mp_subscript(o, key);
155 assert((item != NULL) ^ (PyErr_Occurred() != NULL));
156 return item;
157 }
158
159 ms = o->ob_type->tp_as_sequence;
160 if (ms && ms->sq_item) {
161 if (PyIndex_Check(key)) {
162 Py_ssize_t key_value;
163 key_value = PyNumber_AsSsize_t(key, PyExc_IndexError);
164 if (key_value == -1 && PyErr_Occurred())
165 return NULL;
166 return PySequence_GetItem(o, key_value);
167 }
168 else {
169 return type_error("sequence index must "
170 "be integer, not '%.200s'", key);
171 }
172 }
173
174 if (PyType_Check(o)) {
175 PyObject *meth, *result, *stack[1] = {key};
176 _Py_IDENTIFIER(__class_getitem__);
177 if (_PyObject_LookupAttrId(o, &PyId___class_getitem__, &meth) < 0) {
178 return NULL;
179 }
180 if (meth) {
181 result = _PyObject_FastCall(meth, stack, 1);
182 Py_DECREF(meth);
183 return result;
184 }
185 }
186
187 return type_error("'%.200s' object is not subscriptable", o);
188 }
189
190 int
PyObject_SetItem(PyObject * o,PyObject * key,PyObject * value)191 PyObject_SetItem(PyObject *o, PyObject *key, PyObject *value)
192 {
193 PyMappingMethods *m;
194
195 if (o == NULL || key == NULL || value == NULL) {
196 null_error();
197 return -1;
198 }
199 m = o->ob_type->tp_as_mapping;
200 if (m && m->mp_ass_subscript)
201 return m->mp_ass_subscript(o, key, value);
202
203 if (o->ob_type->tp_as_sequence) {
204 if (PyIndex_Check(key)) {
205 Py_ssize_t key_value;
206 key_value = PyNumber_AsSsize_t(key, PyExc_IndexError);
207 if (key_value == -1 && PyErr_Occurred())
208 return -1;
209 return PySequence_SetItem(o, key_value, value);
210 }
211 else if (o->ob_type->tp_as_sequence->sq_ass_item) {
212 type_error("sequence index must be "
213 "integer, not '%.200s'", key);
214 return -1;
215 }
216 }
217
218 type_error("'%.200s' object does not support item assignment", o);
219 return -1;
220 }
221
222 int
PyObject_DelItem(PyObject * o,PyObject * key)223 PyObject_DelItem(PyObject *o, PyObject *key)
224 {
225 PyMappingMethods *m;
226
227 if (o == NULL || key == NULL) {
228 null_error();
229 return -1;
230 }
231 m = o->ob_type->tp_as_mapping;
232 if (m && m->mp_ass_subscript)
233 return m->mp_ass_subscript(o, key, (PyObject*)NULL);
234
235 if (o->ob_type->tp_as_sequence) {
236 if (PyIndex_Check(key)) {
237 Py_ssize_t key_value;
238 key_value = PyNumber_AsSsize_t(key, PyExc_IndexError);
239 if (key_value == -1 && PyErr_Occurred())
240 return -1;
241 return PySequence_DelItem(o, key_value);
242 }
243 else if (o->ob_type->tp_as_sequence->sq_ass_item) {
244 type_error("sequence index must be "
245 "integer, not '%.200s'", key);
246 return -1;
247 }
248 }
249
250 type_error("'%.200s' object does not support item deletion", o);
251 return -1;
252 }
253
254 int
PyObject_DelItemString(PyObject * o,const char * key)255 PyObject_DelItemString(PyObject *o, const char *key)
256 {
257 PyObject *okey;
258 int ret;
259
260 if (o == NULL || key == NULL) {
261 null_error();
262 return -1;
263 }
264 okey = PyUnicode_FromString(key);
265 if (okey == NULL)
266 return -1;
267 ret = PyObject_DelItem(o, okey);
268 Py_DECREF(okey);
269 return ret;
270 }
271
272 /* We release the buffer right after use of this function which could
273 cause issues later on. Don't use these functions in new code.
274 */
275 int
PyObject_CheckReadBuffer(PyObject * obj)276 PyObject_CheckReadBuffer(PyObject *obj)
277 {
278 PyBufferProcs *pb = obj->ob_type->tp_as_buffer;
279 Py_buffer view;
280
281 if (pb == NULL ||
282 pb->bf_getbuffer == NULL)
283 return 0;
284 if ((*pb->bf_getbuffer)(obj, &view, PyBUF_SIMPLE) == -1) {
285 PyErr_Clear();
286 return 0;
287 }
288 PyBuffer_Release(&view);
289 return 1;
290 }
291
292 static int
as_read_buffer(PyObject * obj,const void ** buffer,Py_ssize_t * buffer_len)293 as_read_buffer(PyObject *obj, const void **buffer, Py_ssize_t *buffer_len)
294 {
295 Py_buffer view;
296
297 if (obj == NULL || buffer == NULL || buffer_len == NULL) {
298 null_error();
299 return -1;
300 }
301 if (PyObject_GetBuffer(obj, &view, PyBUF_SIMPLE) != 0)
302 return -1;
303
304 *buffer = view.buf;
305 *buffer_len = view.len;
306 PyBuffer_Release(&view);
307 return 0;
308 }
309
310 int
PyObject_AsCharBuffer(PyObject * obj,const char ** buffer,Py_ssize_t * buffer_len)311 PyObject_AsCharBuffer(PyObject *obj,
312 const char **buffer,
313 Py_ssize_t *buffer_len)
314 {
315 return as_read_buffer(obj, (const void **)buffer, buffer_len);
316 }
317
PyObject_AsReadBuffer(PyObject * obj,const void ** buffer,Py_ssize_t * buffer_len)318 int PyObject_AsReadBuffer(PyObject *obj,
319 const void **buffer,
320 Py_ssize_t *buffer_len)
321 {
322 return as_read_buffer(obj, buffer, buffer_len);
323 }
324
PyObject_AsWriteBuffer(PyObject * obj,void ** buffer,Py_ssize_t * buffer_len)325 int PyObject_AsWriteBuffer(PyObject *obj,
326 void **buffer,
327 Py_ssize_t *buffer_len)
328 {
329 PyBufferProcs *pb;
330 Py_buffer view;
331
332 if (obj == NULL || buffer == NULL || buffer_len == NULL) {
333 null_error();
334 return -1;
335 }
336 pb = obj->ob_type->tp_as_buffer;
337 if (pb == NULL ||
338 pb->bf_getbuffer == NULL ||
339 ((*pb->bf_getbuffer)(obj, &view, PyBUF_WRITABLE) != 0)) {
340 PyErr_SetString(PyExc_TypeError,
341 "expected a writable bytes-like object");
342 return -1;
343 }
344
345 *buffer = view.buf;
346 *buffer_len = view.len;
347 PyBuffer_Release(&view);
348 return 0;
349 }
350
351 /* Buffer C-API for Python 3.0 */
352
353 int
PyObject_GetBuffer(PyObject * obj,Py_buffer * view,int flags)354 PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags)
355 {
356 PyBufferProcs *pb = obj->ob_type->tp_as_buffer;
357
358 if (pb == NULL || pb->bf_getbuffer == NULL) {
359 PyErr_Format(PyExc_TypeError,
360 "a bytes-like object is required, not '%.100s'",
361 Py_TYPE(obj)->tp_name);
362 return -1;
363 }
364 return (*pb->bf_getbuffer)(obj, view, flags);
365 }
366
367 static int
_IsFortranContiguous(const Py_buffer * view)368 _IsFortranContiguous(const Py_buffer *view)
369 {
370 Py_ssize_t sd, dim;
371 int i;
372
373 /* 1) len = product(shape) * itemsize
374 2) itemsize > 0
375 3) len = 0 <==> exists i: shape[i] = 0 */
376 if (view->len == 0) return 1;
377 if (view->strides == NULL) { /* C-contiguous by definition */
378 /* Trivially F-contiguous */
379 if (view->ndim <= 1) return 1;
380
381 /* ndim > 1 implies shape != NULL */
382 assert(view->shape != NULL);
383
384 /* Effectively 1-d */
385 sd = 0;
386 for (i=0; i<view->ndim; i++) {
387 if (view->shape[i] > 1) sd += 1;
388 }
389 return sd <= 1;
390 }
391
392 /* strides != NULL implies both of these */
393 assert(view->ndim > 0);
394 assert(view->shape != NULL);
395
396 sd = view->itemsize;
397 for (i=0; i<view->ndim; i++) {
398 dim = view->shape[i];
399 if (dim > 1 && view->strides[i] != sd) {
400 return 0;
401 }
402 sd *= dim;
403 }
404 return 1;
405 }
406
407 static int
_IsCContiguous(const Py_buffer * view)408 _IsCContiguous(const Py_buffer *view)
409 {
410 Py_ssize_t sd, dim;
411 int i;
412
413 /* 1) len = product(shape) * itemsize
414 2) itemsize > 0
415 3) len = 0 <==> exists i: shape[i] = 0 */
416 if (view->len == 0) return 1;
417 if (view->strides == NULL) return 1; /* C-contiguous by definition */
418
419 /* strides != NULL implies both of these */
420 assert(view->ndim > 0);
421 assert(view->shape != NULL);
422
423 sd = view->itemsize;
424 for (i=view->ndim-1; i>=0; i--) {
425 dim = view->shape[i];
426 if (dim > 1 && view->strides[i] != sd) {
427 return 0;
428 }
429 sd *= dim;
430 }
431 return 1;
432 }
433
434 int
PyBuffer_IsContiguous(const Py_buffer * view,char order)435 PyBuffer_IsContiguous(const Py_buffer *view, char order)
436 {
437
438 if (view->suboffsets != NULL) return 0;
439
440 if (order == 'C')
441 return _IsCContiguous(view);
442 else if (order == 'F')
443 return _IsFortranContiguous(view);
444 else if (order == 'A')
445 return (_IsCContiguous(view) || _IsFortranContiguous(view));
446 return 0;
447 }
448
449
450 void*
PyBuffer_GetPointer(Py_buffer * view,Py_ssize_t * indices)451 PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices)
452 {
453 char* pointer;
454 int i;
455 pointer = (char *)view->buf;
456 for (i = 0; i < view->ndim; i++) {
457 pointer += view->strides[i]*indices[i];
458 if ((view->suboffsets != NULL) && (view->suboffsets[i] >= 0)) {
459 pointer = *((char**)pointer) + view->suboffsets[i];
460 }
461 }
462 return (void*)pointer;
463 }
464
465
466 void
_Py_add_one_to_index_F(int nd,Py_ssize_t * index,const Py_ssize_t * shape)467 _Py_add_one_to_index_F(int nd, Py_ssize_t *index, const Py_ssize_t *shape)
468 {
469 int k;
470
471 for (k=0; k<nd; k++) {
472 if (index[k] < shape[k]-1) {
473 index[k]++;
474 break;
475 }
476 else {
477 index[k] = 0;
478 }
479 }
480 }
481
482 void
_Py_add_one_to_index_C(int nd,Py_ssize_t * index,const Py_ssize_t * shape)483 _Py_add_one_to_index_C(int nd, Py_ssize_t *index, const Py_ssize_t *shape)
484 {
485 int k;
486
487 for (k=nd-1; k>=0; k--) {
488 if (index[k] < shape[k]-1) {
489 index[k]++;
490 break;
491 }
492 else {
493 index[k] = 0;
494 }
495 }
496 }
497
498 int
PyBuffer_FromContiguous(Py_buffer * view,void * buf,Py_ssize_t len,char fort)499 PyBuffer_FromContiguous(Py_buffer *view, void *buf, Py_ssize_t len, char fort)
500 {
501 int k;
502 void (*addone)(int, Py_ssize_t *, const Py_ssize_t *);
503 Py_ssize_t *indices, elements;
504 char *src, *ptr;
505
506 if (len > view->len) {
507 len = view->len;
508 }
509
510 if (PyBuffer_IsContiguous(view, fort)) {
511 /* simplest copy is all that is needed */
512 memcpy(view->buf, buf, len);
513 return 0;
514 }
515
516 /* Otherwise a more elaborate scheme is needed */
517
518 /* view->ndim <= 64 */
519 indices = (Py_ssize_t *)PyMem_Malloc(sizeof(Py_ssize_t)*(view->ndim));
520 if (indices == NULL) {
521 PyErr_NoMemory();
522 return -1;
523 }
524 for (k=0; k<view->ndim;k++) {
525 indices[k] = 0;
526 }
527
528 if (fort == 'F') {
529 addone = _Py_add_one_to_index_F;
530 }
531 else {
532 addone = _Py_add_one_to_index_C;
533 }
534 src = buf;
535 /* XXX : This is not going to be the fastest code in the world
536 several optimizations are possible.
537 */
538 elements = len / view->itemsize;
539 while (elements--) {
540 ptr = PyBuffer_GetPointer(view, indices);
541 memcpy(ptr, src, view->itemsize);
542 src += view->itemsize;
543 addone(view->ndim, indices, view->shape);
544 }
545
546 PyMem_Free(indices);
547 return 0;
548 }
549
PyObject_CopyData(PyObject * dest,PyObject * src)550 int PyObject_CopyData(PyObject *dest, PyObject *src)
551 {
552 Py_buffer view_dest, view_src;
553 int k;
554 Py_ssize_t *indices, elements;
555 char *dptr, *sptr;
556
557 if (!PyObject_CheckBuffer(dest) ||
558 !PyObject_CheckBuffer(src)) {
559 PyErr_SetString(PyExc_TypeError,
560 "both destination and source must be "\
561 "bytes-like objects");
562 return -1;
563 }
564
565 if (PyObject_GetBuffer(dest, &view_dest, PyBUF_FULL) != 0) return -1;
566 if (PyObject_GetBuffer(src, &view_src, PyBUF_FULL_RO) != 0) {
567 PyBuffer_Release(&view_dest);
568 return -1;
569 }
570
571 if (view_dest.len < view_src.len) {
572 PyErr_SetString(PyExc_BufferError,
573 "destination is too small to receive data from source");
574 PyBuffer_Release(&view_dest);
575 PyBuffer_Release(&view_src);
576 return -1;
577 }
578
579 if ((PyBuffer_IsContiguous(&view_dest, 'C') &&
580 PyBuffer_IsContiguous(&view_src, 'C')) ||
581 (PyBuffer_IsContiguous(&view_dest, 'F') &&
582 PyBuffer_IsContiguous(&view_src, 'F'))) {
583 /* simplest copy is all that is needed */
584 memcpy(view_dest.buf, view_src.buf, view_src.len);
585 PyBuffer_Release(&view_dest);
586 PyBuffer_Release(&view_src);
587 return 0;
588 }
589
590 /* Otherwise a more elaborate copy scheme is needed */
591
592 /* XXX(nnorwitz): need to check for overflow! */
593 indices = (Py_ssize_t *)PyMem_Malloc(sizeof(Py_ssize_t)*view_src.ndim);
594 if (indices == NULL) {
595 PyErr_NoMemory();
596 PyBuffer_Release(&view_dest);
597 PyBuffer_Release(&view_src);
598 return -1;
599 }
600 for (k=0; k<view_src.ndim;k++) {
601 indices[k] = 0;
602 }
603 elements = 1;
604 for (k=0; k<view_src.ndim; k++) {
605 /* XXX(nnorwitz): can this overflow? */
606 elements *= view_src.shape[k];
607 }
608 while (elements--) {
609 _Py_add_one_to_index_C(view_src.ndim, indices, view_src.shape);
610 dptr = PyBuffer_GetPointer(&view_dest, indices);
611 sptr = PyBuffer_GetPointer(&view_src, indices);
612 memcpy(dptr, sptr, view_src.itemsize);
613 }
614 PyMem_Free(indices);
615 PyBuffer_Release(&view_dest);
616 PyBuffer_Release(&view_src);
617 return 0;
618 }
619
620 void
PyBuffer_FillContiguousStrides(int nd,Py_ssize_t * shape,Py_ssize_t * strides,int itemsize,char fort)621 PyBuffer_FillContiguousStrides(int nd, Py_ssize_t *shape,
622 Py_ssize_t *strides, int itemsize,
623 char fort)
624 {
625 int k;
626 Py_ssize_t sd;
627
628 sd = itemsize;
629 if (fort == 'F') {
630 for (k=0; k<nd; k++) {
631 strides[k] = sd;
632 sd *= shape[k];
633 }
634 }
635 else {
636 for (k=nd-1; k>=0; k--) {
637 strides[k] = sd;
638 sd *= shape[k];
639 }
640 }
641 return;
642 }
643
644 int
PyBuffer_FillInfo(Py_buffer * view,PyObject * obj,void * buf,Py_ssize_t len,int readonly,int flags)645 PyBuffer_FillInfo(Py_buffer *view, PyObject *obj, void *buf, Py_ssize_t len,
646 int readonly, int flags)
647 {
648 if (view == NULL) {
649 PyErr_SetString(PyExc_BufferError,
650 "PyBuffer_FillInfo: view==NULL argument is obsolete");
651 return -1;
652 }
653
654 if (((flags & PyBUF_WRITABLE) == PyBUF_WRITABLE) &&
655 (readonly == 1)) {
656 PyErr_SetString(PyExc_BufferError,
657 "Object is not writable.");
658 return -1;
659 }
660
661 view->obj = obj;
662 if (obj)
663 Py_INCREF(obj);
664 view->buf = buf;
665 view->len = len;
666 view->readonly = readonly;
667 view->itemsize = 1;
668 view->format = NULL;
669 if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT)
670 view->format = "B";
671 view->ndim = 1;
672 view->shape = NULL;
673 if ((flags & PyBUF_ND) == PyBUF_ND)
674 view->shape = &(view->len);
675 view->strides = NULL;
676 if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES)
677 view->strides = &(view->itemsize);
678 view->suboffsets = NULL;
679 view->internal = NULL;
680 return 0;
681 }
682
683 void
PyBuffer_Release(Py_buffer * view)684 PyBuffer_Release(Py_buffer *view)
685 {
686 PyObject *obj = view->obj;
687 PyBufferProcs *pb;
688 if (obj == NULL)
689 return;
690 pb = Py_TYPE(obj)->tp_as_buffer;
691 if (pb && pb->bf_releasebuffer)
692 pb->bf_releasebuffer(obj, view);
693 view->obj = NULL;
694 Py_DECREF(obj);
695 }
696
697 PyObject *
PyObject_Format(PyObject * obj,PyObject * format_spec)698 PyObject_Format(PyObject *obj, PyObject *format_spec)
699 {
700 PyObject *meth;
701 PyObject *empty = NULL;
702 PyObject *result = NULL;
703 _Py_IDENTIFIER(__format__);
704
705 if (format_spec != NULL && !PyUnicode_Check(format_spec)) {
706 PyErr_Format(PyExc_SystemError,
707 "Format specifier must be a string, not %.200s",
708 Py_TYPE(format_spec)->tp_name);
709 return NULL;
710 }
711
712 /* Fast path for common types. */
713 if (format_spec == NULL || PyUnicode_GET_LENGTH(format_spec) == 0) {
714 if (PyUnicode_CheckExact(obj)) {
715 Py_INCREF(obj);
716 return obj;
717 }
718 if (PyLong_CheckExact(obj)) {
719 return PyObject_Str(obj);
720 }
721 }
722
723 /* If no format_spec is provided, use an empty string */
724 if (format_spec == NULL) {
725 empty = PyUnicode_New(0, 0);
726 format_spec = empty;
727 }
728
729 /* Find the (unbound!) __format__ method */
730 meth = _PyObject_LookupSpecial(obj, &PyId___format__);
731 if (meth == NULL) {
732 if (!PyErr_Occurred())
733 PyErr_Format(PyExc_TypeError,
734 "Type %.100s doesn't define __format__",
735 Py_TYPE(obj)->tp_name);
736 goto done;
737 }
738
739 /* And call it. */
740 result = PyObject_CallFunctionObjArgs(meth, format_spec, NULL);
741 Py_DECREF(meth);
742
743 if (result && !PyUnicode_Check(result)) {
744 PyErr_Format(PyExc_TypeError,
745 "__format__ must return a str, not %.200s",
746 Py_TYPE(result)->tp_name);
747 Py_DECREF(result);
748 result = NULL;
749 goto done;
750 }
751
752 done:
753 Py_XDECREF(empty);
754 return result;
755 }
756 /* Operations on numbers */
757
758 int
PyNumber_Check(PyObject * o)759 PyNumber_Check(PyObject *o)
760 {
761 return o && o->ob_type->tp_as_number &&
762 (o->ob_type->tp_as_number->nb_index ||
763 o->ob_type->tp_as_number->nb_int ||
764 o->ob_type->tp_as_number->nb_float);
765 }
766
767 /* Binary operators */
768
769 #define NB_SLOT(x) offsetof(PyNumberMethods, x)
770 #define NB_BINOP(nb_methods, slot) \
771 (*(binaryfunc*)(& ((char*)nb_methods)[slot]))
772 #define NB_TERNOP(nb_methods, slot) \
773 (*(ternaryfunc*)(& ((char*)nb_methods)[slot]))
774
775 /*
776 Calling scheme used for binary operations:
777
778 Order operations are tried until either a valid result or error:
779 w.op(v,w)[*], v.op(v,w), w.op(v,w)
780
781 [*] only when v->ob_type != w->ob_type && w->ob_type is a subclass of
782 v->ob_type
783 */
784
785 static PyObject *
binary_op1(PyObject * v,PyObject * w,const int op_slot)786 binary_op1(PyObject *v, PyObject *w, const int op_slot)
787 {
788 PyObject *x;
789 binaryfunc slotv = NULL;
790 binaryfunc slotw = NULL;
791
792 if (v->ob_type->tp_as_number != NULL)
793 slotv = NB_BINOP(v->ob_type->tp_as_number, op_slot);
794 if (w->ob_type != v->ob_type &&
795 w->ob_type->tp_as_number != NULL) {
796 slotw = NB_BINOP(w->ob_type->tp_as_number, op_slot);
797 if (slotw == slotv)
798 slotw = NULL;
799 }
800 if (slotv) {
801 if (slotw && PyType_IsSubtype(w->ob_type, v->ob_type)) {
802 x = slotw(v, w);
803 if (x != Py_NotImplemented)
804 return x;
805 Py_DECREF(x); /* can't do it */
806 slotw = NULL;
807 }
808 x = slotv(v, w);
809 if (x != Py_NotImplemented)
810 return x;
811 Py_DECREF(x); /* can't do it */
812 }
813 if (slotw) {
814 x = slotw(v, w);
815 if (x != Py_NotImplemented)
816 return x;
817 Py_DECREF(x); /* can't do it */
818 }
819 Py_RETURN_NOTIMPLEMENTED;
820 }
821
822 static PyObject *
binop_type_error(PyObject * v,PyObject * w,const char * op_name)823 binop_type_error(PyObject *v, PyObject *w, const char *op_name)
824 {
825 PyErr_Format(PyExc_TypeError,
826 "unsupported operand type(s) for %.100s: "
827 "'%.100s' and '%.100s'",
828 op_name,
829 v->ob_type->tp_name,
830 w->ob_type->tp_name);
831 return NULL;
832 }
833
834 static PyObject *
binary_op(PyObject * v,PyObject * w,const int op_slot,const char * op_name)835 binary_op(PyObject *v, PyObject *w, const int op_slot, const char *op_name)
836 {
837 PyObject *result = binary_op1(v, w, op_slot);
838 if (result == Py_NotImplemented) {
839 Py_DECREF(result);
840
841 if (op_slot == NB_SLOT(nb_rshift) &&
842 PyCFunction_Check(v) &&
843 strcmp(((PyCFunctionObject *)v)->m_ml->ml_name, "print") == 0)
844 {
845 PyErr_Format(PyExc_TypeError,
846 "unsupported operand type(s) for %.100s: "
847 "'%.100s' and '%.100s'. Did you mean \"print(<message>, "
848 "file=<output_stream>)\"?",
849 op_name,
850 v->ob_type->tp_name,
851 w->ob_type->tp_name);
852 return NULL;
853 }
854
855 return binop_type_error(v, w, op_name);
856 }
857 return result;
858 }
859
860
861 /*
862 Calling scheme used for ternary operations:
863
864 Order operations are tried until either a valid result or error:
865 v.op(v,w,z), w.op(v,w,z), z.op(v,w,z)
866 */
867
868 static PyObject *
ternary_op(PyObject * v,PyObject * w,PyObject * z,const int op_slot,const char * op_name)869 ternary_op(PyObject *v,
870 PyObject *w,
871 PyObject *z,
872 const int op_slot,
873 const char *op_name)
874 {
875 PyNumberMethods *mv, *mw, *mz;
876 PyObject *x = NULL;
877 ternaryfunc slotv = NULL;
878 ternaryfunc slotw = NULL;
879 ternaryfunc slotz = NULL;
880
881 mv = v->ob_type->tp_as_number;
882 mw = w->ob_type->tp_as_number;
883 if (mv != NULL)
884 slotv = NB_TERNOP(mv, op_slot);
885 if (w->ob_type != v->ob_type &&
886 mw != NULL) {
887 slotw = NB_TERNOP(mw, op_slot);
888 if (slotw == slotv)
889 slotw = NULL;
890 }
891 if (slotv) {
892 if (slotw && PyType_IsSubtype(w->ob_type, v->ob_type)) {
893 x = slotw(v, w, z);
894 if (x != Py_NotImplemented)
895 return x;
896 Py_DECREF(x); /* can't do it */
897 slotw = NULL;
898 }
899 x = slotv(v, w, z);
900 if (x != Py_NotImplemented)
901 return x;
902 Py_DECREF(x); /* can't do it */
903 }
904 if (slotw) {
905 x = slotw(v, w, z);
906 if (x != Py_NotImplemented)
907 return x;
908 Py_DECREF(x); /* can't do it */
909 }
910 mz = z->ob_type->tp_as_number;
911 if (mz != NULL) {
912 slotz = NB_TERNOP(mz, op_slot);
913 if (slotz == slotv || slotz == slotw)
914 slotz = NULL;
915 if (slotz) {
916 x = slotz(v, w, z);
917 if (x != Py_NotImplemented)
918 return x;
919 Py_DECREF(x); /* can't do it */
920 }
921 }
922
923 if (z == Py_None)
924 PyErr_Format(
925 PyExc_TypeError,
926 "unsupported operand type(s) for ** or pow(): "
927 "'%.100s' and '%.100s'",
928 v->ob_type->tp_name,
929 w->ob_type->tp_name);
930 else
931 PyErr_Format(
932 PyExc_TypeError,
933 "unsupported operand type(s) for pow(): "
934 "'%.100s', '%.100s', '%.100s'",
935 v->ob_type->tp_name,
936 w->ob_type->tp_name,
937 z->ob_type->tp_name);
938 return NULL;
939 }
940
941 #define BINARY_FUNC(func, op, op_name) \
942 PyObject * \
943 func(PyObject *v, PyObject *w) { \
944 return binary_op(v, w, NB_SLOT(op), op_name); \
945 }
946
947 BINARY_FUNC(PyNumber_Or, nb_or, "|")
948 BINARY_FUNC(PyNumber_Xor, nb_xor, "^")
949 BINARY_FUNC(PyNumber_And, nb_and, "&")
950 BINARY_FUNC(PyNumber_Lshift, nb_lshift, "<<")
951 BINARY_FUNC(PyNumber_Rshift, nb_rshift, ">>")
952 BINARY_FUNC(PyNumber_Subtract, nb_subtract, "-")
953 BINARY_FUNC(PyNumber_Divmod, nb_divmod, "divmod()")
954
955 PyObject *
PyNumber_Add(PyObject * v,PyObject * w)956 PyNumber_Add(PyObject *v, PyObject *w)
957 {
958 PyObject *result = binary_op1(v, w, NB_SLOT(nb_add));
959 if (result == Py_NotImplemented) {
960 PySequenceMethods *m = v->ob_type->tp_as_sequence;
961 Py_DECREF(result);
962 if (m && m->sq_concat) {
963 return (*m->sq_concat)(v, w);
964 }
965 result = binop_type_error(v, w, "+");
966 }
967 return result;
968 }
969
970 static PyObject *
sequence_repeat(ssizeargfunc repeatfunc,PyObject * seq,PyObject * n)971 sequence_repeat(ssizeargfunc repeatfunc, PyObject *seq, PyObject *n)
972 {
973 Py_ssize_t count;
974 if (PyIndex_Check(n)) {
975 count = PyNumber_AsSsize_t(n, PyExc_OverflowError);
976 if (count == -1 && PyErr_Occurred())
977 return NULL;
978 }
979 else {
980 return type_error("can't multiply sequence by "
981 "non-int of type '%.200s'", n);
982 }
983 return (*repeatfunc)(seq, count);
984 }
985
986 PyObject *
PyNumber_Multiply(PyObject * v,PyObject * w)987 PyNumber_Multiply(PyObject *v, PyObject *w)
988 {
989 PyObject *result = binary_op1(v, w, NB_SLOT(nb_multiply));
990 if (result == Py_NotImplemented) {
991 PySequenceMethods *mv = v->ob_type->tp_as_sequence;
992 PySequenceMethods *mw = w->ob_type->tp_as_sequence;
993 Py_DECREF(result);
994 if (mv && mv->sq_repeat) {
995 return sequence_repeat(mv->sq_repeat, v, w);
996 }
997 else if (mw && mw->sq_repeat) {
998 return sequence_repeat(mw->sq_repeat, w, v);
999 }
1000 result = binop_type_error(v, w, "*");
1001 }
1002 return result;
1003 }
1004
1005 PyObject *
PyNumber_MatrixMultiply(PyObject * v,PyObject * w)1006 PyNumber_MatrixMultiply(PyObject *v, PyObject *w)
1007 {
1008 return binary_op(v, w, NB_SLOT(nb_matrix_multiply), "@");
1009 }
1010
1011 PyObject *
PyNumber_FloorDivide(PyObject * v,PyObject * w)1012 PyNumber_FloorDivide(PyObject *v, PyObject *w)
1013 {
1014 return binary_op(v, w, NB_SLOT(nb_floor_divide), "//");
1015 }
1016
1017 PyObject *
PyNumber_TrueDivide(PyObject * v,PyObject * w)1018 PyNumber_TrueDivide(PyObject *v, PyObject *w)
1019 {
1020 return binary_op(v, w, NB_SLOT(nb_true_divide), "/");
1021 }
1022
1023 PyObject *
PyNumber_Remainder(PyObject * v,PyObject * w)1024 PyNumber_Remainder(PyObject *v, PyObject *w)
1025 {
1026 return binary_op(v, w, NB_SLOT(nb_remainder), "%");
1027 }
1028
1029 PyObject *
PyNumber_Power(PyObject * v,PyObject * w,PyObject * z)1030 PyNumber_Power(PyObject *v, PyObject *w, PyObject *z)
1031 {
1032 return ternary_op(v, w, z, NB_SLOT(nb_power), "** or pow()");
1033 }
1034
1035 /* Binary in-place operators */
1036
1037 /* The in-place operators are defined to fall back to the 'normal',
1038 non in-place operations, if the in-place methods are not in place.
1039
1040 - If the left hand object has the appropriate struct members, and
1041 they are filled, call the appropriate function and return the
1042 result. No coercion is done on the arguments; the left-hand object
1043 is the one the operation is performed on, and it's up to the
1044 function to deal with the right-hand object.
1045
1046 - Otherwise, in-place modification is not supported. Handle it exactly as
1047 a non in-place operation of the same kind.
1048
1049 */
1050
1051 static PyObject *
binary_iop1(PyObject * v,PyObject * w,const int iop_slot,const int op_slot)1052 binary_iop1(PyObject *v, PyObject *w, const int iop_slot, const int op_slot)
1053 {
1054 PyNumberMethods *mv = v->ob_type->tp_as_number;
1055 if (mv != NULL) {
1056 binaryfunc slot = NB_BINOP(mv, iop_slot);
1057 if (slot) {
1058 PyObject *x = (slot)(v, w);
1059 if (x != Py_NotImplemented) {
1060 return x;
1061 }
1062 Py_DECREF(x);
1063 }
1064 }
1065 return binary_op1(v, w, op_slot);
1066 }
1067
1068 static PyObject *
binary_iop(PyObject * v,PyObject * w,const int iop_slot,const int op_slot,const char * op_name)1069 binary_iop(PyObject *v, PyObject *w, const int iop_slot, const int op_slot,
1070 const char *op_name)
1071 {
1072 PyObject *result = binary_iop1(v, w, iop_slot, op_slot);
1073 if (result == Py_NotImplemented) {
1074 Py_DECREF(result);
1075 return binop_type_error(v, w, op_name);
1076 }
1077 return result;
1078 }
1079
1080 #define INPLACE_BINOP(func, iop, op, op_name) \
1081 PyObject * \
1082 func(PyObject *v, PyObject *w) { \
1083 return binary_iop(v, w, NB_SLOT(iop), NB_SLOT(op), op_name); \
1084 }
1085
1086 INPLACE_BINOP(PyNumber_InPlaceOr, nb_inplace_or, nb_or, "|=")
1087 INPLACE_BINOP(PyNumber_InPlaceXor, nb_inplace_xor, nb_xor, "^=")
1088 INPLACE_BINOP(PyNumber_InPlaceAnd, nb_inplace_and, nb_and, "&=")
1089 INPLACE_BINOP(PyNumber_InPlaceLshift, nb_inplace_lshift, nb_lshift, "<<=")
1090 INPLACE_BINOP(PyNumber_InPlaceRshift, nb_inplace_rshift, nb_rshift, ">>=")
1091 INPLACE_BINOP(PyNumber_InPlaceSubtract, nb_inplace_subtract, nb_subtract, "-=")
1092 INPLACE_BINOP(PyNumber_InMatrixMultiply, nb_inplace_matrix_multiply, nb_matrix_multiply, "@=")
1093
1094 PyObject *
PyNumber_InPlaceFloorDivide(PyObject * v,PyObject * w)1095 PyNumber_InPlaceFloorDivide(PyObject *v, PyObject *w)
1096 {
1097 return binary_iop(v, w, NB_SLOT(nb_inplace_floor_divide),
1098 NB_SLOT(nb_floor_divide), "//=");
1099 }
1100
1101 PyObject *
PyNumber_InPlaceTrueDivide(PyObject * v,PyObject * w)1102 PyNumber_InPlaceTrueDivide(PyObject *v, PyObject *w)
1103 {
1104 return binary_iop(v, w, NB_SLOT(nb_inplace_true_divide),
1105 NB_SLOT(nb_true_divide), "/=");
1106 }
1107
1108 PyObject *
PyNumber_InPlaceAdd(PyObject * v,PyObject * w)1109 PyNumber_InPlaceAdd(PyObject *v, PyObject *w)
1110 {
1111 PyObject *result = binary_iop1(v, w, NB_SLOT(nb_inplace_add),
1112 NB_SLOT(nb_add));
1113 if (result == Py_NotImplemented) {
1114 PySequenceMethods *m = v->ob_type->tp_as_sequence;
1115 Py_DECREF(result);
1116 if (m != NULL) {
1117 binaryfunc f = NULL;
1118 f = m->sq_inplace_concat;
1119 if (f == NULL)
1120 f = m->sq_concat;
1121 if (f != NULL)
1122 return (*f)(v, w);
1123 }
1124 result = binop_type_error(v, w, "+=");
1125 }
1126 return result;
1127 }
1128
1129 PyObject *
PyNumber_InPlaceMultiply(PyObject * v,PyObject * w)1130 PyNumber_InPlaceMultiply(PyObject *v, PyObject *w)
1131 {
1132 PyObject *result = binary_iop1(v, w, NB_SLOT(nb_inplace_multiply),
1133 NB_SLOT(nb_multiply));
1134 if (result == Py_NotImplemented) {
1135 ssizeargfunc f = NULL;
1136 PySequenceMethods *mv = v->ob_type->tp_as_sequence;
1137 PySequenceMethods *mw = w->ob_type->tp_as_sequence;
1138 Py_DECREF(result);
1139 if (mv != NULL) {
1140 f = mv->sq_inplace_repeat;
1141 if (f == NULL)
1142 f = mv->sq_repeat;
1143 if (f != NULL)
1144 return sequence_repeat(f, v, w);
1145 }
1146 else if (mw != NULL) {
1147 /* Note that the right hand operand should not be
1148 * mutated in this case so sq_inplace_repeat is not
1149 * used. */
1150 if (mw->sq_repeat)
1151 return sequence_repeat(mw->sq_repeat, w, v);
1152 }
1153 result = binop_type_error(v, w, "*=");
1154 }
1155 return result;
1156 }
1157
1158 PyObject *
PyNumber_InPlaceMatrixMultiply(PyObject * v,PyObject * w)1159 PyNumber_InPlaceMatrixMultiply(PyObject *v, PyObject *w)
1160 {
1161 return binary_iop(v, w, NB_SLOT(nb_inplace_matrix_multiply),
1162 NB_SLOT(nb_matrix_multiply), "@=");
1163 }
1164
1165 PyObject *
PyNumber_InPlaceRemainder(PyObject * v,PyObject * w)1166 PyNumber_InPlaceRemainder(PyObject *v, PyObject *w)
1167 {
1168 return binary_iop(v, w, NB_SLOT(nb_inplace_remainder),
1169 NB_SLOT(nb_remainder), "%=");
1170 }
1171
1172 PyObject *
PyNumber_InPlacePower(PyObject * v,PyObject * w,PyObject * z)1173 PyNumber_InPlacePower(PyObject *v, PyObject *w, PyObject *z)
1174 {
1175 if (v->ob_type->tp_as_number &&
1176 v->ob_type->tp_as_number->nb_inplace_power != NULL) {
1177 return ternary_op(v, w, z, NB_SLOT(nb_inplace_power), "**=");
1178 }
1179 else {
1180 return ternary_op(v, w, z, NB_SLOT(nb_power), "**=");
1181 }
1182 }
1183
1184
1185 /* Unary operators and functions */
1186
1187 PyObject *
PyNumber_Negative(PyObject * o)1188 PyNumber_Negative(PyObject *o)
1189 {
1190 PyNumberMethods *m;
1191
1192 if (o == NULL) {
1193 return null_error();
1194 }
1195
1196 m = o->ob_type->tp_as_number;
1197 if (m && m->nb_negative)
1198 return (*m->nb_negative)(o);
1199
1200 return type_error("bad operand type for unary -: '%.200s'", o);
1201 }
1202
1203 PyObject *
PyNumber_Positive(PyObject * o)1204 PyNumber_Positive(PyObject *o)
1205 {
1206 PyNumberMethods *m;
1207
1208 if (o == NULL) {
1209 return null_error();
1210 }
1211
1212 m = o->ob_type->tp_as_number;
1213 if (m && m->nb_positive)
1214 return (*m->nb_positive)(o);
1215
1216 return type_error("bad operand type for unary +: '%.200s'", o);
1217 }
1218
1219 PyObject *
PyNumber_Invert(PyObject * o)1220 PyNumber_Invert(PyObject *o)
1221 {
1222 PyNumberMethods *m;
1223
1224 if (o == NULL) {
1225 return null_error();
1226 }
1227
1228 m = o->ob_type->tp_as_number;
1229 if (m && m->nb_invert)
1230 return (*m->nb_invert)(o);
1231
1232 return type_error("bad operand type for unary ~: '%.200s'", o);
1233 }
1234
1235 PyObject *
PyNumber_Absolute(PyObject * o)1236 PyNumber_Absolute(PyObject *o)
1237 {
1238 PyNumberMethods *m;
1239
1240 if (o == NULL) {
1241 return null_error();
1242 }
1243
1244 m = o->ob_type->tp_as_number;
1245 if (m && m->nb_absolute)
1246 return m->nb_absolute(o);
1247
1248 return type_error("bad operand type for abs(): '%.200s'", o);
1249 }
1250
1251 #undef PyIndex_Check
1252
1253 int
PyIndex_Check(PyObject * obj)1254 PyIndex_Check(PyObject *obj)
1255 {
1256 return obj->ob_type->tp_as_number != NULL &&
1257 obj->ob_type->tp_as_number->nb_index != NULL;
1258 }
1259
1260 /* Return a Python int from the object item.
1261 Raise TypeError if the result is not an int
1262 or if the object cannot be interpreted as an index.
1263 */
1264 PyObject *
PyNumber_Index(PyObject * item)1265 PyNumber_Index(PyObject *item)
1266 {
1267 PyObject *result = NULL;
1268 if (item == NULL) {
1269 return null_error();
1270 }
1271
1272 if (PyLong_Check(item)) {
1273 Py_INCREF(item);
1274 return item;
1275 }
1276 if (!PyIndex_Check(item)) {
1277 PyErr_Format(PyExc_TypeError,
1278 "'%.200s' object cannot be interpreted "
1279 "as an integer", item->ob_type->tp_name);
1280 return NULL;
1281 }
1282 result = item->ob_type->tp_as_number->nb_index(item);
1283 if (!result || PyLong_CheckExact(result))
1284 return result;
1285 if (!PyLong_Check(result)) {
1286 PyErr_Format(PyExc_TypeError,
1287 "__index__ returned non-int (type %.200s)",
1288 result->ob_type->tp_name);
1289 Py_DECREF(result);
1290 return NULL;
1291 }
1292 /* Issue #17576: warn if 'result' not of exact type int. */
1293 if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
1294 "__index__ returned non-int (type %.200s). "
1295 "The ability to return an instance of a strict subclass of int "
1296 "is deprecated, and may be removed in a future version of Python.",
1297 result->ob_type->tp_name)) {
1298 Py_DECREF(result);
1299 return NULL;
1300 }
1301 return result;
1302 }
1303
1304 /* Return an error on Overflow only if err is not NULL*/
1305
1306 Py_ssize_t
PyNumber_AsSsize_t(PyObject * item,PyObject * err)1307 PyNumber_AsSsize_t(PyObject *item, PyObject *err)
1308 {
1309 Py_ssize_t result;
1310 PyObject *runerr;
1311 PyObject *value = PyNumber_Index(item);
1312 if (value == NULL)
1313 return -1;
1314
1315 /* We're done if PyLong_AsSsize_t() returns without error. */
1316 result = PyLong_AsSsize_t(value);
1317 if (result != -1 || !(runerr = PyErr_Occurred()))
1318 goto finish;
1319
1320 /* Error handling code -- only manage OverflowError differently */
1321 if (!PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError))
1322 goto finish;
1323
1324 PyErr_Clear();
1325 /* If no error-handling desired then the default clipping
1326 is sufficient.
1327 */
1328 if (!err) {
1329 assert(PyLong_Check(value));
1330 /* Whether or not it is less than or equal to
1331 zero is determined by the sign of ob_size
1332 */
1333 if (_PyLong_Sign(value) < 0)
1334 result = PY_SSIZE_T_MIN;
1335 else
1336 result = PY_SSIZE_T_MAX;
1337 }
1338 else {
1339 /* Otherwise replace the error with caller's error object. */
1340 PyErr_Format(err,
1341 "cannot fit '%.200s' into an index-sized integer",
1342 item->ob_type->tp_name);
1343 }
1344
1345 finish:
1346 Py_DECREF(value);
1347 return result;
1348 }
1349
1350
1351 PyObject *
PyNumber_Long(PyObject * o)1352 PyNumber_Long(PyObject *o)
1353 {
1354 PyObject *result;
1355 PyNumberMethods *m;
1356 PyObject *trunc_func;
1357 Py_buffer view;
1358 _Py_IDENTIFIER(__trunc__);
1359
1360 if (o == NULL) {
1361 return null_error();
1362 }
1363
1364 if (PyLong_CheckExact(o)) {
1365 Py_INCREF(o);
1366 return o;
1367 }
1368 m = o->ob_type->tp_as_number;
1369 if (m && m->nb_int) { /* This should include subclasses of int */
1370 result = _PyLong_FromNbInt(o);
1371 if (result != NULL && !PyLong_CheckExact(result)) {
1372 Py_SETREF(result, _PyLong_Copy((PyLongObject *)result));
1373 }
1374 return result;
1375 }
1376 if (m && m->nb_index) {
1377 result = _PyLong_FromNbIndexOrNbInt(o);
1378 if (result != NULL && !PyLong_CheckExact(result)) {
1379 Py_SETREF(result, _PyLong_Copy((PyLongObject *)result));
1380 }
1381 return result;
1382 }
1383 trunc_func = _PyObject_LookupSpecial(o, &PyId___trunc__);
1384 if (trunc_func) {
1385 result = _PyObject_CallNoArg(trunc_func);
1386 Py_DECREF(trunc_func);
1387 if (result == NULL || PyLong_CheckExact(result)) {
1388 return result;
1389 }
1390 if (PyLong_Check(result)) {
1391 Py_SETREF(result, _PyLong_Copy((PyLongObject *)result));
1392 return result;
1393 }
1394 /* __trunc__ is specified to return an Integral type,
1395 but int() needs to return an int. */
1396 m = result->ob_type->tp_as_number;
1397 if (m == NULL || (m->nb_index == NULL && m->nb_int == NULL)) {
1398 PyErr_Format(
1399 PyExc_TypeError,
1400 "__trunc__ returned non-Integral (type %.200s)",
1401 result->ob_type->tp_name);
1402 Py_DECREF(result);
1403 return NULL;
1404 }
1405 Py_SETREF(result, _PyLong_FromNbIndexOrNbInt(result));
1406 if (result != NULL && !PyLong_CheckExact(result)) {
1407 Py_SETREF(result, _PyLong_Copy((PyLongObject *)result));
1408 }
1409 return result;
1410 }
1411 if (PyErr_Occurred())
1412 return NULL;
1413
1414 if (PyUnicode_Check(o))
1415 /* The below check is done in PyLong_FromUnicode(). */
1416 return PyLong_FromUnicodeObject(o, 10);
1417
1418 if (PyBytes_Check(o))
1419 /* need to do extra error checking that PyLong_FromString()
1420 * doesn't do. In particular int('9\x005') must raise an
1421 * exception, not truncate at the null.
1422 */
1423 return _PyLong_FromBytes(PyBytes_AS_STRING(o),
1424 PyBytes_GET_SIZE(o), 10);
1425
1426 if (PyByteArray_Check(o))
1427 return _PyLong_FromBytes(PyByteArray_AS_STRING(o),
1428 PyByteArray_GET_SIZE(o), 10);
1429
1430 if (PyObject_GetBuffer(o, &view, PyBUF_SIMPLE) == 0) {
1431 PyObject *bytes;
1432
1433 /* Copy to NUL-terminated buffer. */
1434 bytes = PyBytes_FromStringAndSize((const char *)view.buf, view.len);
1435 if (bytes == NULL) {
1436 PyBuffer_Release(&view);
1437 return NULL;
1438 }
1439 result = _PyLong_FromBytes(PyBytes_AS_STRING(bytes),
1440 PyBytes_GET_SIZE(bytes), 10);
1441 Py_DECREF(bytes);
1442 PyBuffer_Release(&view);
1443 return result;
1444 }
1445
1446 return type_error("int() argument must be a string, a bytes-like object "
1447 "or a number, not '%.200s'", o);
1448 }
1449
1450 PyObject *
PyNumber_Float(PyObject * o)1451 PyNumber_Float(PyObject *o)
1452 {
1453 PyNumberMethods *m;
1454
1455 if (o == NULL) {
1456 return null_error();
1457 }
1458
1459 if (PyFloat_CheckExact(o)) {
1460 Py_INCREF(o);
1461 return o;
1462 }
1463 m = o->ob_type->tp_as_number;
1464 if (m && m->nb_float) { /* This should include subclasses of float */
1465 PyObject *res = m->nb_float(o);
1466 double val;
1467 if (!res || PyFloat_CheckExact(res)) {
1468 return res;
1469 }
1470 if (!PyFloat_Check(res)) {
1471 PyErr_Format(PyExc_TypeError,
1472 "%.50s.__float__ returned non-float (type %.50s)",
1473 o->ob_type->tp_name, res->ob_type->tp_name);
1474 Py_DECREF(res);
1475 return NULL;
1476 }
1477 /* Issue #26983: warn if 'res' not of exact type float. */
1478 if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
1479 "%.50s.__float__ returned non-float (type %.50s). "
1480 "The ability to return an instance of a strict subclass of float "
1481 "is deprecated, and may be removed in a future version of Python.",
1482 o->ob_type->tp_name, res->ob_type->tp_name)) {
1483 Py_DECREF(res);
1484 return NULL;
1485 }
1486 val = PyFloat_AS_DOUBLE(res);
1487 Py_DECREF(res);
1488 return PyFloat_FromDouble(val);
1489 }
1490 if (m && m->nb_index) {
1491 PyObject *res = PyNumber_Index(o);
1492 if (!res) {
1493 return NULL;
1494 }
1495 double val = PyLong_AsDouble(res);
1496 Py_DECREF(res);
1497 if (val == -1.0 && PyErr_Occurred()) {
1498 return NULL;
1499 }
1500 return PyFloat_FromDouble(val);
1501 }
1502 if (PyFloat_Check(o)) { /* A float subclass with nb_float == NULL */
1503 return PyFloat_FromDouble(PyFloat_AS_DOUBLE(o));
1504 }
1505 return PyFloat_FromString(o);
1506 }
1507
1508
1509 PyObject *
PyNumber_ToBase(PyObject * n,int base)1510 PyNumber_ToBase(PyObject *n, int base)
1511 {
1512 if (!(base == 2 || base == 8 || base == 10 || base == 16)) {
1513 PyErr_SetString(PyExc_SystemError,
1514 "PyNumber_ToBase: base must be 2, 8, 10 or 16");
1515 return NULL;
1516 }
1517 PyObject *index = PyNumber_Index(n);
1518 if (!index)
1519 return NULL;
1520 PyObject *res = _PyLong_Format(index, base);
1521 Py_DECREF(index);
1522 return res;
1523 }
1524
1525
1526 /* Operations on sequences */
1527
1528 int
PySequence_Check(PyObject * s)1529 PySequence_Check(PyObject *s)
1530 {
1531 if (PyDict_Check(s))
1532 return 0;
1533 return s->ob_type->tp_as_sequence &&
1534 s->ob_type->tp_as_sequence->sq_item != NULL;
1535 }
1536
1537 Py_ssize_t
PySequence_Size(PyObject * s)1538 PySequence_Size(PyObject *s)
1539 {
1540 PySequenceMethods *m;
1541
1542 if (s == NULL) {
1543 null_error();
1544 return -1;
1545 }
1546
1547 m = s->ob_type->tp_as_sequence;
1548 if (m && m->sq_length) {
1549 Py_ssize_t len = m->sq_length(s);
1550 assert(len >= 0 || PyErr_Occurred());
1551 return len;
1552 }
1553
1554 if (s->ob_type->tp_as_mapping && s->ob_type->tp_as_mapping->mp_length) {
1555 type_error("%.200s is not a sequence", s);
1556 return -1;
1557 }
1558 type_error("object of type '%.200s' has no len()", s);
1559 return -1;
1560 }
1561
1562 #undef PySequence_Length
1563 Py_ssize_t
PySequence_Length(PyObject * s)1564 PySequence_Length(PyObject *s)
1565 {
1566 return PySequence_Size(s);
1567 }
1568 #define PySequence_Length PySequence_Size
1569
1570 PyObject *
PySequence_Concat(PyObject * s,PyObject * o)1571 PySequence_Concat(PyObject *s, PyObject *o)
1572 {
1573 PySequenceMethods *m;
1574
1575 if (s == NULL || o == NULL) {
1576 return null_error();
1577 }
1578
1579 m = s->ob_type->tp_as_sequence;
1580 if (m && m->sq_concat)
1581 return m->sq_concat(s, o);
1582
1583 /* Instances of user classes defining an __add__() method only
1584 have an nb_add slot, not an sq_concat slot. So we fall back
1585 to nb_add if both arguments appear to be sequences. */
1586 if (PySequence_Check(s) && PySequence_Check(o)) {
1587 PyObject *result = binary_op1(s, o, NB_SLOT(nb_add));
1588 if (result != Py_NotImplemented)
1589 return result;
1590 Py_DECREF(result);
1591 }
1592 return type_error("'%.200s' object can't be concatenated", s);
1593 }
1594
1595 PyObject *
PySequence_Repeat(PyObject * o,Py_ssize_t count)1596 PySequence_Repeat(PyObject *o, Py_ssize_t count)
1597 {
1598 PySequenceMethods *m;
1599
1600 if (o == NULL) {
1601 return null_error();
1602 }
1603
1604 m = o->ob_type->tp_as_sequence;
1605 if (m && m->sq_repeat)
1606 return m->sq_repeat(o, count);
1607
1608 /* Instances of user classes defining a __mul__() method only
1609 have an nb_multiply slot, not an sq_repeat slot. so we fall back
1610 to nb_multiply if o appears to be a sequence. */
1611 if (PySequence_Check(o)) {
1612 PyObject *n, *result;
1613 n = PyLong_FromSsize_t(count);
1614 if (n == NULL)
1615 return NULL;
1616 result = binary_op1(o, n, NB_SLOT(nb_multiply));
1617 Py_DECREF(n);
1618 if (result != Py_NotImplemented)
1619 return result;
1620 Py_DECREF(result);
1621 }
1622 return type_error("'%.200s' object can't be repeated", o);
1623 }
1624
1625 PyObject *
PySequence_InPlaceConcat(PyObject * s,PyObject * o)1626 PySequence_InPlaceConcat(PyObject *s, PyObject *o)
1627 {
1628 PySequenceMethods *m;
1629
1630 if (s == NULL || o == NULL) {
1631 return null_error();
1632 }
1633
1634 m = s->ob_type->tp_as_sequence;
1635 if (m && m->sq_inplace_concat)
1636 return m->sq_inplace_concat(s, o);
1637 if (m && m->sq_concat)
1638 return m->sq_concat(s, o);
1639
1640 if (PySequence_Check(s) && PySequence_Check(o)) {
1641 PyObject *result = binary_iop1(s, o, NB_SLOT(nb_inplace_add),
1642 NB_SLOT(nb_add));
1643 if (result != Py_NotImplemented)
1644 return result;
1645 Py_DECREF(result);
1646 }
1647 return type_error("'%.200s' object can't be concatenated", s);
1648 }
1649
1650 PyObject *
PySequence_InPlaceRepeat(PyObject * o,Py_ssize_t count)1651 PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count)
1652 {
1653 PySequenceMethods *m;
1654
1655 if (o == NULL) {
1656 return null_error();
1657 }
1658
1659 m = o->ob_type->tp_as_sequence;
1660 if (m && m->sq_inplace_repeat)
1661 return m->sq_inplace_repeat(o, count);
1662 if (m && m->sq_repeat)
1663 return m->sq_repeat(o, count);
1664
1665 if (PySequence_Check(o)) {
1666 PyObject *n, *result;
1667 n = PyLong_FromSsize_t(count);
1668 if (n == NULL)
1669 return NULL;
1670 result = binary_iop1(o, n, NB_SLOT(nb_inplace_multiply),
1671 NB_SLOT(nb_multiply));
1672 Py_DECREF(n);
1673 if (result != Py_NotImplemented)
1674 return result;
1675 Py_DECREF(result);
1676 }
1677 return type_error("'%.200s' object can't be repeated", o);
1678 }
1679
1680 PyObject *
PySequence_GetItem(PyObject * s,Py_ssize_t i)1681 PySequence_GetItem(PyObject *s, Py_ssize_t i)
1682 {
1683 PySequenceMethods *m;
1684
1685 if (s == NULL) {
1686 return null_error();
1687 }
1688
1689 m = s->ob_type->tp_as_sequence;
1690 if (m && m->sq_item) {
1691 if (i < 0) {
1692 if (m->sq_length) {
1693 Py_ssize_t l = (*m->sq_length)(s);
1694 if (l < 0) {
1695 assert(PyErr_Occurred());
1696 return NULL;
1697 }
1698 i += l;
1699 }
1700 }
1701 return m->sq_item(s, i);
1702 }
1703
1704 if (s->ob_type->tp_as_mapping && s->ob_type->tp_as_mapping->mp_subscript) {
1705 return type_error("%.200s is not a sequence", s);
1706 }
1707 return type_error("'%.200s' object does not support indexing", s);
1708 }
1709
1710 PyObject *
PySequence_GetSlice(PyObject * s,Py_ssize_t i1,Py_ssize_t i2)1711 PySequence_GetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2)
1712 {
1713 PyMappingMethods *mp;
1714
1715 if (!s) {
1716 return null_error();
1717 }
1718
1719 mp = s->ob_type->tp_as_mapping;
1720 if (mp && mp->mp_subscript) {
1721 PyObject *res;
1722 PyObject *slice = _PySlice_FromIndices(i1, i2);
1723 if (!slice)
1724 return NULL;
1725 res = mp->mp_subscript(s, slice);
1726 Py_DECREF(slice);
1727 return res;
1728 }
1729
1730 return type_error("'%.200s' object is unsliceable", s);
1731 }
1732
1733 int
PySequence_SetItem(PyObject * s,Py_ssize_t i,PyObject * o)1734 PySequence_SetItem(PyObject *s, Py_ssize_t i, PyObject *o)
1735 {
1736 PySequenceMethods *m;
1737
1738 if (s == NULL) {
1739 null_error();
1740 return -1;
1741 }
1742
1743 m = s->ob_type->tp_as_sequence;
1744 if (m && m->sq_ass_item) {
1745 if (i < 0) {
1746 if (m->sq_length) {
1747 Py_ssize_t l = (*m->sq_length)(s);
1748 if (l < 0) {
1749 assert(PyErr_Occurred());
1750 return -1;
1751 }
1752 i += l;
1753 }
1754 }
1755 return m->sq_ass_item(s, i, o);
1756 }
1757
1758 if (s->ob_type->tp_as_mapping && s->ob_type->tp_as_mapping->mp_ass_subscript) {
1759 type_error("%.200s is not a sequence", s);
1760 return -1;
1761 }
1762 type_error("'%.200s' object does not support item assignment", s);
1763 return -1;
1764 }
1765
1766 int
PySequence_DelItem(PyObject * s,Py_ssize_t i)1767 PySequence_DelItem(PyObject *s, Py_ssize_t i)
1768 {
1769 PySequenceMethods *m;
1770
1771 if (s == NULL) {
1772 null_error();
1773 return -1;
1774 }
1775
1776 m = s->ob_type->tp_as_sequence;
1777 if (m && m->sq_ass_item) {
1778 if (i < 0) {
1779 if (m->sq_length) {
1780 Py_ssize_t l = (*m->sq_length)(s);
1781 if (l < 0) {
1782 assert(PyErr_Occurred());
1783 return -1;
1784 }
1785 i += l;
1786 }
1787 }
1788 return m->sq_ass_item(s, i, (PyObject *)NULL);
1789 }
1790
1791 if (s->ob_type->tp_as_mapping && s->ob_type->tp_as_mapping->mp_ass_subscript) {
1792 type_error("%.200s is not a sequence", s);
1793 return -1;
1794 }
1795 type_error("'%.200s' object doesn't support item deletion", s);
1796 return -1;
1797 }
1798
1799 int
PySequence_SetSlice(PyObject * s,Py_ssize_t i1,Py_ssize_t i2,PyObject * o)1800 PySequence_SetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2, PyObject *o)
1801 {
1802 PyMappingMethods *mp;
1803
1804 if (s == NULL) {
1805 null_error();
1806 return -1;
1807 }
1808
1809 mp = s->ob_type->tp_as_mapping;
1810 if (mp && mp->mp_ass_subscript) {
1811 int res;
1812 PyObject *slice = _PySlice_FromIndices(i1, i2);
1813 if (!slice)
1814 return -1;
1815 res = mp->mp_ass_subscript(s, slice, o);
1816 Py_DECREF(slice);
1817 return res;
1818 }
1819
1820 type_error("'%.200s' object doesn't support slice assignment", s);
1821 return -1;
1822 }
1823
1824 int
PySequence_DelSlice(PyObject * s,Py_ssize_t i1,Py_ssize_t i2)1825 PySequence_DelSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2)
1826 {
1827 PyMappingMethods *mp;
1828
1829 if (s == NULL) {
1830 null_error();
1831 return -1;
1832 }
1833
1834 mp = s->ob_type->tp_as_mapping;
1835 if (mp && mp->mp_ass_subscript) {
1836 int res;
1837 PyObject *slice = _PySlice_FromIndices(i1, i2);
1838 if (!slice)
1839 return -1;
1840 res = mp->mp_ass_subscript(s, slice, NULL);
1841 Py_DECREF(slice);
1842 return res;
1843 }
1844 type_error("'%.200s' object doesn't support slice deletion", s);
1845 return -1;
1846 }
1847
1848 PyObject *
PySequence_Tuple(PyObject * v)1849 PySequence_Tuple(PyObject *v)
1850 {
1851 PyObject *it; /* iter(v) */
1852 Py_ssize_t n; /* guess for result tuple size */
1853 PyObject *result = NULL;
1854 Py_ssize_t j;
1855
1856 if (v == NULL) {
1857 return null_error();
1858 }
1859
1860 /* Special-case the common tuple and list cases, for efficiency. */
1861 if (PyTuple_CheckExact(v)) {
1862 /* Note that we can't know whether it's safe to return
1863 a tuple *subclass* instance as-is, hence the restriction
1864 to exact tuples here. In contrast, lists always make
1865 a copy, so there's no need for exactness below. */
1866 Py_INCREF(v);
1867 return v;
1868 }
1869 if (PyList_CheckExact(v))
1870 return PyList_AsTuple(v);
1871
1872 /* Get iterator. */
1873 it = PyObject_GetIter(v);
1874 if (it == NULL)
1875 return NULL;
1876
1877 /* Guess result size and allocate space. */
1878 n = PyObject_LengthHint(v, 10);
1879 if (n == -1)
1880 goto Fail;
1881 result = PyTuple_New(n);
1882 if (result == NULL)
1883 goto Fail;
1884
1885 /* Fill the tuple. */
1886 for (j = 0; ; ++j) {
1887 PyObject *item = PyIter_Next(it);
1888 if (item == NULL) {
1889 if (PyErr_Occurred())
1890 goto Fail;
1891 break;
1892 }
1893 if (j >= n) {
1894 size_t newn = (size_t)n;
1895 /* The over-allocation strategy can grow a bit faster
1896 than for lists because unlike lists the
1897 over-allocation isn't permanent -- we reclaim
1898 the excess before the end of this routine.
1899 So, grow by ten and then add 25%.
1900 */
1901 newn += 10u;
1902 newn += newn >> 2;
1903 if (newn > PY_SSIZE_T_MAX) {
1904 /* Check for overflow */
1905 PyErr_NoMemory();
1906 Py_DECREF(item);
1907 goto Fail;
1908 }
1909 n = (Py_ssize_t)newn;
1910 if (_PyTuple_Resize(&result, n) != 0) {
1911 Py_DECREF(item);
1912 goto Fail;
1913 }
1914 }
1915 PyTuple_SET_ITEM(result, j, item);
1916 }
1917
1918 /* Cut tuple back if guess was too large. */
1919 if (j < n &&
1920 _PyTuple_Resize(&result, j) != 0)
1921 goto Fail;
1922
1923 Py_DECREF(it);
1924 return result;
1925
1926 Fail:
1927 Py_XDECREF(result);
1928 Py_DECREF(it);
1929 return NULL;
1930 }
1931
1932 PyObject *
PySequence_List(PyObject * v)1933 PySequence_List(PyObject *v)
1934 {
1935 PyObject *result; /* result list */
1936 PyObject *rv; /* return value from PyList_Extend */
1937
1938 if (v == NULL) {
1939 return null_error();
1940 }
1941
1942 result = PyList_New(0);
1943 if (result == NULL)
1944 return NULL;
1945
1946 rv = _PyList_Extend((PyListObject *)result, v);
1947 if (rv == NULL) {
1948 Py_DECREF(result);
1949 return NULL;
1950 }
1951 Py_DECREF(rv);
1952 return result;
1953 }
1954
1955 PyObject *
PySequence_Fast(PyObject * v,const char * m)1956 PySequence_Fast(PyObject *v, const char *m)
1957 {
1958 PyObject *it;
1959
1960 if (v == NULL) {
1961 return null_error();
1962 }
1963
1964 if (PyList_CheckExact(v) || PyTuple_CheckExact(v)) {
1965 Py_INCREF(v);
1966 return v;
1967 }
1968
1969 it = PyObject_GetIter(v);
1970 if (it == NULL) {
1971 if (PyErr_ExceptionMatches(PyExc_TypeError))
1972 PyErr_SetString(PyExc_TypeError, m);
1973 return NULL;
1974 }
1975
1976 v = PySequence_List(it);
1977 Py_DECREF(it);
1978
1979 return v;
1980 }
1981
1982 /* Iterate over seq. Result depends on the operation:
1983 PY_ITERSEARCH_COUNT: -1 if error, else # of times obj appears in seq.
1984 PY_ITERSEARCH_INDEX: 0-based index of first occurrence of obj in seq;
1985 set ValueError and return -1 if none found; also return -1 on error.
1986 Py_ITERSEARCH_CONTAINS: return 1 if obj in seq, else 0; -1 on error.
1987 */
1988 Py_ssize_t
_PySequence_IterSearch(PyObject * seq,PyObject * obj,int operation)1989 _PySequence_IterSearch(PyObject *seq, PyObject *obj, int operation)
1990 {
1991 Py_ssize_t n;
1992 int wrapped; /* for PY_ITERSEARCH_INDEX, true iff n wrapped around */
1993 PyObject *it; /* iter(seq) */
1994
1995 if (seq == NULL || obj == NULL) {
1996 null_error();
1997 return -1;
1998 }
1999
2000 it = PyObject_GetIter(seq);
2001 if (it == NULL) {
2002 if (PyErr_ExceptionMatches(PyExc_TypeError)) {
2003 type_error("argument of type '%.200s' is not iterable", seq);
2004 }
2005 return -1;
2006 }
2007
2008 n = wrapped = 0;
2009 for (;;) {
2010 int cmp;
2011 PyObject *item = PyIter_Next(it);
2012 if (item == NULL) {
2013 if (PyErr_Occurred())
2014 goto Fail;
2015 break;
2016 }
2017
2018 cmp = PyObject_RichCompareBool(obj, item, Py_EQ);
2019 Py_DECREF(item);
2020 if (cmp < 0)
2021 goto Fail;
2022 if (cmp > 0) {
2023 switch (operation) {
2024 case PY_ITERSEARCH_COUNT:
2025 if (n == PY_SSIZE_T_MAX) {
2026 PyErr_SetString(PyExc_OverflowError,
2027 "count exceeds C integer size");
2028 goto Fail;
2029 }
2030 ++n;
2031 break;
2032
2033 case PY_ITERSEARCH_INDEX:
2034 if (wrapped) {
2035 PyErr_SetString(PyExc_OverflowError,
2036 "index exceeds C integer size");
2037 goto Fail;
2038 }
2039 goto Done;
2040
2041 case PY_ITERSEARCH_CONTAINS:
2042 n = 1;
2043 goto Done;
2044
2045 default:
2046 Py_UNREACHABLE();
2047 }
2048 }
2049
2050 if (operation == PY_ITERSEARCH_INDEX) {
2051 if (n == PY_SSIZE_T_MAX)
2052 wrapped = 1;
2053 ++n;
2054 }
2055 }
2056
2057 if (operation != PY_ITERSEARCH_INDEX)
2058 goto Done;
2059
2060 PyErr_SetString(PyExc_ValueError,
2061 "sequence.index(x): x not in sequence");
2062 /* fall into failure code */
2063 Fail:
2064 n = -1;
2065 /* fall through */
2066 Done:
2067 Py_DECREF(it);
2068 return n;
2069
2070 }
2071
2072 /* Return # of times o appears in s. */
2073 Py_ssize_t
PySequence_Count(PyObject * s,PyObject * o)2074 PySequence_Count(PyObject *s, PyObject *o)
2075 {
2076 return _PySequence_IterSearch(s, o, PY_ITERSEARCH_COUNT);
2077 }
2078
2079 /* Return -1 if error; 1 if ob in seq; 0 if ob not in seq.
2080 * Use sq_contains if possible, else defer to _PySequence_IterSearch().
2081 */
2082 int
PySequence_Contains(PyObject * seq,PyObject * ob)2083 PySequence_Contains(PyObject *seq, PyObject *ob)
2084 {
2085 Py_ssize_t result;
2086 PySequenceMethods *sqm = seq->ob_type->tp_as_sequence;
2087 if (sqm != NULL && sqm->sq_contains != NULL)
2088 return (*sqm->sq_contains)(seq, ob);
2089 result = _PySequence_IterSearch(seq, ob, PY_ITERSEARCH_CONTAINS);
2090 return Py_SAFE_DOWNCAST(result, Py_ssize_t, int);
2091 }
2092
2093 /* Backwards compatibility */
2094 #undef PySequence_In
2095 int
PySequence_In(PyObject * w,PyObject * v)2096 PySequence_In(PyObject *w, PyObject *v)
2097 {
2098 return PySequence_Contains(w, v);
2099 }
2100
2101 Py_ssize_t
PySequence_Index(PyObject * s,PyObject * o)2102 PySequence_Index(PyObject *s, PyObject *o)
2103 {
2104 return _PySequence_IterSearch(s, o, PY_ITERSEARCH_INDEX);
2105 }
2106
2107 /* Operations on mappings */
2108
2109 int
PyMapping_Check(PyObject * o)2110 PyMapping_Check(PyObject *o)
2111 {
2112 return o && o->ob_type->tp_as_mapping &&
2113 o->ob_type->tp_as_mapping->mp_subscript;
2114 }
2115
2116 Py_ssize_t
PyMapping_Size(PyObject * o)2117 PyMapping_Size(PyObject *o)
2118 {
2119 PyMappingMethods *m;
2120
2121 if (o == NULL) {
2122 null_error();
2123 return -1;
2124 }
2125
2126 m = o->ob_type->tp_as_mapping;
2127 if (m && m->mp_length) {
2128 Py_ssize_t len = m->mp_length(o);
2129 assert(len >= 0 || PyErr_Occurred());
2130 return len;
2131 }
2132
2133 if (o->ob_type->tp_as_sequence && o->ob_type->tp_as_sequence->sq_length) {
2134 type_error("%.200s is not a mapping", o);
2135 return -1;
2136 }
2137 /* PyMapping_Size() can be called from PyObject_Size(). */
2138 type_error("object of type '%.200s' has no len()", o);
2139 return -1;
2140 }
2141
2142 #undef PyMapping_Length
2143 Py_ssize_t
PyMapping_Length(PyObject * o)2144 PyMapping_Length(PyObject *o)
2145 {
2146 return PyMapping_Size(o);
2147 }
2148 #define PyMapping_Length PyMapping_Size
2149
2150 PyObject *
PyMapping_GetItemString(PyObject * o,const char * key)2151 PyMapping_GetItemString(PyObject *o, const char *key)
2152 {
2153 PyObject *okey, *r;
2154
2155 if (key == NULL) {
2156 return null_error();
2157 }
2158
2159 okey = PyUnicode_FromString(key);
2160 if (okey == NULL)
2161 return NULL;
2162 r = PyObject_GetItem(o, okey);
2163 Py_DECREF(okey);
2164 return r;
2165 }
2166
2167 int
PyMapping_SetItemString(PyObject * o,const char * key,PyObject * value)2168 PyMapping_SetItemString(PyObject *o, const char *key, PyObject *value)
2169 {
2170 PyObject *okey;
2171 int r;
2172
2173 if (key == NULL) {
2174 null_error();
2175 return -1;
2176 }
2177
2178 okey = PyUnicode_FromString(key);
2179 if (okey == NULL)
2180 return -1;
2181 r = PyObject_SetItem(o, okey, value);
2182 Py_DECREF(okey);
2183 return r;
2184 }
2185
2186 int
PyMapping_HasKeyString(PyObject * o,const char * key)2187 PyMapping_HasKeyString(PyObject *o, const char *key)
2188 {
2189 PyObject *v;
2190
2191 v = PyMapping_GetItemString(o, key);
2192 if (v) {
2193 Py_DECREF(v);
2194 return 1;
2195 }
2196 PyErr_Clear();
2197 return 0;
2198 }
2199
2200 int
PyMapping_HasKey(PyObject * o,PyObject * key)2201 PyMapping_HasKey(PyObject *o, PyObject *key)
2202 {
2203 PyObject *v;
2204
2205 v = PyObject_GetItem(o, key);
2206 if (v) {
2207 Py_DECREF(v);
2208 return 1;
2209 }
2210 PyErr_Clear();
2211 return 0;
2212 }
2213
2214 /* This function is quite similar to PySequence_Fast(), but specialized to be
2215 a helper for PyMapping_Keys(), PyMapping_Items() and PyMapping_Values().
2216 */
2217 static PyObject *
method_output_as_list(PyObject * o,_Py_Identifier * meth_id)2218 method_output_as_list(PyObject *o, _Py_Identifier *meth_id)
2219 {
2220 PyObject *it, *result, *meth_output;
2221
2222 assert(o != NULL);
2223 meth_output = _PyObject_CallMethodId(o, meth_id, NULL);
2224 if (meth_output == NULL || PyList_CheckExact(meth_output)) {
2225 return meth_output;
2226 }
2227 it = PyObject_GetIter(meth_output);
2228 if (it == NULL) {
2229 if (PyErr_ExceptionMatches(PyExc_TypeError)) {
2230 PyErr_Format(PyExc_TypeError,
2231 "%.200s.%U() returned a non-iterable (type %.200s)",
2232 Py_TYPE(o)->tp_name,
2233 meth_id->object,
2234 Py_TYPE(meth_output)->tp_name);
2235 }
2236 Py_DECREF(meth_output);
2237 return NULL;
2238 }
2239 Py_DECREF(meth_output);
2240 result = PySequence_List(it);
2241 Py_DECREF(it);
2242 return result;
2243 }
2244
2245 PyObject *
PyMapping_Keys(PyObject * o)2246 PyMapping_Keys(PyObject *o)
2247 {
2248 _Py_IDENTIFIER(keys);
2249
2250 if (o == NULL) {
2251 return null_error();
2252 }
2253 if (PyDict_CheckExact(o)) {
2254 return PyDict_Keys(o);
2255 }
2256 return method_output_as_list(o, &PyId_keys);
2257 }
2258
2259 PyObject *
PyMapping_Items(PyObject * o)2260 PyMapping_Items(PyObject *o)
2261 {
2262 _Py_IDENTIFIER(items);
2263
2264 if (o == NULL) {
2265 return null_error();
2266 }
2267 if (PyDict_CheckExact(o)) {
2268 return PyDict_Items(o);
2269 }
2270 return method_output_as_list(o, &PyId_items);
2271 }
2272
2273 PyObject *
PyMapping_Values(PyObject * o)2274 PyMapping_Values(PyObject *o)
2275 {
2276 _Py_IDENTIFIER(values);
2277
2278 if (o == NULL) {
2279 return null_error();
2280 }
2281 if (PyDict_CheckExact(o)) {
2282 return PyDict_Values(o);
2283 }
2284 return method_output_as_list(o, &PyId_values);
2285 }
2286
2287 /* isinstance(), issubclass() */
2288
2289 /* abstract_get_bases() has logically 4 return states:
2290 *
2291 * 1. getattr(cls, '__bases__') could raise an AttributeError
2292 * 2. getattr(cls, '__bases__') could raise some other exception
2293 * 3. getattr(cls, '__bases__') could return a tuple
2294 * 4. getattr(cls, '__bases__') could return something other than a tuple
2295 *
2296 * Only state #3 is a non-error state and only it returns a non-NULL object
2297 * (it returns the retrieved tuple).
2298 *
2299 * Any raised AttributeErrors are masked by clearing the exception and
2300 * returning NULL. If an object other than a tuple comes out of __bases__,
2301 * then again, the return value is NULL. So yes, these two situations
2302 * produce exactly the same results: NULL is returned and no error is set.
2303 *
2304 * If some exception other than AttributeError is raised, then NULL is also
2305 * returned, but the exception is not cleared. That's because we want the
2306 * exception to be propagated along.
2307 *
2308 * Callers are expected to test for PyErr_Occurred() when the return value
2309 * is NULL to decide whether a valid exception should be propagated or not.
2310 * When there's no exception to propagate, it's customary for the caller to
2311 * set a TypeError.
2312 */
2313 static PyObject *
abstract_get_bases(PyObject * cls)2314 abstract_get_bases(PyObject *cls)
2315 {
2316 _Py_IDENTIFIER(__bases__);
2317 PyObject *bases;
2318
2319 (void)_PyObject_LookupAttrId(cls, &PyId___bases__, &bases);
2320 if (bases != NULL && !PyTuple_Check(bases)) {
2321 Py_DECREF(bases);
2322 return NULL;
2323 }
2324 return bases;
2325 }
2326
2327
2328 static int
abstract_issubclass(PyObject * derived,PyObject * cls)2329 abstract_issubclass(PyObject *derived, PyObject *cls)
2330 {
2331 PyObject *bases = NULL;
2332 Py_ssize_t i, n;
2333 int r = 0;
2334
2335 while (1) {
2336 if (derived == cls) {
2337 Py_XDECREF(bases); /* See below comment */
2338 return 1;
2339 }
2340 /* Use XSETREF to drop bases reference *after* finishing with
2341 derived; bases might be the only reference to it.
2342 XSETREF is used instead of SETREF, because bases is NULL on the
2343 first iteration of the loop.
2344 */
2345 Py_XSETREF(bases, abstract_get_bases(derived));
2346 if (bases == NULL) {
2347 if (PyErr_Occurred())
2348 return -1;
2349 return 0;
2350 }
2351 n = PyTuple_GET_SIZE(bases);
2352 if (n == 0) {
2353 Py_DECREF(bases);
2354 return 0;
2355 }
2356 /* Avoid recursivity in the single inheritance case */
2357 if (n == 1) {
2358 derived = PyTuple_GET_ITEM(bases, 0);
2359 continue;
2360 }
2361 for (i = 0; i < n; i++) {
2362 r = abstract_issubclass(PyTuple_GET_ITEM(bases, i), cls);
2363 if (r != 0)
2364 break;
2365 }
2366 Py_DECREF(bases);
2367 return r;
2368 }
2369 }
2370
2371 static int
check_class(PyObject * cls,const char * error)2372 check_class(PyObject *cls, const char *error)
2373 {
2374 PyObject *bases = abstract_get_bases(cls);
2375 if (bases == NULL) {
2376 /* Do not mask errors. */
2377 if (!PyErr_Occurred())
2378 PyErr_SetString(PyExc_TypeError, error);
2379 return 0;
2380 }
2381 Py_DECREF(bases);
2382 return -1;
2383 }
2384
2385 static int
recursive_isinstance(PyObject * inst,PyObject * cls)2386 recursive_isinstance(PyObject *inst, PyObject *cls)
2387 {
2388 PyObject *icls;
2389 int retval;
2390 _Py_IDENTIFIER(__class__);
2391
2392 if (PyType_Check(cls)) {
2393 retval = PyObject_TypeCheck(inst, (PyTypeObject *)cls);
2394 if (retval == 0) {
2395 retval = _PyObject_LookupAttrId(inst, &PyId___class__, &icls);
2396 if (icls != NULL) {
2397 if (icls != (PyObject *)(inst->ob_type) && PyType_Check(icls)) {
2398 retval = PyType_IsSubtype(
2399 (PyTypeObject *)icls,
2400 (PyTypeObject *)cls);
2401 }
2402 else {
2403 retval = 0;
2404 }
2405 Py_DECREF(icls);
2406 }
2407 }
2408 }
2409 else {
2410 if (!check_class(cls,
2411 "isinstance() arg 2 must be a type or tuple of types"))
2412 return -1;
2413 retval = _PyObject_LookupAttrId(inst, &PyId___class__, &icls);
2414 if (icls != NULL) {
2415 retval = abstract_issubclass(icls, cls);
2416 Py_DECREF(icls);
2417 }
2418 }
2419
2420 return retval;
2421 }
2422
2423 int
PyObject_IsInstance(PyObject * inst,PyObject * cls)2424 PyObject_IsInstance(PyObject *inst, PyObject *cls)
2425 {
2426 _Py_IDENTIFIER(__instancecheck__);
2427 PyObject *checker;
2428
2429 /* Quick test for an exact match */
2430 if (Py_TYPE(inst) == (PyTypeObject *)cls)
2431 return 1;
2432
2433 /* We know what type's __instancecheck__ does. */
2434 if (PyType_CheckExact(cls)) {
2435 return recursive_isinstance(inst, cls);
2436 }
2437
2438 if (PyTuple_Check(cls)) {
2439 Py_ssize_t i;
2440 Py_ssize_t n;
2441 int r = 0;
2442
2443 if (Py_EnterRecursiveCall(" in __instancecheck__"))
2444 return -1;
2445 n = PyTuple_GET_SIZE(cls);
2446 for (i = 0; i < n; ++i) {
2447 PyObject *item = PyTuple_GET_ITEM(cls, i);
2448 r = PyObject_IsInstance(inst, item);
2449 if (r != 0)
2450 /* either found it, or got an error */
2451 break;
2452 }
2453 Py_LeaveRecursiveCall();
2454 return r;
2455 }
2456
2457 checker = _PyObject_LookupSpecial(cls, &PyId___instancecheck__);
2458 if (checker != NULL) {
2459 PyObject *res;
2460 int ok = -1;
2461 if (Py_EnterRecursiveCall(" in __instancecheck__")) {
2462 Py_DECREF(checker);
2463 return ok;
2464 }
2465 res = PyObject_CallFunctionObjArgs(checker, inst, NULL);
2466 Py_LeaveRecursiveCall();
2467 Py_DECREF(checker);
2468 if (res != NULL) {
2469 ok = PyObject_IsTrue(res);
2470 Py_DECREF(res);
2471 }
2472 return ok;
2473 }
2474 else if (PyErr_Occurred())
2475 return -1;
2476 /* Probably never reached anymore. */
2477 return recursive_isinstance(inst, cls);
2478 }
2479
2480 static int
recursive_issubclass(PyObject * derived,PyObject * cls)2481 recursive_issubclass(PyObject *derived, PyObject *cls)
2482 {
2483 if (PyType_Check(cls) && PyType_Check(derived)) {
2484 /* Fast path (non-recursive) */
2485 return PyType_IsSubtype((PyTypeObject *)derived, (PyTypeObject *)cls);
2486 }
2487 if (!check_class(derived,
2488 "issubclass() arg 1 must be a class"))
2489 return -1;
2490 if (!check_class(cls,
2491 "issubclass() arg 2 must be a class"
2492 " or tuple of classes"))
2493 return -1;
2494
2495 return abstract_issubclass(derived, cls);
2496 }
2497
2498 int
PyObject_IsSubclass(PyObject * derived,PyObject * cls)2499 PyObject_IsSubclass(PyObject *derived, PyObject *cls)
2500 {
2501 _Py_IDENTIFIER(__subclasscheck__);
2502 PyObject *checker;
2503
2504 /* We know what type's __subclasscheck__ does. */
2505 if (PyType_CheckExact(cls)) {
2506 /* Quick test for an exact match */
2507 if (derived == cls)
2508 return 1;
2509 return recursive_issubclass(derived, cls);
2510 }
2511
2512 if (PyTuple_Check(cls)) {
2513 Py_ssize_t i;
2514 Py_ssize_t n;
2515 int r = 0;
2516
2517 if (Py_EnterRecursiveCall(" in __subclasscheck__"))
2518 return -1;
2519 n = PyTuple_GET_SIZE(cls);
2520 for (i = 0; i < n; ++i) {
2521 PyObject *item = PyTuple_GET_ITEM(cls, i);
2522 r = PyObject_IsSubclass(derived, item);
2523 if (r != 0)
2524 /* either found it, or got an error */
2525 break;
2526 }
2527 Py_LeaveRecursiveCall();
2528 return r;
2529 }
2530
2531 checker = _PyObject_LookupSpecial(cls, &PyId___subclasscheck__);
2532 if (checker != NULL) {
2533 PyObject *res;
2534 int ok = -1;
2535 if (Py_EnterRecursiveCall(" in __subclasscheck__")) {
2536 Py_DECREF(checker);
2537 return ok;
2538 }
2539 res = PyObject_CallFunctionObjArgs(checker, derived, NULL);
2540 Py_LeaveRecursiveCall();
2541 Py_DECREF(checker);
2542 if (res != NULL) {
2543 ok = PyObject_IsTrue(res);
2544 Py_DECREF(res);
2545 }
2546 return ok;
2547 }
2548 else if (PyErr_Occurred())
2549 return -1;
2550 /* Probably never reached anymore. */
2551 return recursive_issubclass(derived, cls);
2552 }
2553
2554 int
_PyObject_RealIsInstance(PyObject * inst,PyObject * cls)2555 _PyObject_RealIsInstance(PyObject *inst, PyObject *cls)
2556 {
2557 return recursive_isinstance(inst, cls);
2558 }
2559
2560 int
_PyObject_RealIsSubclass(PyObject * derived,PyObject * cls)2561 _PyObject_RealIsSubclass(PyObject *derived, PyObject *cls)
2562 {
2563 return recursive_issubclass(derived, cls);
2564 }
2565
2566
2567 PyObject *
PyObject_GetIter(PyObject * o)2568 PyObject_GetIter(PyObject *o)
2569 {
2570 PyTypeObject *t = o->ob_type;
2571 getiterfunc f;
2572
2573 f = t->tp_iter;
2574 if (f == NULL) {
2575 if (PySequence_Check(o))
2576 return PySeqIter_New(o);
2577 return type_error("'%.200s' object is not iterable", o);
2578 }
2579 else {
2580 PyObject *res = (*f)(o);
2581 if (res != NULL && !PyIter_Check(res)) {
2582 PyErr_Format(PyExc_TypeError,
2583 "iter() returned non-iterator "
2584 "of type '%.100s'",
2585 res->ob_type->tp_name);
2586 Py_DECREF(res);
2587 res = NULL;
2588 }
2589 return res;
2590 }
2591 }
2592
2593 #undef PyIter_Check
2594
PyIter_Check(PyObject * obj)2595 int PyIter_Check(PyObject *obj)
2596 {
2597 return obj->ob_type->tp_iternext != NULL &&
2598 obj->ob_type->tp_iternext != &_PyObject_NextNotImplemented;
2599 }
2600
2601 /* Return next item.
2602 * If an error occurs, return NULL. PyErr_Occurred() will be true.
2603 * If the iteration terminates normally, return NULL and clear the
2604 * PyExc_StopIteration exception (if it was set). PyErr_Occurred()
2605 * will be false.
2606 * Else return the next object. PyErr_Occurred() will be false.
2607 */
2608 PyObject *
PyIter_Next(PyObject * iter)2609 PyIter_Next(PyObject *iter)
2610 {
2611 PyObject *result;
2612 result = (*iter->ob_type->tp_iternext)(iter);
2613 if (result == NULL &&
2614 PyErr_Occurred() &&
2615 PyErr_ExceptionMatches(PyExc_StopIteration))
2616 PyErr_Clear();
2617 return result;
2618 }
2619
2620
2621 /*
2622 * Flatten a sequence of bytes() objects into a C array of
2623 * NULL terminated string pointers with a NULL char* terminating the array.
2624 * (ie: an argv or env list)
2625 *
2626 * Memory allocated for the returned list is allocated using PyMem_Malloc()
2627 * and MUST be freed by _Py_FreeCharPArray().
2628 */
2629 char *const *
_PySequence_BytesToCharpArray(PyObject * self)2630 _PySequence_BytesToCharpArray(PyObject* self)
2631 {
2632 char **array;
2633 Py_ssize_t i, argc;
2634 PyObject *item = NULL;
2635 Py_ssize_t size;
2636
2637 argc = PySequence_Size(self);
2638 if (argc == -1)
2639 return NULL;
2640
2641 assert(argc >= 0);
2642
2643 if ((size_t)argc > (PY_SSIZE_T_MAX-sizeof(char *)) / sizeof(char *)) {
2644 PyErr_NoMemory();
2645 return NULL;
2646 }
2647
2648 array = PyMem_Malloc((argc + 1) * sizeof(char *));
2649 if (array == NULL) {
2650 PyErr_NoMemory();
2651 return NULL;
2652 }
2653 for (i = 0; i < argc; ++i) {
2654 char *data;
2655 item = PySequence_GetItem(self, i);
2656 if (item == NULL) {
2657 /* NULL terminate before freeing. */
2658 array[i] = NULL;
2659 goto fail;
2660 }
2661 /* check for embedded null bytes */
2662 if (PyBytes_AsStringAndSize(item, &data, NULL) < 0) {
2663 /* NULL terminate before freeing. */
2664 array[i] = NULL;
2665 goto fail;
2666 }
2667 size = PyBytes_GET_SIZE(item) + 1;
2668 array[i] = PyMem_Malloc(size);
2669 if (!array[i]) {
2670 PyErr_NoMemory();
2671 goto fail;
2672 }
2673 memcpy(array[i], data, size);
2674 Py_DECREF(item);
2675 }
2676 array[argc] = NULL;
2677
2678 return array;
2679
2680 fail:
2681 Py_XDECREF(item);
2682 _Py_FreeCharPArray(array);
2683 return NULL;
2684 }
2685
2686
2687 /* Free's a NULL terminated char** array of C strings. */
2688 void
_Py_FreeCharPArray(char * const array[])2689 _Py_FreeCharPArray(char *const array[])
2690 {
2691 Py_ssize_t i;
2692 for (i = 0; array[i] != NULL; ++i) {
2693 PyMem_Free(array[i]);
2694 }
2695 PyMem_Free((void*)array);
2696 }
2697