?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
move sections
[python/dscho.git] / Objects / abstract.c
blob98d2dd0078405e6f3f7681f43ce7e79ff9e59c2b
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 *
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 *
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
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 *
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
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
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
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 = PyLong_Check(ro) ? PyLong_AsSsize_t(ro) : defaultvalue;
130 Py_DECREF(ro);
131 return rv;
132 }
133
134 PyObject *
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 is not subscriptable", o);
160 }
161
162 int
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
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
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
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 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
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
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
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
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
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
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
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*
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
446 _add_one_to_index_F(int nd, Py_ssize_t *index, 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
462 _add_one_to_index_C(int nd, Py_ssize_t *index, 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
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 *, 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 /* XXX(nnorwitz): need to check for overflow! */
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 = _add_one_to_index_F;
514 }
515 else {
516 addone = _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 addone(view->ndim, indices, view->shape);
525 ptr = PyBuffer_GetPointer(view, indices);
526 memcpy(dest, ptr, view->itemsize);
527 dest += view->itemsize;
528 }
529 PyMem_Free(indices);
530 return 0;
531 }
532
533 int
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 *, 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 /* XXX(nnorwitz): need to check for overflow! */
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 = _add_one_to_index_F;
565 }
566 else {
567 addone = _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 addone(view->ndim, indices, view->shape);
576 ptr = PyBuffer_GetPointer(view, indices);
577 memcpy(ptr, src, view->itemsize);
578 src += view->itemsize;
579 }
580
581 PyMem_Free(indices);
582 return 0;
583 }
584
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 _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
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
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
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 *
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 (PyInt_Check(item) || PyLong_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 &&
1502 !PyInt_Check(result) && !PyLong_Check(result)) {
1503 PyErr_Format(PyExc_TypeError,
1504 "__index__ returned non-(int,long) " \
1505 "(type %.200s)",
1506 result->ob_type->tp_name);
1507 Py_DECREF(result);
1508 return NULL;
1509 }
1510 }
1511 else {
1512 PyErr_Format(PyExc_TypeError,
1513 "'%.200s' object cannot be interpreted "
1514 "as an index", item->ob_type->tp_name);
1515 }
1516 return result;
1517 }
1518
1519 /* Return an error on Overflow only if err is not NULL*/
1520
1521 Py_ssize_t
1522 PyNumber_AsSsize_t(PyObject *item, PyObject *err)
1523 {
1524 Py_ssize_t result;
1525 PyObject *runerr;
1526 PyObject *value = PyNumber_Index(item);
1527 if (value == NULL)
1528 return -1;
1529
1530 /* We're done if PyInt_AsSsize_t() returns without error. */
1531 result = PyInt_AsSsize_t(value);
1532 if (result != -1 || !(runerr = PyErr_Occurred()))
1533 goto finish;
1534
1535 /* Error handling code -- only manage OverflowError differently */
1536 if (!PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError))
1537 goto finish;
1538
1539 PyErr_Clear();
1540 /* If no error-handling desired then the default clipping
1541 is sufficient.
1542 */
1543 if (!err) {
1544 assert(PyLong_Check(value));
1545 /* Whether or not it is less than or equal to
1546 zero is determined by the sign of ob_size
1547 */
1548 if (_PyLong_Sign(value) < 0)
1549 result = PY_SSIZE_T_MIN;
1550 else
1551 result = PY_SSIZE_T_MAX;
1552 }
1553 else {
1554 /* Otherwise replace the error with caller's error object. */
1555 PyErr_Format(err,
1556 "cannot fit '%.200s' into an index-sized integer",
1557 item->ob_type->tp_name);
1558 }
1559
1560 finish:
1561 Py_DECREF(value);
1562 return result;
1563 }
1564
1565
1566 PyObject *
1567 _PyNumber_ConvertIntegralToInt(PyObject *integral, const char* error_format)
1568 {
1569 const char *type_name;
1570 static PyObject *int_name = NULL;
1571 if (int_name == NULL) {
1572 int_name = PyString_InternFromString("__int__");
1573 if (int_name == NULL)
1574 return NULL;
1575 }
1576
1577 if (integral && (!PyInt_Check(integral) &&
1578 !PyLong_Check(integral))) {
1579 /* Don't go through tp_as_number->nb_int to avoid
1580 hitting the classic class fallback to __trunc__. */
1581 PyObject *int_func = PyObject_GetAttr(integral, int_name);
1582 if (int_func == NULL) {
1583 PyErr_Clear(); /* Raise a different error. */
1584 goto non_integral_error;
1585 }
1586 Py_DECREF(integral);
1587 integral = PyEval_CallObject(int_func, NULL);
1588 Py_DECREF(int_func);
1589 if (integral && (!PyInt_Check(integral) &&
1590 !PyLong_Check(integral))) {
1591 goto non_integral_error;
1592 }
1593 }
1594 return integral;
1595
1596 non_integral_error:
1597 if (PyInstance_Check(integral)) {
1598 type_name = PyString_AS_STRING(((PyInstanceObject *)integral)
1599 ->in_class->cl_name);
1600 }
1601 else {
1602 type_name = integral->ob_type->tp_name;
1603 }
1604 PyErr_Format(PyExc_TypeError, error_format, type_name);
1605 Py_DECREF(integral);
1606 return NULL;
1607 }
1608
1609
1610 PyObject *
1611 PyNumber_Int(PyObject *o)
1612 {
1613 PyNumberMethods *m;
1614 static PyObject *trunc_name = NULL;
1615 PyObject *trunc_func;
1616 const char *buffer;
1617 Py_ssize_t buffer_len;
1618
1619 if (trunc_name == NULL) {
1620 trunc_name = PyString_InternFromString("__trunc__");
1621 if (trunc_name == NULL)
1622 return NULL;
1623 }
1624
1625 if (o == NULL)
1626 return null_error();
1627 if (PyInt_CheckExact(o)) {
1628 Py_INCREF(o);
1629 return o;
1630 }
1631 m = o->ob_type->tp_as_number;
1632 if (m && m->nb_int) { /* This should include subclasses of int */
1633 /* Classic classes always take this branch. */
1634 PyObject *res = m->nb_int(o);
1635 if (res && (!PyInt_Check(res) && !PyLong_Check(res))) {
1636 PyErr_Format(PyExc_TypeError,
1637 "__int__ returned non-int (type %.200s)",
1638 res->ob_type->tp_name);
1639 Py_DECREF(res);
1640 return NULL;
1641 }
1642 return res;
1643 }
1644 if (PyInt_Check(o)) { /* A int subclass without nb_int */
1645 PyIntObject *io = (PyIntObject*)o;
1646 return PyInt_FromLong(io->ob_ival);
1647 }
1648 trunc_func = PyObject_GetAttr(o, trunc_name);
1649 if (trunc_func) {
1650 PyObject *truncated = PyEval_CallObject(trunc_func, NULL);
1651 Py_DECREF(trunc_func);
1652 /* __trunc__ is specified to return an Integral type, but
1653 int() needs to return an int. */
1654 return _PyNumber_ConvertIntegralToInt(
1655 truncated,
1656 "__trunc__ returned non-Integral (type %.200s)");
1657 }
1658 PyErr_Clear(); /* It's not an error if o.__trunc__ doesn't exist. */
1659
1660 if (PyString_Check(o))
1661 return int_from_string(PyString_AS_STRING(o),
1662 PyString_GET_SIZE(o));
1663 #ifdef Py_USING_UNICODE
1664 if (PyUnicode_Check(o))
1665 return PyInt_FromUnicode(PyUnicode_AS_UNICODE(o),
1666 PyUnicode_GET_SIZE(o),
1667 10);
1668 #endif
1669 if (!PyObject_AsCharBuffer(o, &buffer, &buffer_len))
1670 return int_from_string((char*)buffer, buffer_len);
1671
1672 return type_error("int() argument must be a string or a "
1673 "number, not '%.200s'", o);
1674 }
1675
1676 /* Add a check for embedded NULL-bytes in the argument. */
1677 static PyObject *
1678 long_from_string(const char *s, Py_ssize_t len)
1679 {
1680 char *end;
1681 PyObject *x;
1682
1683 x = PyLong_FromString((char*)s, &end, 10);
1684 if (x == NULL)
1685 return NULL;
1686 if (end != s + len) {
1687 PyErr_SetString(PyExc_ValueError,
1688 "null byte in argument for long()");
1689 Py_DECREF(x);
1690 return NULL;
1691 }
1692 return x;
1693 }
1694
1695 PyObject *
1696 PyNumber_Long(PyObject *o)
1697 {
1698 PyNumberMethods *m;
1699 static PyObject *trunc_name = NULL;
1700 PyObject *trunc_func;
1701 const char *buffer;
1702 Py_ssize_t buffer_len;
1703
1704 if (trunc_name == NULL) {
1705 trunc_name = PyString_InternFromString("__trunc__");
1706 if (trunc_name == NULL)
1707 return NULL;
1708 }
1709
1710 if (o == NULL)
1711 return null_error();
1712 m = o->ob_type->tp_as_number;
1713 if (m && m->nb_long) { /* This should include subclasses of long */
1714 /* Classic classes always take this branch. */
1715 PyObject *res = m->nb_long(o);
1716 if (res && (!PyInt_Check(res) && !PyLong_Check(res))) {
1717 PyErr_Format(PyExc_TypeError,
1718 "__long__ returned non-long (type %.200s)",
1719 res->ob_type->tp_name);
1720 Py_DECREF(res);
1721 return NULL;
1722 }
1723 return res;
1724 }
1725 if (PyLong_Check(o)) /* A long subclass without nb_long */
1726 return _PyLong_Copy((PyLongObject *)o);
1727 trunc_func = PyObject_GetAttr(o, trunc_name);
1728 if (trunc_func) {
1729 PyObject *truncated = PyEval_CallObject(trunc_func, NULL);
1730 PyObject *int_instance;
1731 Py_DECREF(trunc_func);
1732 /* __trunc__ is specified to return an Integral type,
1733 but long() needs to return a long. */
1734 int_instance = _PyNumber_ConvertIntegralToInt(
1735 truncated,
1736 "__trunc__ returned non-Integral (type %.200s)");
1737 if (int_instance && PyInt_Check(int_instance)) {
1738 /* Make sure that long() returns a long instance. */
1739 long value = PyInt_AS_LONG(int_instance);
1740 Py_DECREF(int_instance);
1741 return PyLong_FromLong(value);
1742 }
1743 return int_instance;
1744 }
1745 PyErr_Clear(); /* It's not an error if o.__trunc__ doesn't exist. */
1746
1747 if (PyString_Check(o))
1748 /* need to do extra error checking that PyLong_FromString()
1749 * doesn't do. In particular long('9.5') must raise an
1750 * exception, not truncate the float.
1751 */
1752 return long_from_string(PyString_AS_STRING(o),
1753 PyString_GET_SIZE(o));
1754 #ifdef Py_USING_UNICODE
1755 if (PyUnicode_Check(o))
1756 /* The above check is done in PyLong_FromUnicode(). */
1757 return PyLong_FromUnicode(PyUnicode_AS_UNICODE(o),
1758 PyUnicode_GET_SIZE(o),
1759 10);
1760 #endif
1761 if (!PyObject_AsCharBuffer(o, &buffer, &buffer_len))
1762 return long_from_string(buffer, buffer_len);
1763
1764 return type_error("long() argument must be a string or a "
1765 "number, not '%.200s'", o);
1766 }
1767
1768 PyObject *
1769 PyNumber_Float(PyObject *o)
1770 {
1771 PyNumberMethods *m;
1772
1773 if (o == NULL)
1774 return null_error();
1775 m = o->ob_type->tp_as_number;
1776 if (m && m->nb_float) { /* This should include subclasses of float */
1777 PyObject *res = m->nb_float(o);
1778 if (res && !PyFloat_Check(res)) {
1779 PyErr_Format(PyExc_TypeError,
1780 "__float__ returned non-float (type %.200s)",
1781 res->ob_type->tp_name);
1782 Py_DECREF(res);
1783 return NULL;
1784 }
1785 return res;
1786 }
1787 if (PyFloat_Check(o)) { /* A float subclass with nb_float == NULL */
1788 PyFloatObject *po = (PyFloatObject *)o;
1789 return PyFloat_FromDouble(po->ob_fval);
1790 }
1791 return PyFloat_FromString(o, NULL);
1792 }
1793
1794 PyObject *
1795 PyNumber_ToBase(PyObject *n, int base)
1796 {
1797 PyObject *res = NULL;
1798 PyObject *index = PyNumber_Index(n);
1799
1800 if (!index)
1801 return NULL;
1802 if (PyLong_Check(index))
1803 res = _PyLong_Format(index, base, 0, 1);
1804 else if (PyInt_Check(index))
1805 res = _PyInt_Format((PyIntObject*)index, base, 1);
1806 else
1807 /* It should not be possible to get here, as
1808 PyNumber_Index already has a check for the same
1809 condition */
1810 PyErr_SetString(PyExc_ValueError, "PyNumber_ToBase: index not "
1811 "int or long");
1812 Py_DECREF(index);
1813 return res;
1814 }
1815
1816
1817 /* Operations on sequences */
1818
1819 int
1820 PySequence_Check(PyObject *s)
1821 {
1822 if (s == NULL)
1823 return 0;
1824 if (PyInstance_Check(s))
1825 return PyObject_HasAttrString(s, "__getitem__");
1826 if (PyDict_Check(s))
1827 return 0;
1828 return s->ob_type->tp_as_sequence &&
1829 s->ob_type->tp_as_sequence->sq_item != NULL;
1830 }
1831
1832 Py_ssize_t
1833 PySequence_Size(PyObject *s)
1834 {
1835 PySequenceMethods *m;
1836
1837 if (s == NULL) {
1838 null_error();
1839 return -1;
1840 }
1841
1842 m = s->ob_type->tp_as_sequence;
1843 if (m && m->sq_length)
1844 return m->sq_length(s);
1845
1846 type_error("object of type '%.200s' has no len()", s);
1847 return -1;
1848 }
1849
1850 #undef PySequence_Length
1851 Py_ssize_t
1852 PySequence_Length(PyObject *s)
1853 {
1854 return PySequence_Size(s);
1855 }
1856 #define PySequence_Length PySequence_Size
1857
1858 PyObject *
1859 PySequence_Concat(PyObject *s, PyObject *o)
1860 {
1861 PySequenceMethods *m;
1862
1863 if (s == NULL || o == NULL)
1864 return null_error();
1865
1866 m = s->ob_type->tp_as_sequence;
1867 if (m && m->sq_concat)
1868 return m->sq_concat(s, o);
1869
1870 /* Instances of user classes defining an __add__() method only
1871 have an nb_add slot, not an sq_concat slot. So we fall back
1872 to nb_add if both arguments appear to be sequences. */
1873 if (PySequence_Check(s) && PySequence_Check(o)) {
1874 PyObject *result = binary_op1(s, o, NB_SLOT(nb_add));
1875 if (result != Py_NotImplemented)
1876 return result;
1877 Py_DECREF(result);
1878 }
1879 return type_error("'%.200s' object can't be concatenated", s);
1880 }
1881
1882 PyObject *
1883 PySequence_Repeat(PyObject *o, Py_ssize_t count)
1884 {
1885 PySequenceMethods *m;
1886
1887 if (o == NULL)
1888 return null_error();
1889
1890 m = o->ob_type->tp_as_sequence;
1891 if (m && m->sq_repeat)
1892 return m->sq_repeat(o, count);
1893
1894 /* Instances of user classes defining a __mul__() method only
1895 have an nb_multiply slot, not an sq_repeat slot. so we fall back
1896 to nb_multiply if o appears to be a sequence. */
1897 if (PySequence_Check(o)) {
1898 PyObject *n, *result;
1899 n = PyInt_FromSsize_t(count);
1900 if (n == NULL)
1901 return NULL;
1902 result = binary_op1(o, n, NB_SLOT(nb_multiply));
1903 Py_DECREF(n);
1904 if (result != Py_NotImplemented)
1905 return result;
1906 Py_DECREF(result);
1907 }
1908 return type_error("'%.200s' object can't be repeated", o);
1909 }
1910
1911 PyObject *
1912 PySequence_InPlaceConcat(PyObject *s, PyObject *o)
1913 {
1914 PySequenceMethods *m;
1915
1916 if (s == NULL || o == NULL)
1917 return null_error();
1918
1919 m = s->ob_type->tp_as_sequence;
1920 if (m && HASINPLACE(s) && m->sq_inplace_concat)
1921 return m->sq_inplace_concat(s, o);
1922 if (m && m->sq_concat)
1923 return m->sq_concat(s, o);
1924
1925 if (PySequence_Check(s) && PySequence_Check(o)) {
1926 PyObject *result = binary_iop1(s, o, NB_SLOT(nb_inplace_add),
1927 NB_SLOT(nb_add));
1928 if (result != Py_NotImplemented)
1929 return result;
1930 Py_DECREF(result);
1931 }
1932 return type_error("'%.200s' object can't be concatenated", s);
1933 }
1934
1935 PyObject *
1936 PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count)
1937 {
1938 PySequenceMethods *m;
1939
1940 if (o == NULL)
1941 return null_error();
1942
1943 m = o->ob_type->tp_as_sequence;
1944 if (m && HASINPLACE(o) && m->sq_inplace_repeat)
1945 return m->sq_inplace_repeat(o, count);
1946 if (m && m->sq_repeat)
1947 return m->sq_repeat(o, count);
1948
1949 if (PySequence_Check(o)) {
1950 PyObject *n, *result;
1951 n = PyInt_FromSsize_t(count);
1952 if (n == NULL)
1953 return NULL;
1954 result = binary_iop1(o, n, NB_SLOT(nb_inplace_multiply),
1955 NB_SLOT(nb_multiply));
1956 Py_DECREF(n);
1957 if (result != Py_NotImplemented)
1958 return result;
1959 Py_DECREF(result);
1960 }
1961 return type_error("'%.200s' object can't be repeated", o);
1962 }
1963
1964 PyObject *
1965 PySequence_GetItem(PyObject *s, Py_ssize_t i)
1966 {
1967 PySequenceMethods *m;
1968
1969 if (s == NULL)
1970 return null_error();
1971
1972 m = s->ob_type->tp_as_sequence;
1973 if (m && m->sq_item) {
1974 if (i < 0) {
1975 if (m->sq_length) {
1976 Py_ssize_t l = (*m->sq_length)(s);
1977 if (l < 0)
1978 return NULL;
1979 i += l;
1980 }
1981 }
1982 return m->sq_item(s, i);
1983 }
1984
1985 return type_error("'%.200s' object does not support indexing", s);
1986 }
1987
1988 PyObject *
1989 PySequence_GetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2)
1990 {
1991 PySequenceMethods *m;
1992 PyMappingMethods *mp;
1993
1994 if (!s) return null_error();
1995
1996 m = s->ob_type->tp_as_sequence;
1997 if (m && m->sq_slice) {
1998 if (i1 < 0 || i2 < 0) {
1999 if (m->sq_length) {
2000 Py_ssize_t l = (*m->sq_length)(s);
2001 if (l < 0)
2002 return NULL;
2003 if (i1 < 0)
2004 i1 += l;
2005 if (i2 < 0)
2006 i2 += l;
2007 }
2008 }
2009 return m->sq_slice(s, i1, i2);
2010 } else if ((mp = s->ob_type->tp_as_mapping) && mp->mp_subscript) {
2011 PyObject *res;
2012 PyObject *slice = _PySlice_FromIndices(i1, i2);
2013 if (!slice)
2014 return NULL;
2015 res = mp->mp_subscript(s, slice);
2016 Py_DECREF(slice);
2017 return res;
2018 }
2019
2020 return type_error("'%.200s' object is unsliceable", s);
2021 }
2022
2023 int
2024 PySequence_SetItem(PyObject *s, Py_ssize_t i, PyObject *o)
2025 {
2026 PySequenceMethods *m;
2027
2028 if (s == NULL) {
2029 null_error();
2030 return -1;
2031 }
2032
2033 m = s->ob_type->tp_as_sequence;
2034 if (m && m->sq_ass_item) {
2035 if (i < 0) {
2036 if (m->sq_length) {
2037 Py_ssize_t l = (*m->sq_length)(s);
2038 if (l < 0)
2039 return -1;
2040 i += l;
2041 }
2042 }
2043 return m->sq_ass_item(s, i, o);
2044 }
2045
2046 type_error("'%.200s' object does not support item assignment", s);
2047 return -1;
2048 }
2049
2050 int
2051 PySequence_DelItem(PyObject *s, Py_ssize_t i)
2052 {
2053 PySequenceMethods *m;
2054
2055 if (s == NULL) {
2056 null_error();
2057 return -1;
2058 }
2059
2060 m = s->ob_type->tp_as_sequence;
2061 if (m && m->sq_ass_item) {
2062 if (i < 0) {
2063 if (m->sq_length) {
2064 Py_ssize_t l = (*m->sq_length)(s);
2065 if (l < 0)
2066 return -1;
2067 i += l;
2068 }
2069 }
2070 return m->sq_ass_item(s, i, (PyObject *)NULL);
2071 }
2072
2073 type_error("'%.200s' object doesn't support item deletion", s);
2074 return -1;
2075 }
2076
2077 int
2078 PySequence_SetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2, PyObject *o)
2079 {
2080 PySequenceMethods *m;
2081 PyMappingMethods *mp;
2082
2083 if (s == NULL) {
2084 null_error();
2085 return -1;
2086 }
2087
2088 m = s->ob_type->tp_as_sequence;
2089 if (m && m->sq_ass_slice) {
2090 if (i1 < 0 || i2 < 0) {
2091 if (m->sq_length) {
2092 Py_ssize_t l = (*m->sq_length)(s);
2093 if (l < 0)
2094 return -1;
2095 if (i1 < 0)
2096 i1 += l;
2097 if (i2 < 0)
2098 i2 += l;
2099 }
2100 }
2101 return m->sq_ass_slice(s, i1, i2, o);
2102 } else if ((mp = s->ob_type->tp_as_mapping) && mp->mp_ass_subscript) {
2103 int res;
2104 PyObject *slice = _PySlice_FromIndices(i1, i2);
2105 if (!slice)
2106 return -1;
2107 res = mp->mp_ass_subscript(s, slice, o);
2108 Py_DECREF(slice);
2109 return res;
2110 }
2111
2112 type_error("'%.200s' object doesn't support slice assignment", s);
2113 return -1;
2114 }
2115
2116 int
2117 PySequence_DelSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2)
2118 {
2119 PySequenceMethods *m;
2120
2121 if (s == NULL) {
2122 null_error();
2123 return -1;
2124 }
2125
2126 m = s->ob_type->tp_as_sequence;
2127 if (m && m->sq_ass_slice) {
2128 if (i1 < 0 || i2 < 0) {
2129 if (m->sq_length) {
2130 Py_ssize_t l = (*m->sq_length)(s);
2131 if (l < 0)
2132 return -1;
2133 if (i1 < 0)
2134 i1 += l;
2135 if (i2 < 0)
2136 i2 += l;
2137 }
2138 }
2139 return m->sq_ass_slice(s, i1, i2, (PyObject *)NULL);
2140 }
2141 type_error("'%.200s' object doesn't support slice deletion", s);
2142 return -1;
2143 }
2144
2145 PyObject *
2146 PySequence_Tuple(PyObject *v)
2147 {
2148 PyObject *it; /* iter(v) */
2149 Py_ssize_t n; /* guess for result tuple size */
2150 PyObject *result = NULL;
2151 Py_ssize_t j;
2152
2153 if (v == NULL)
2154 return null_error();
2155
2156 /* Special-case the common tuple and list cases, for efficiency. */
2157 if (PyTuple_CheckExact(v)) {
2158 /* Note that we can't know whether it's safe to return
2159 a tuple *subclass* instance as-is, hence the restriction
2160 to exact tuples here. In contrast, lists always make
2161 a copy, so there's no need for exactness below. */
2162 Py_INCREF(v);
2163 return v;
2164 }
2165 if (PyList_Check(v))
2166 return PyList_AsTuple(v);
2167
2168 /* Get iterator. */
2169 it = PyObject_GetIter(v);
2170 if (it == NULL)
2171 return NULL;
2172
2173 /* Guess result size and allocate space. */
2174 n = _PyObject_LengthHint(v, 10);
2175 if (n == -1)
2176 goto Fail;
2177 result = PyTuple_New(n);
2178 if (result == NULL)
2179 goto Fail;
2180
2181 /* Fill the tuple. */
2182 for (j = 0; ; ++j) {
2183 PyObject *item = PyIter_Next(it);
2184 if (item == NULL) {
2185 if (PyErr_Occurred())
2186 goto Fail;
2187 break;
2188 }
2189 if (j >= n) {
2190 Py_ssize_t oldn = n;
2191 /* The over-allocation strategy can grow a bit faster
2192 than for lists because unlike lists the
2193 over-allocation isn't permanent -- we reclaim
2194 the excess before the end of this routine.
2195 So, grow by ten and then add 25%.
2196 */
2197 n += 10;
2198 n += n >> 2;
2199 if (n < oldn) {
2200 /* Check for overflow */
2201 PyErr_NoMemory();
2202 Py_DECREF(item);
2203 goto Fail;
2204 }
2205 if (_PyTuple_Resize(&result, n) != 0) {
2206 Py_DECREF(item);
2207 goto Fail;
2208 }
2209 }
2210 PyTuple_SET_ITEM(result, j, item);
2211 }
2212
2213 /* Cut tuple back if guess was too large. */
2214 if (j < n &&
2215 _PyTuple_Resize(&result, j) != 0)
2216 goto Fail;
2217
2218 Py_DECREF(it);
2219 return result;
2220
2221 Fail:
2222 Py_XDECREF(result);
2223 Py_DECREF(it);
2224 return NULL;
2225 }
2226
2227 PyObject *
2228 PySequence_List(PyObject *v)
2229 {
2230 PyObject *result; /* result list */
2231 PyObject *rv; /* return value from PyList_Extend */
2232
2233 if (v == NULL)
2234 return null_error();
2235
2236 result = PyList_New(0);
2237 if (result == NULL)
2238 return NULL;
2239
2240 rv = _PyList_Extend((PyListObject *)result, v);
2241 if (rv == NULL) {
2242 Py_DECREF(result);
2243 return NULL;
2244 }
2245 Py_DECREF(rv);
2246 return result;
2247 }
2248
2249 PyObject *
2250 PySequence_Fast(PyObject *v, const char *m)
2251 {
2252 PyObject *it;
2253
2254 if (v == NULL)
2255 return null_error();
2256
2257 if (PyList_CheckExact(v) || PyTuple_CheckExact(v)) {
2258 Py_INCREF(v);
2259 return v;
2260 }
2261
2262 it = PyObject_GetIter(v);
2263 if (it == NULL) {
2264 if (PyErr_ExceptionMatches(PyExc_TypeError))
2265 PyErr_SetString(PyExc_TypeError, m);
2266 return NULL;
2267 }
2268
2269 v = PySequence_List(it);
2270 Py_DECREF(it);
2271
2272 return v;
2273 }
2274
2275 /* Iterate over seq. Result depends on the operation:
2276 PY_ITERSEARCH_COUNT: -1 if error, else # of times obj appears in seq.
2277 PY_ITERSEARCH_INDEX: 0-based index of first occurrence of obj in seq;
2278 set ValueError and return -1 if none found; also return -1 on error.
2279 Py_ITERSEARCH_CONTAINS: return 1 if obj in seq, else 0; -1 on error.
2280 */
2281 Py_ssize_t
2282 _PySequence_IterSearch(PyObject *seq, PyObject *obj, int operation)
2283 {
2284 Py_ssize_t n;
2285 int wrapped; /* for PY_ITERSEARCH_INDEX, true iff n wrapped around */
2286 PyObject *it; /* iter(seq) */
2287
2288 if (seq == NULL || obj == NULL) {
2289 null_error();
2290 return -1;
2291 }
2292
2293 it = PyObject_GetIter(seq);
2294 if (it == NULL) {
2295 type_error("argument of type '%.200s' is not iterable", seq);
2296 return -1;
2297 }
2298
2299 n = wrapped = 0;
2300 for (;;) {
2301 int cmp;
2302 PyObject *item = PyIter_Next(it);
2303 if (item == NULL) {
2304 if (PyErr_Occurred())
2305 goto Fail;
2306 break;
2307 }
2308
2309 cmp = PyObject_RichCompareBool(obj, item, Py_EQ);
2310 Py_DECREF(item);
2311 if (cmp < 0)
2312 goto Fail;
2313 if (cmp > 0) {
2314 switch (operation) {
2315 case PY_ITERSEARCH_COUNT:
2316 if (n == PY_SSIZE_T_MAX) {
2317 PyErr_SetString(PyExc_OverflowError,
2318 "count exceeds C integer size");
2319 goto Fail;
2320 }
2321 ++n;
2322 break;
2323
2324 case PY_ITERSEARCH_INDEX:
2325 if (wrapped) {
2326 PyErr_SetString(PyExc_OverflowError,
2327 "index exceeds C integer size");
2328 goto Fail;
2329 }
2330 goto Done;
2331
2332 case PY_ITERSEARCH_CONTAINS:
2333 n = 1;
2334 goto Done;
2335
2336 default:
2337 assert(!"unknown operation");
2338 }
2339 }
2340
2341 if (operation == PY_ITERSEARCH_INDEX) {
2342 if (n == PY_SSIZE_T_MAX)
2343 wrapped = 1;
2344 ++n;
2345 }
2346 }
2347
2348 if (operation != PY_ITERSEARCH_INDEX)
2349 goto Done;
2350
2351 PyErr_SetString(PyExc_ValueError,
2352 "sequence.index(x): x not in sequence");
2353 /* fall into failure code */
2354 Fail:
2355 n = -1;
2356 /* fall through */
2357 Done:
2358 Py_DECREF(it);
2359 return n;
2360
2361 }
2362
2363 /* Return # of times o appears in s. */
2364 Py_ssize_t
2365 PySequence_Count(PyObject *s, PyObject *o)
2366 {
2367 return _PySequence_IterSearch(s, o, PY_ITERSEARCH_COUNT);
2368 }
2369
2370 /* Return -1 if error; 1 if ob in seq; 0 if ob not in seq.
2371 * Use sq_contains if possible, else defer to _PySequence_IterSearch().
2372 */
2373 int
2374 PySequence_Contains(PyObject *seq, PyObject *ob)
2375 {
2376 Py_ssize_t result;
2377 if (PyType_HasFeature(seq->ob_type, Py_TPFLAGS_HAVE_SEQUENCE_IN)) {
2378 PySequenceMethods *sqm = seq->ob_type->tp_as_sequence;
2379 if (sqm != NULL && sqm->sq_contains != NULL)
2380 return (*sqm->sq_contains)(seq, ob);
2381 }
2382 result = _PySequence_IterSearch(seq, ob, PY_ITERSEARCH_CONTAINS);
2383 return Py_SAFE_DOWNCAST(result, Py_ssize_t, int);
2384 }
2385
2386 /* Backwards compatibility */
2387 #undef PySequence_In
2388 int
2389 PySequence_In(PyObject *w, PyObject *v)
2390 {
2391 return PySequence_Contains(w, v);
2392 }
2393
2394 Py_ssize_t
2395 PySequence_Index(PyObject *s, PyObject *o)
2396 {
2397 return _PySequence_IterSearch(s, o, PY_ITERSEARCH_INDEX);
2398 }
2399
2400 /* Operations on mappings */
2401
2402 int
2403 PyMapping_Check(PyObject *o)
2404 {
2405 if (o && PyInstance_Check(o))
2406 return PyObject_HasAttrString(o, "__getitem__");
2407
2408 return o && o->ob_type->tp_as_mapping &&
2409 o->ob_type->tp_as_mapping->mp_subscript &&
2410 !(o->ob_type->tp_as_sequence &&
2411 o->ob_type->tp_as_sequence->sq_slice);
2412 }
2413
2414 Py_ssize_t
2415 PyMapping_Size(PyObject *o)
2416 {
2417 PyMappingMethods *m;
2418
2419 if (o == NULL) {
2420 null_error();
2421 return -1;
2422 }
2423
2424 m = o->ob_type->tp_as_mapping;
2425 if (m && m->mp_length)
2426 return m->mp_length(o);
2427
2428 type_error("object of type '%.200s' has no len()", o);
2429 return -1;
2430 }
2431
2432 #undef PyMapping_Length
2433 Py_ssize_t
2434 PyMapping_Length(PyObject *o)
2435 {
2436 return PyMapping_Size(o);
2437 }
2438 #define PyMapping_Length PyMapping_Size
2439
2440 PyObject *
2441 PyMapping_GetItemString(PyObject *o, char *key)
2442 {
2443 PyObject *okey, *r;
2444
2445 if (key == NULL)
2446 return null_error();
2447
2448 okey = PyString_FromString(key);
2449 if (okey == NULL)
2450 return NULL;
2451 r = PyObject_GetItem(o, okey);
2452 Py_DECREF(okey);
2453 return r;
2454 }
2455
2456 int
2457 PyMapping_SetItemString(PyObject *o, char *key, PyObject *value)
2458 {
2459 PyObject *okey;
2460 int r;
2461
2462 if (key == NULL) {
2463 null_error();
2464 return -1;
2465 }
2466
2467 okey = PyString_FromString(key);
2468 if (okey == NULL)
2469 return -1;
2470 r = PyObject_SetItem(o, okey, value);
2471 Py_DECREF(okey);
2472 return r;
2473 }
2474
2475 int
2476 PyMapping_HasKeyString(PyObject *o, char *key)
2477 {
2478 PyObject *v;
2479
2480 v = PyMapping_GetItemString(o, key);
2481 if (v) {
2482 Py_DECREF(v);
2483 return 1;
2484 }
2485 PyErr_Clear();
2486 return 0;
2487 }
2488
2489 int
2490 PyMapping_HasKey(PyObject *o, PyObject *key)
2491 {
2492 PyObject *v;
2493
2494 v = PyObject_GetItem(o, key);
2495 if (v) {
2496 Py_DECREF(v);
2497 return 1;
2498 }
2499 PyErr_Clear();
2500 return 0;
2501 }
2502
2503 /* Operations on callable objects */
2504
2505 /* XXX PyCallable_Check() is in object.c */
2506
2507 PyObject *
2508 PyObject_CallObject(PyObject *o, PyObject *a)
2509 {
2510 return PyEval_CallObjectWithKeywords(o, a, NULL);
2511 }
2512
2513 PyObject *
2514 PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw)
2515 {
2516 ternaryfunc call;
2517
2518 if ((call = func->ob_type->tp_call) != NULL) {
2519 PyObject *result;
2520 if (Py_EnterRecursiveCall(" while calling a Python object"))
2521 return NULL;
2522 result = (*call)(func, arg, kw);
2523 Py_LeaveRecursiveCall();
2524 if (result == NULL && !PyErr_Occurred())
2525 PyErr_SetString(
2526 PyExc_SystemError,
2527 "NULL result without error in PyObject_Call");
2528 return result;
2529 }
2530 PyErr_Format(PyExc_TypeError, "'%.200s' object is not callable",
2531 func->ob_type->tp_name);
2532 return NULL;
2533 }
2534
2535 static PyObject*
2536 call_function_tail(PyObject *callable, PyObject *args)
2537 {
2538 PyObject *retval;
2539
2540 if (args == NULL)
2541 return NULL;
2542
2543 if (!PyTuple_Check(args)) {
2544 PyObject *a;
2545
2546 a = PyTuple_New(1);
2547 if (a == NULL) {
2548 Py_DECREF(args);
2549 return NULL;
2550 }
2551 PyTuple_SET_ITEM(a, 0, args);
2552 args = a;
2553 }
2554 retval = PyObject_Call(callable, args, NULL);
2555
2556 Py_DECREF(args);
2557
2558 return retval;
2559 }
2560
2561 PyObject *
2562 PyObject_CallFunction(PyObject *callable, char *format, ...)
2563 {
2564 va_list va;
2565 PyObject *args;
2566
2567 if (callable == NULL)
2568 return null_error();
2569
2570 if (format && *format) {
2571 va_start(va, format);
2572 args = Py_VaBuildValue(format, va);
2573 va_end(va);
2574 }
2575 else
2576 args = PyTuple_New(0);
2577
2578 return call_function_tail(callable, args);
2579 }
2580
2581 PyObject *
2582 _PyObject_CallFunction_SizeT(PyObject *callable, char *format, ...)
2583 {
2584 va_list va;
2585 PyObject *args;
2586
2587 if (callable == NULL)
2588 return null_error();
2589
2590 if (format && *format) {
2591 va_start(va, format);
2592 args = _Py_VaBuildValue_SizeT(format, va);
2593 va_end(va);
2594 }
2595 else
2596 args = PyTuple_New(0);
2597
2598 return call_function_tail(callable, args);
2599 }
2600
2601 PyObject *
2602 PyObject_CallMethod(PyObject *o, char *name, char *format, ...)
2603 {
2604 va_list va;
2605 PyObject *args;
2606 PyObject *func = NULL;
2607 PyObject *retval = NULL;
2608
2609 if (o == NULL || name == NULL)
2610 return null_error();
2611
2612 func = PyObject_GetAttrString(o, name);
2613 if (func == NULL) {
2614 PyErr_SetString(PyExc_AttributeError, name);
2615 return 0;
2616 }
2617
2618 if (!PyCallable_Check(func)) {
2619 type_error("attribute of type '%.200s' is not callable", func);
2620 goto exit;
2621 }
2622
2623 if (format && *format) {
2624 va_start(va, format);
2625 args = Py_VaBuildValue(format, va);
2626 va_end(va);
2627 }
2628 else
2629 args = PyTuple_New(0);
2630
2631 retval = call_function_tail(func, args);
2632
2633 exit:
2634 /* args gets consumed in call_function_tail */
2635 Py_XDECREF(func);
2636
2637 return retval;
2638 }
2639
2640 PyObject *
2641 _PyObject_CallMethod_SizeT(PyObject *o, char *name, char *format, ...)
2642 {
2643 va_list va;
2644 PyObject *args;
2645 PyObject *func = NULL;
2646 PyObject *retval = NULL;
2647
2648 if (o == NULL || name == NULL)
2649 return null_error();
2650
2651 func = PyObject_GetAttrString(o, name);
2652 if (func == NULL) {
2653 PyErr_SetString(PyExc_AttributeError, name);
2654 return 0;
2655 }
2656
2657 if (!PyCallable_Check(func)) {
2658 type_error("attribute of type '%.200s' is not callable", func);
2659 goto exit;
2660 }
2661
2662 if (format && *format) {
2663 va_start(va, format);
2664 args = _Py_VaBuildValue_SizeT(format, va);
2665 va_end(va);
2666 }
2667 else
2668 args = PyTuple_New(0);
2669
2670 retval = call_function_tail(func, args);
2671
2672 exit:
2673 /* args gets consumed in call_function_tail */
2674 Py_XDECREF(func);
2675
2676 return retval;
2677 }
2678
2679
2680 static PyObject *
2681 objargs_mktuple(va_list va)
2682 {
2683 int i, n = 0;
2684 va_list countva;
2685 PyObject *result, *tmp;
2686
2687 #ifdef VA_LIST_IS_ARRAY
2688 memcpy(countva, va, sizeof(va_list));
2689 #else
2690 #ifdef __va_copy
2691 __va_copy(countva, va);
2692 #else
2693 countva = va;
2694 #endif
2695 #endif
2696
2697 while (((PyObject *)va_arg(countva, PyObject *)) != NULL)
2698 ++n;
2699 result = PyTuple_New(n);
2700 if (result != NULL && n > 0) {
2701 for (i = 0; i < n; ++i) {
2702 tmp = (PyObject *)va_arg(va, PyObject *);
2703 PyTuple_SET_ITEM(result, i, tmp);
2704 Py_INCREF(tmp);
2705 }
2706 }
2707 return result;
2708 }
2709
2710 PyObject *
2711 PyObject_CallMethodObjArgs(PyObject *callable, PyObject *name, ...)
2712 {
2713 PyObject *args, *tmp;
2714 va_list vargs;
2715
2716 if (callable == NULL || name == NULL)
2717 return null_error();
2718
2719 callable = PyObject_GetAttr(callable, name);
2720 if (callable == NULL)
2721 return NULL;
2722
2723 /* count the args */
2724 va_start(vargs, name);
2725 args = objargs_mktuple(vargs);
2726 va_end(vargs);
2727 if (args == NULL) {
2728 Py_DECREF(callable);
2729 return NULL;
2730 }
2731 tmp = PyObject_Call(callable, args, NULL);
2732 Py_DECREF(args);
2733 Py_DECREF(callable);
2734
2735 return tmp;
2736 }
2737
2738 PyObject *
2739 PyObject_CallFunctionObjArgs(PyObject *callable, ...)
2740 {
2741 PyObject *args, *tmp;
2742 va_list vargs;
2743
2744 if (callable == NULL)
2745 return null_error();
2746
2747 /* count the args */
2748 va_start(vargs, callable);
2749 args = objargs_mktuple(vargs);
2750 va_end(vargs);
2751 if (args == NULL)
2752 return NULL;
2753 tmp = PyObject_Call(callable, args, NULL);
2754 Py_DECREF(args);
2755
2756 return tmp;
2757 }
2758
2759
2760 /* isinstance(), issubclass() */
2761
2762 /* abstract_get_bases() has logically 4 return states, with a sort of 0th
2763 * state that will almost never happen.
2764 *
2765 * 0. creating the __bases__ static string could get a MemoryError
2766 * 1. getattr(cls, '__bases__') could raise an AttributeError
2767 * 2. getattr(cls, '__bases__') could raise some other exception
2768 * 3. getattr(cls, '__bases__') could return a tuple
2769 * 4. getattr(cls, '__bases__') could return something other than a tuple
2770 *
2771 * Only state #3 is a non-error state and only it returns a non-NULL object
2772 * (it returns the retrieved tuple).
2773 *
2774 * Any raised AttributeErrors are masked by clearing the exception and
2775 * returning NULL. If an object other than a tuple comes out of __bases__,
2776 * then again, the return value is NULL. So yes, these two situations
2777 * produce exactly the same results: NULL is returned and no error is set.
2778 *
2779 * If some exception other than AttributeError is raised, then NULL is also
2780 * returned, but the exception is not cleared. That's because we want the
2781 * exception to be propagated along.
2782 *
2783 * Callers are expected to test for PyErr_Occurred() when the return value
2784 * is NULL to decide whether a valid exception should be propagated or not.
2785 * When there's no exception to propagate, it's customary for the caller to
2786 * set a TypeError.
2787 */
2788 static PyObject *
2789 abstract_get_bases(PyObject *cls)
2790 {
2791 static PyObject *__bases__ = NULL;
2792 PyObject *bases;
2793
2794 if (__bases__ == NULL) {
2795 __bases__ = PyString_InternFromString("__bases__");
2796 if (__bases__ == NULL)
2797 return NULL;
2798 }
2799 bases = PyObject_GetAttr(cls, __bases__);
2800 if (bases == NULL) {
2801 if (PyErr_ExceptionMatches(PyExc_AttributeError))
2802 PyErr_Clear();
2803 return NULL;
2804 }
2805 if (!PyTuple_Check(bases)) {
2806 Py_DECREF(bases);
2807 return NULL;
2808 }
2809 return bases;
2810 }
2811
2812
2813 static int
2814 abstract_issubclass(PyObject *derived, PyObject *cls)
2815 {
2816 PyObject *bases = NULL;
2817 Py_ssize_t i, n;
2818 int r = 0;
2819
2820 while (1) {
2821 if (derived == cls)
2822 return 1;
2823 bases = abstract_get_bases(derived);
2824 if (bases == NULL) {
2825 if (PyErr_Occurred())
2826 return -1;
2827 return 0;
2828 }
2829 n = PyTuple_GET_SIZE(bases);
2830 if (n == 0) {
2831 Py_DECREF(bases);
2832 return 0;
2833 }
2834 /* Avoid recursivity in the single inheritance case */
2835 if (n == 1) {
2836 derived = PyTuple_GET_ITEM(bases, 0);
2837 Py_DECREF(bases);
2838 continue;
2839 }
2840 for (i = 0; i < n; i++) {
2841 r = abstract_issubclass(PyTuple_GET_ITEM(bases, i), cls);
2842 if (r != 0)
2843 break;
2844 }
2845 Py_DECREF(bases);
2846 return r;
2847 }
2848 }
2849
2850 static int
2851 check_class(PyObject *cls, const char *error)
2852 {
2853 PyObject *bases = abstract_get_bases(cls);
2854 if (bases == NULL) {
2855 /* Do not mask errors. */
2856 if (!PyErr_Occurred())
2857 PyErr_SetString(PyExc_TypeError, error);
2858 return 0;
2859 }
2860 Py_DECREF(bases);
2861 return -1;
2862 }
2863
2864 static int
2865 recursive_isinstance(PyObject *inst, PyObject *cls)
2866 {
2867 PyObject *icls;
2868 static PyObject *__class__ = NULL;
2869 int retval = 0;
2870
2871 if (__class__ == NULL) {
2872 __class__ = PyString_InternFromString("__class__");
2873 if (__class__ == NULL)
2874 return -1;
2875 }
2876
2877 if (PyClass_Check(cls) && PyInstance_Check(inst)) {
2878 PyObject *inclass =
2879 (PyObject*)((PyInstanceObject*)inst)->in_class;
2880 retval = PyClass_IsSubclass(inclass, cls);
2881 }
2882 else if (PyType_Check(cls)) {
2883 retval = PyObject_TypeCheck(inst, (PyTypeObject *)cls);
2884 if (retval == 0) {
2885 PyObject *c = PyObject_GetAttr(inst, __class__);
2886 if (c == NULL) {
2887 PyErr_Clear();
2888 }
2889 else {
2890 if (c != (PyObject *)(inst->ob_type) &&
2891 PyType_Check(c))
2892 retval = PyType_IsSubtype(
2893 (PyTypeObject *)c,
2894 (PyTypeObject *)cls);
2895 Py_DECREF(c);
2896 }
2897 }
2898 }
2899 else {
2900 if (!check_class(cls,
2901 "isinstance() arg 2 must be a class, type,"
2902 " or tuple of classes and types"))
2903 return -1;
2904 icls = PyObject_GetAttr(inst, __class__);
2905 if (icls == NULL) {
2906 PyErr_Clear();
2907 retval = 0;
2908 }
2909 else {
2910 retval = abstract_issubclass(icls, cls);
2911 Py_DECREF(icls);
2912 }
2913 }
2914
2915 return retval;
2916 }
2917
2918 int
2919 PyObject_IsInstance(PyObject *inst, PyObject *cls)
2920 {
2921 static PyObject *name = NULL;
2922
2923 /* Quick test for an exact match */
2924 if (Py_TYPE(inst) == (PyTypeObject *)cls)
2925 return 1;
2926
2927 if (PyTuple_Check(cls)) {
2928 Py_ssize_t i;
2929 Py_ssize_t n;
2930 int r = 0;
2931
2932 if (Py_EnterRecursiveCall(" in __instancecheck__"))
2933 return -1;
2934 n = PyTuple_GET_SIZE(cls);
2935 for (i = 0; i < n; ++i) {
2936 PyObject *item = PyTuple_GET_ITEM(cls, i);
2937 r = PyObject_IsInstance(inst, item);
2938 if (r != 0)
2939 /* either found it, or got an error */
2940 break;
2941 }
2942 Py_LeaveRecursiveCall();
2943 return r;
2944 }
2945
2946 if (!(PyClass_Check(cls) || PyInstance_Check(cls))) {
2947 PyObject *checker;
2948 checker = _PyObject_LookupSpecial(cls, "__instancecheck__", &name);
2949 if (checker != NULL) {
2950 PyObject *res;
2951 int ok = -1;
2952 if (Py_EnterRecursiveCall(" in __instancecheck__")) {
2953 Py_DECREF(checker);
2954 return ok;
2955 }
2956 res = PyObject_CallFunctionObjArgs(checker, inst, NULL);
2957 Py_LeaveRecursiveCall();
2958 Py_DECREF(checker);
2959 if (res != NULL) {
2960 ok = PyObject_IsTrue(res);
2961 Py_DECREF(res);
2962 }
2963 return ok;
2964 }
2965 else if (PyErr_Occurred())
2966 return -1;
2967 }
2968 return recursive_isinstance(inst, cls);
2969 }
2970
2971 static int
2972 recursive_issubclass(PyObject *derived, PyObject *cls)
2973 {
2974 int retval;
2975
2976 if (PyType_Check(cls) && PyType_Check(derived)) {
2977 /* Fast path (non-recursive) */
2978 return PyType_IsSubtype(
2979 (PyTypeObject *)derived, (PyTypeObject *)cls);
2980 }
2981 if (!PyClass_Check(derived) || !PyClass_Check(cls)) {
2982 if (!check_class(derived,
2983 "issubclass() arg 1 must be a class"))
2984 return -1;
2985
2986 if (!check_class(cls,
2987 "issubclass() arg 2 must be a class"
2988 " or tuple of classes"))
2989 return -1;
2990 retval = abstract_issubclass(derived, cls);
2991 }
2992 else {
2993 /* shortcut */
2994 if (!(retval = (derived == cls)))
2995 retval = PyClass_IsSubclass(derived, cls);
2996 }
2997
2998 return retval;
2999 }
3000
3001 int
3002 PyObject_IsSubclass(PyObject *derived, PyObject *cls)
3003 {
3004 static PyObject *name = NULL;
3005
3006 if (PyTuple_Check(cls)) {
3007 Py_ssize_t i;
3008 Py_ssize_t n;
3009 int r = 0;
3010
3011 if (Py_EnterRecursiveCall(" in __subclasscheck__"))
3012 return -1;
3013 n = PyTuple_GET_SIZE(cls);
3014 for (i = 0; i < n; ++i) {
3015 PyObject *item = PyTuple_GET_ITEM(cls, i);
3016 r = PyObject_IsSubclass(derived, item);
3017 if (r != 0)
3018 /* either found it, or got an error */
3019 break;
3020 }
3021 Py_LeaveRecursiveCall();
3022 return r;
3023 }
3024 if (!(PyClass_Check(cls) || PyInstance_Check(cls))) {
3025 PyObject *checker;
3026 checker = _PyObject_LookupSpecial(cls, "__subclasscheck__", &name);
3027 if (checker != NULL) {
3028 PyObject *res;
3029 int ok = -1;
3030 if (Py_EnterRecursiveCall(" in __subclasscheck__")) {
3031 Py_DECREF(checker);
3032 return ok;
3033 }
3034 res = PyObject_CallFunctionObjArgs(checker, derived, NULL);
3035 Py_LeaveRecursiveCall();
3036 Py_DECREF(checker);
3037 if (res != NULL) {
3038 ok = PyObject_IsTrue(res);
3039 Py_DECREF(res);
3040 }
3041 return ok;
3042 }
3043 else if (PyErr_Occurred()) {
3044 return -1;
3045 }
3046 }
3047 return recursive_issubclass(derived, cls);
3048 }
3049
3050 int
3051 _PyObject_RealIsInstance(PyObject *inst, PyObject *cls)
3052 {
3053 return recursive_isinstance(inst, cls);
3054 }
3055
3056 int
3057 _PyObject_RealIsSubclass(PyObject *derived, PyObject *cls)
3058 {
3059 return recursive_issubclass(derived, cls);
3060 }
3061
3062
3063 PyObject *
3064 PyObject_GetIter(PyObject *o)
3065 {
3066 PyTypeObject *t = o->ob_type;
3067 getiterfunc f = NULL;
3068 if (PyType_HasFeature(t, Py_TPFLAGS_HAVE_ITER))
3069 f = t->tp_iter;
3070 if (f == NULL) {
3071 if (PySequence_Check(o))
3072 return PySeqIter_New(o);
3073 return type_error("'%.200s' object is not iterable", o);
3074 }
3075 else {
3076 PyObject *res = (*f)(o);
3077 if (res != NULL && !PyIter_Check(res)) {
3078 PyErr_Format(PyExc_TypeError,
3079 "iter() returned non-iterator "
3080 "of type '%.100s'",
3081 res->ob_type->tp_name);
3082 Py_DECREF(res);
3083 res = NULL;
3084 }
3085 return res;
3086 }
3087 }
3088
3089 /* Return next item.
3090 * If an error occurs, return NULL. PyErr_Occurred() will be true.
3091 * If the iteration terminates normally, return NULL and clear the
3092 * PyExc_StopIteration exception (if it was set). PyErr_Occurred()
3093 * will be false.
3094 * Else return the next object. PyErr_Occurred() will be false.
3095 */
3096 PyObject *
3097 PyIter_Next(PyObject *iter)
3098 {
3099 PyObject *result;
3100 result = (*iter->ob_type->tp_iternext)(iter);
3101 if (result == NULL &&
3102 PyErr_Occurred() &&
3103 PyErr_ExceptionMatches(PyExc_StopIteration))
3104 PyErr_Clear();
3105 return result;
3106 }