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