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