source: python/vendor/Python-2.6.5/Objects/abstract.c

Last change on this file was 2, checked in by Yuri Dario, 15 years ago

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