1 /* Abstract Object Interface (many thanks to Jim Fulton) */
5 #include "structmember.h" /* we need the offsetof() macro from there */
6 #include "longintrepr.h"
8 #define NEW_STYLE_NUMBER(o) PyType_HasFeature((o)->ob_type, \
12 /* Shorthands to return certain errors */
15 type_error(const char *msg, PyObject *obj)
17 PyErr_Format(PyExc_TypeError, msg, obj->ob_type->tp_name);
24 if (!PyErr_Occurred())
25 PyErr_SetString(PyExc_SystemError,
26 "null argument to internal routine");
30 /* Operations on any object */
33 PyObject_Cmp(PyObject *o1, PyObject *o2, int *result)
37 if (o1 == NULL || o2 == NULL) {
41 r = PyObject_Compare(o1, o2);
49 PyObject_Type(PyObject *o)
55 v = (PyObject *)o->ob_type;
61 PyObject_Size(PyObject *o)
70 m = o->ob_type->tp_as_sequence;
71 if (m && m->sq_length)
72 return m->sq_length(o);
74 return PyMapping_Size(o);
77 #undef PyObject_Length
79 PyObject_Length(PyObject *o)
81 return PyObject_Size(o);
83 #define PyObject_Length PyObject_Size
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.
93 _PyObject_LengthHint(PyObject *o, Py_ssize_t defaultvalue)
95 static PyObject *hintstrobj = NULL;
96 PyObject *ro, *hintmeth;
100 rv = PyObject_Size(o);
103 if (PyErr_Occurred()) {
104 if (!PyErr_ExceptionMatches(PyExc_TypeError) &&
105 !PyErr_ExceptionMatches(PyExc_AttributeError))
110 if (PyInstance_Check(o))
112 /* try o.__length_hint__() */
113 hintmeth = _PyObject_LookupSpecial(o, "__length_hint__", &hintstrobj);
114 if (hintmeth == NULL) {
115 if (PyErr_Occurred())
120 ro = PyObject_CallFunctionObjArgs(hintmeth, NULL);
123 if (!PyErr_ExceptionMatches(PyExc_TypeError) &&
124 !PyErr_ExceptionMatches(PyExc_AttributeError))
129 rv = PyLong_Check(ro) ? PyLong_AsSsize_t(ro) : defaultvalue;
135 PyObject_GetItem(PyObject *o, PyObject *key)
139 if (o == NULL || key == NULL)
142 m = o->ob_type->tp_as_mapping;
143 if (m && m->mp_subscript)
144 return m->mp_subscript(o, key);
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())
152 return PySequence_GetItem(o, key_value);
154 else if (o->ob_type->tp_as_sequence->sq_item)
155 return type_error("sequence index must "
156 "be integer, not '%.200s'", key);
159 return type_error("'%.200s' object has no attribute '__getitem__'", o);
163 PyObject_SetItem(PyObject *o, PyObject *key, PyObject *value)
167 if (o == NULL || key == NULL || value == NULL) {
171 m = o->ob_type->tp_as_mapping;
172 if (m && m->mp_ass_subscript)
173 return m->mp_ass_subscript(o, key, value);
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())
181 return PySequence_SetItem(o, key_value, value);
183 else if (o->ob_type->tp_as_sequence->sq_ass_item) {
184 type_error("sequence index must be "
185 "integer, not '%.200s'", key);
190 type_error("'%.200s' object does not support item assignment", o);
195 PyObject_DelItem(PyObject *o, PyObject *key)
199 if (o == NULL || key == NULL) {
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);
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())
213 return PySequence_DelItem(o, key_value);
215 else if (o->ob_type->tp_as_sequence->sq_ass_item) {
216 type_error("sequence index must be "
217 "integer, not '%.200s'", key);
222 type_error("'%.200s' object does not support item deletion", o);
227 PyObject_DelItemString(PyObject *o, char *key)
232 if (o == NULL || key == NULL) {
236 okey = PyString_FromString(key);
239 ret = PyObject_DelItem(o, okey);
245 PyObject_AsCharBuffer(PyObject *obj,
247 Py_ssize_t *buffer_len)
253 if (obj == NULL || buffer == NULL || buffer_len == NULL) {
257 pb = obj->ob_type->tp_as_buffer;
259 pb->bf_getcharbuffer == NULL ||
260 pb->bf_getsegcount == NULL) {
261 PyErr_SetString(PyExc_TypeError,
262 "expected a character buffer object");
265 if ((*pb->bf_getsegcount)(obj,NULL) != 1) {
266 PyErr_SetString(PyExc_TypeError,
267 "expected a single-segment buffer object");
270 len = (*pb->bf_getcharbuffer)(obj, 0, &pp);
279 PyObject_CheckReadBuffer(PyObject *obj)
281 PyBufferProcs *pb = obj->ob_type->tp_as_buffer;
284 pb->bf_getreadbuffer == NULL ||
285 pb->bf_getsegcount == NULL ||
286 (*pb->bf_getsegcount)(obj, NULL) != 1)
291 int PyObject_AsReadBuffer(PyObject *obj,
293 Py_ssize_t *buffer_len)
299 if (obj == NULL || buffer == NULL || buffer_len == NULL) {
303 pb = obj->ob_type->tp_as_buffer;
305 pb->bf_getreadbuffer == NULL ||
306 pb->bf_getsegcount == NULL) {
307 PyErr_SetString(PyExc_TypeError,
308 "expected a readable buffer object");
311 if ((*pb->bf_getsegcount)(obj, NULL) != 1) {
312 PyErr_SetString(PyExc_TypeError,
313 "expected a single-segment buffer object");
316 len = (*pb->bf_getreadbuffer)(obj, 0, &pp);
324 int PyObject_AsWriteBuffer(PyObject *obj,
326 Py_ssize_t *buffer_len)
332 if (obj == NULL || buffer == NULL || buffer_len == NULL) {
336 pb = obj->ob_type->tp_as_buffer;
338 pb->bf_getwritebuffer == NULL ||
339 pb->bf_getsegcount == NULL) {
340 PyErr_SetString(PyExc_TypeError,
341 "expected a writeable buffer object");
344 if ((*pb->bf_getsegcount)(obj, NULL) != 1) {
345 PyErr_SetString(PyExc_TypeError,
346 "expected a single-segment buffer object");
349 len = (*pb->bf_getwritebuffer)(obj,0,&pp);
357 /* Buffer C-API for Python 3.0 */
360 PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags)
362 if (!PyObject_CheckBuffer(obj)) {
363 PyErr_Format(PyExc_TypeError,
364 "'%100s' does not have the buffer interface",
365 Py_TYPE(obj)->tp_name);
368 return (*(obj->ob_type->tp_as_buffer->bf_getbuffer))(obj, view, flags);
372 _IsFortranContiguous(Py_buffer *view)
377 if (view->ndim == 0) return 1;
378 if (view->strides == NULL) return (view->ndim == 1);
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;
393 _IsCContiguous(Py_buffer *view)
398 if (view->ndim == 0) return 1;
399 if (view->strides == NULL) return 1;
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;
414 PyBuffer_IsContiguous(Py_buffer *view, char fort)
417 if (view->suboffsets != NULL) return 0;
420 return _IsCContiguous(view);
421 else if (fort == 'F')
422 return _IsFortranContiguous(view);
423 else if (fort == 'A')
424 return (_IsCContiguous(view) || _IsFortranContiguous(view));
430 PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices)
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];
441 return (void*)pointer;
446 _Py_add_one_to_index_F(int nd, Py_ssize_t *index, const Py_ssize_t *shape)
450 for (k=0; k<nd; k++) {
451 if (index[k] < shape[k]-1) {
462 _Py_add_one_to_index_C(int nd, Py_ssize_t *index, const Py_ssize_t *shape)
466 for (k=nd-1; k>=0; k--) {
467 if (index[k] < shape[k]-1) {
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.
483 PyBuffer_ToContiguous(void *buf, Py_buffer *view, Py_ssize_t len, char fort)
486 void (*addone)(int, Py_ssize_t *, const Py_ssize_t *);
487 Py_ssize_t *indices, elements;
490 if (len > view->len) {
494 if (PyBuffer_IsContiguous(view, fort)) {
495 /* simplest copy is all that is needed */
496 memcpy(buf, view->buf, len);
500 /* Otherwise a more elaborate scheme is needed */
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) {
508 for (k=0; k<view->ndim;k++) {
513 addone = _Py_add_one_to_index_F;
516 addone = _Py_add_one_to_index_C;
519 /* XXX : This is not going to be the fastest code in the world
520 several optimizations are possible.
522 elements = len / view->itemsize;
524 addone(view->ndim, indices, view->shape);
525 ptr = PyBuffer_GetPointer(view, indices);
526 memcpy(dest, ptr, view->itemsize);
527 dest += view->itemsize;
534 PyBuffer_FromContiguous(Py_buffer *view, void *buf, Py_ssize_t len, char fort)
537 void (*addone)(int, Py_ssize_t *, const Py_ssize_t *);
538 Py_ssize_t *indices, elements;
541 if (len > view->len) {
545 if (PyBuffer_IsContiguous(view, fort)) {
546 /* simplest copy is all that is needed */
547 memcpy(view->buf, buf, len);
551 /* Otherwise a more elaborate scheme is needed */
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) {
559 for (k=0; k<view->ndim;k++) {
564 addone = _Py_add_one_to_index_F;
567 addone = _Py_add_one_to_index_C;
570 /* XXX : This is not going to be the fastest code in the world
571 several optimizations are possible.
573 elements = len / view->itemsize;
575 addone(view->ndim, indices, view->shape);
576 ptr = PyBuffer_GetPointer(view, indices);
577 memcpy(ptr, src, view->itemsize);
578 src += view->itemsize;
585 int PyObject_CopyData(PyObject *dest, PyObject *src)
587 Py_buffer view_dest, view_src;
589 Py_ssize_t *indices, elements;
592 if (!PyObject_CheckBuffer(dest) ||
593 !PyObject_CheckBuffer(src)) {
594 PyErr_SetString(PyExc_TypeError,
595 "both destination and source must have the "\
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);
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);
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);
625 /* Otherwise a more elaborate copy scheme is needed */
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) {
631 PyBuffer_Release(&view_dest);
632 PyBuffer_Release(&view_src);
635 for (k=0; k<view_src.ndim;k++) {
639 for (k=0; k<view_src.ndim; k++) {
640 /* XXX(nnorwitz): can this overflow? */
641 elements *= view_src.shape[k];
644 _Py_add_one_to_index_C(view_src.ndim, indices, view_src.shape);
645 dptr = PyBuffer_GetPointer(&view_dest, indices);
646 sptr = PyBuffer_GetPointer(&view_src, indices);
647 memcpy(dptr, sptr, view_src.itemsize);
650 PyBuffer_Release(&view_dest);
651 PyBuffer_Release(&view_src);
656 PyBuffer_FillContiguousStrides(int nd, Py_ssize_t *shape,
657 Py_ssize_t *strides, int itemsize,
665 for (k=0; k<nd; k++) {
671 for (k=nd-1; k>=0; k--) {
680 PyBuffer_FillInfo(Py_buffer *view, PyObject *obj, void *buf, Py_ssize_t len,
681 int readonly, int flags)
683 if (view == NULL) return 0;
684 if (((flags & PyBUF_WRITABLE) == PyBUF_WRITABLE) &&
686 PyErr_SetString(PyExc_BufferError,
687 "Object is not writable.");
696 view->readonly = readonly;
699 if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT)
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;
714 PyBuffer_Release(Py_buffer *view)
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);
724 PyObject_Format(PyObject* obj, PyObject *format_spec)
726 PyObject *empty = NULL;
727 PyObject *result = NULL;
728 #ifdef Py_USING_UNICODE
730 int result_is_unicode;
733 /* If no format_spec is provided, use an empty string */
734 if (format_spec == NULL) {
735 empty = PyString_FromStringAndSize(NULL, 0);
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))
743 else if (PyString_Check(format_spec))
747 if (!PyString_Check(format_spec)) {
749 PyErr_Format(PyExc_TypeError,
750 "format expects arg 2 to be string "
751 "or unicode, not %.100s", Py_TYPE(format_spec)->tp_name);
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,
763 Py_DECREF(bound_method);
765 PyObject *self_as_str = NULL;
766 PyObject *format_method = NULL;
767 Py_ssize_t format_len;
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);
781 format_len = PyString_GET_SIZE(format_spec);
782 self_as_str = PyObject_Str(obj);
784 if (self_as_str == NULL)
787 if (format_len > 0) {
788 /* See the almost identical code in
789 typeobject.c for new-style
792 PyExc_PendingDeprecationWarning,
793 "object.__format__ with a non-empty "
794 "format string is deprecated", 1)
798 /* Eventually this will become an
800 PyErr_Format(PyExc_TypeError,
801 "non-empty format string passed to "
802 "object.__format__");
807 /* Then call str.__format__ on that result */
808 format_method = PyObject_GetAttrString(self_as_str, "__format__");
809 if (format_method == NULL) {
812 result = PyObject_CallFunctionObjArgs(format_method,
816 Py_XDECREF(self_as_str);
817 Py_XDECREF(format_method);
822 /* Not an instance of a classic class, use the code
824 static PyObject *format_cache = NULL;
826 /* Find the (unbound!) __format__ method (a borrowed
828 PyObject *method = _PyObject_LookupSpecial(obj, "__format__",
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);
838 result = PyObject_CallFunctionObjArgs(method, format_spec, NULL);
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;
853 if (!PyString_Check(result)) {
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);
864 /* Convert to unicode, if needed. Required if spec is unicode
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 */
880 /* Operations on numbers */
883 PyNumber_Check(PyObject *o)
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);
890 /* Binary operators */
892 /* New style number protocol support */
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]))
901 Calling scheme used for binary operations:
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)
910 [*] only when v->ob_type != w->ob_type && w->ob_type is a subclass of
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.
923 binary_op1(PyObject *v, PyObject *w, const int op_slot)
926 binaryfunc slotv = NULL;
927 binaryfunc slotw = NULL;
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);
938 if (slotw && PyType_IsSubtype(w->ob_type, v->ob_type)) {
940 if (x != Py_NotImplemented)
942 Py_DECREF(x); /* can't do it */
946 if (x != Py_NotImplemented)
948 Py_DECREF(x); /* can't do it */
952 if (x != Py_NotImplemented)
954 Py_DECREF(x); /* can't do it */
956 if (!NEW_STYLE_NUMBER(v) || !NEW_STYLE_NUMBER(w)) {
957 int err = PyNumber_CoerceEx(&v, &w);
962 PyNumberMethods *mv = v->ob_type->tp_as_number;
965 slot = NB_BINOP(mv, op_slot);
973 /* CoerceEx incremented the reference counts */
978 Py_INCREF(Py_NotImplemented);
979 return Py_NotImplemented;
983 binop_type_error(PyObject *v, PyObject *w, const char *op_name)
985 PyErr_Format(PyExc_TypeError,
986 "unsupported operand type(s) for %.100s: "
987 "'%.100s' and '%.100s'",
990 w->ob_type->tp_name);
995 binary_op(PyObject *v, PyObject *w, const int op_slot, const char *op_name)
997 PyObject *result = binary_op1(v, w, op_slot);
998 if (result == Py_NotImplemented) {
1000 return binop_type_error(v, w, op_name);
1007 Calling scheme used for ternary operations:
1009 *** In some cases, w.op is called before v.op; see binary_op1. ***
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)
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.
1035 ternary_op(PyObject *v,
1039 const char *op_name)
1041 PyNumberMethods *mv, *mw, *mz;
1043 ternaryfunc slotv = NULL;
1044 ternaryfunc slotw = NULL;
1045 ternaryfunc slotz = NULL;
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);
1058 if (slotw && PyType_IsSubtype(w->ob_type, v->ob_type)) {
1060 if (x != Py_NotImplemented)
1062 Py_DECREF(x); /* can't do it */
1066 if (x != Py_NotImplemented)
1068 Py_DECREF(x); /* can't do it */
1072 if (x != Py_NotImplemented)
1074 Py_DECREF(x); /* can't do it */
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)
1083 if (x != Py_NotImplemented)
1085 Py_DECREF(x); /* can't do it */
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;
1095 c = PyNumber_Coerce(&v, &w);
1099 /* Special case: if the third argument is None, it is
1100 treated as absent argument and not coerced. */
1102 if (v->ob_type->tp_as_number) {
1103 slotz = NB_TERNOP(v->ob_type->tp_as_number,
1116 c = PyNumber_Coerce(&v1, &z1);
1121 c = PyNumber_Coerce(&w2, &z2);
1125 if (v1->ob_type->tp_as_number != NULL) {
1126 slotv = NB_TERNOP(v1->ob_type->tp_as_number,
1129 x = slotv(v1, w2, z2);
1152 "unsupported operand type(s) for ** or pow(): "
1153 "'%.100s' and '%.100s'",
1154 v->ob_type->tp_name,
1155 w->ob_type->tp_name);
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);
1167 #define BINARY_FUNC(func, op, op_name) \
1169 func(PyObject *v, PyObject *w) { \
1170 return binary_op(v, w, NB_SLOT(op), op_name); \
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()")
1183 PyNumber_Add(PyObject *v, PyObject *w)
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;
1189 if (m && m->sq_concat) {
1190 return (*m->sq_concat)(v, w);
1192 result = binop_type_error(v, w, "+");
1198 sequence_repeat(ssizeargfunc repeatfunc, PyObject *seq, PyObject *n)
1201 if (PyIndex_Check(n)) {
1202 count = PyNumber_AsSsize_t(n, PyExc_OverflowError);
1203 if (count == -1 && PyErr_Occurred())
1207 return type_error("can't multiply sequence by "
1208 "non-int of type '%.200s'", n);
1210 return (*repeatfunc)(seq, count);
1214 PyNumber_Multiply(PyObject *v, PyObject *w)
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;
1221 if (mv && mv->sq_repeat) {
1222 return sequence_repeat(mv->sq_repeat, v, w);
1224 else if (mw && mw->sq_repeat) {
1225 return sequence_repeat(mw->sq_repeat, w, v);
1227 result = binop_type_error(v, w, "*");
1233 PyNumber_FloorDivide(PyObject *v, PyObject *w)
1235 /* XXX tp_flags test */
1236 return binary_op(v, w, NB_SLOT(nb_floor_divide), "//");
1240 PyNumber_TrueDivide(PyObject *v, PyObject *w)
1242 /* XXX tp_flags test */
1243 return binary_op(v, w, NB_SLOT(nb_true_divide), "/");
1247 PyNumber_Remainder(PyObject *v, PyObject *w)
1249 return binary_op(v, w, NB_SLOT(nb_remainder), "%");
1253 PyNumber_Power(PyObject *v, PyObject *w, PyObject *z)
1255 return ternary_op(v, w, z, NB_SLOT(nb_power), "** or pow()");
1258 /* Binary in-place operators */
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.
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.
1269 - Otherwise, in-place modification is not supported. Handle it exactly as
1270 a non in-place operation of the same kind.
1274 #define HASINPLACE(t) \
1275 PyType_HasFeature((t)->ob_type, Py_TPFLAGS_HAVE_INPLACEOPS)
1278 binary_iop1(PyObject *v, PyObject *w, const int iop_slot, const int op_slot)
1280 PyNumberMethods *mv = v->ob_type->tp_as_number;
1281 if (mv != NULL && HASINPLACE(v)) {
1282 binaryfunc slot = NB_BINOP(mv, iop_slot);
1284 PyObject *x = (slot)(v, w);
1285 if (x != Py_NotImplemented) {
1291 return binary_op1(v, w, op_slot);
1295 binary_iop(PyObject *v, PyObject *w, const int iop_slot, const int op_slot,
1296 const char *op_name)
1298 PyObject *result = binary_iop1(v, w, iop_slot, op_slot);
1299 if (result == Py_NotImplemented) {
1301 return binop_type_error(v, w, op_name);
1306 #define INPLACE_BINOP(func, iop, op, op_name) \
1308 func(PyObject *v, PyObject *w) { \
1309 return binary_iop(v, w, NB_SLOT(iop), NB_SLOT(op), op_name); \
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, "/=")
1321 PyNumber_InPlaceFloorDivide(PyObject *v, PyObject *w)
1323 /* XXX tp_flags test */
1324 return binary_iop(v, w, NB_SLOT(nb_inplace_floor_divide),
1325 NB_SLOT(nb_floor_divide), "//=");
1329 PyNumber_InPlaceTrueDivide(PyObject *v, PyObject *w)
1331 /* XXX tp_flags test */
1332 return binary_iop(v, w, NB_SLOT(nb_inplace_true_divide),
1333 NB_SLOT(nb_true_divide), "/=");
1337 PyNumber_InPlaceAdd(PyObject *v, PyObject *w)
1339 PyObject *result = binary_iop1(v, w, NB_SLOT(nb_inplace_add),
1341 if (result == Py_NotImplemented) {
1342 PySequenceMethods *m = v->ob_type->tp_as_sequence;
1345 binaryfunc f = NULL;
1347 f = m->sq_inplace_concat;
1353 result = binop_type_error(v, w, "+=");
1359 PyNumber_InPlaceMultiply(PyObject *v, PyObject *w)
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;
1370 f = mv->sq_inplace_repeat;
1374 return sequence_repeat(f, v, w);
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
1381 return sequence_repeat(mw->sq_repeat, w, v);
1383 result = binop_type_error(v, w, "*=");
1389 PyNumber_InPlaceRemainder(PyObject *v, PyObject *w)
1391 return binary_iop(v, w, NB_SLOT(nb_inplace_remainder),
1392 NB_SLOT(nb_remainder), "%=");
1396 PyNumber_InPlacePower(PyObject *v, PyObject *w, PyObject *z)
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), "**=");
1403 return ternary_op(v, w, z, NB_SLOT(nb_power), "**=");
1408 /* Unary operators and functions */
1411 PyNumber_Negative(PyObject *o)
1416 return null_error();
1417 m = o->ob_type->tp_as_number;
1418 if (m && m->nb_negative)
1419 return (*m->nb_negative)(o);
1421 return type_error("bad operand type for unary -: '%.200s'", o);
1425 PyNumber_Positive(PyObject *o)
1430 return null_error();
1431 m = o->ob_type->tp_as_number;
1432 if (m && m->nb_positive)
1433 return (*m->nb_positive)(o);
1435 return type_error("bad operand type for unary +: '%.200s'", o);
1439 PyNumber_Invert(PyObject *o)
1444 return null_error();
1445 m = o->ob_type->tp_as_number;
1446 if (m && m->nb_invert)
1447 return (*m->nb_invert)(o);
1449 return type_error("bad operand type for unary ~: '%.200s'", o);
1453 PyNumber_Absolute(PyObject *o)
1458 return null_error();
1459 m = o->ob_type->tp_as_number;
1460 if (m && m->nb_absolute)
1461 return m->nb_absolute(o);
1463 return type_error("bad operand type for abs(): '%.200s'", o);
1466 /* Add a check for embedded NULL-bytes in the argument. */
1468 int_from_string(const char *s, Py_ssize_t len)
1473 x = PyInt_FromString((char*)s, &end, 10);
1476 if (end != s + len) {
1477 PyErr_SetString(PyExc_ValueError,
1478 "null byte in argument for int()");
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.
1490 PyNumber_Index(PyObject *item)
1492 PyObject *result = NULL;
1494 return null_error();
1495 if (PyInt_Check(item) || PyLong_Check(item)) {
1499 if (PyIndex_Check(item)) {
1500 result = item->ob_type->tp_as_number->nb_index(item);
1502 !PyInt_Check(result) && !PyLong_Check(result)) {
1503 PyErr_Format(PyExc_TypeError,
1504 "__index__ returned non-(int,long) " \
1506 result->ob_type->tp_name);
1512 PyErr_Format(PyExc_TypeError,
1513 "'%.200s' object cannot be interpreted "
1514 "as an index", item->ob_type->tp_name);
1519 /* Return an error on Overflow only if err is not NULL*/
1522 PyNumber_AsSsize_t(PyObject *item, PyObject *err)
1526 PyObject *value = PyNumber_Index(item);
1530 /* We're done if PyInt_AsSsize_t() returns without error. */
1531 result = PyInt_AsSsize_t(value);
1532 if (result != -1 || !(runerr = PyErr_Occurred()))
1535 /* Error handling code -- only manage OverflowError differently */
1536 if (!PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError))
1540 /* If no error-handling desired then the default clipping
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
1548 if (_PyLong_Sign(value) < 0)
1549 result = PY_SSIZE_T_MIN;
1551 result = PY_SSIZE_T_MAX;
1554 /* Otherwise replace the error with caller's error object. */
1556 "cannot fit '%.200s' into an index-sized integer",
1557 item->ob_type->tp_name);
1567 _PyNumber_ConvertIntegralToInt(PyObject *integral, const char* error_format)
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)
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;
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;
1597 if (PyInstance_Check(integral)) {
1598 type_name = PyString_AS_STRING(((PyInstanceObject *)integral)
1599 ->in_class->cl_name);
1602 type_name = integral->ob_type->tp_name;
1604 PyErr_Format(PyExc_TypeError, error_format, type_name);
1605 Py_DECREF(integral);
1611 PyNumber_Int(PyObject *o)
1614 static PyObject *trunc_name = NULL;
1615 PyObject *trunc_func;
1617 Py_ssize_t buffer_len;
1619 if (trunc_name == NULL) {
1620 trunc_name = PyString_InternFromString("__trunc__");
1621 if (trunc_name == NULL)
1626 return null_error();
1627 if (PyInt_CheckExact(o)) {
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);
1644 if (PyInt_Check(o)) { /* A int subclass without nb_int */
1645 PyIntObject *io = (PyIntObject*)o;
1646 return PyInt_FromLong(io->ob_ival);
1648 trunc_func = PyObject_GetAttr(o, trunc_name);
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(
1656 "__trunc__ returned non-Integral (type %.200s)");
1658 PyErr_Clear(); /* It's not an error if o.__trunc__ doesn't exist. */
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),
1669 if (!PyObject_AsCharBuffer(o, &buffer, &buffer_len))
1670 return int_from_string((char*)buffer, buffer_len);
1672 return type_error("int() argument must be a string or a "
1673 "number, not '%.200s'", o);
1676 /* Add a check for embedded NULL-bytes in the argument. */
1678 long_from_string(const char *s, Py_ssize_t len)
1683 x = PyLong_FromString((char*)s, &end, 10);
1686 if (end != s + len) {
1687 PyErr_SetString(PyExc_ValueError,
1688 "null byte in argument for long()");
1696 PyNumber_Long(PyObject *o)
1699 static PyObject *trunc_name = NULL;
1700 PyObject *trunc_func;
1702 Py_ssize_t buffer_len;
1704 if (trunc_name == NULL) {
1705 trunc_name = PyString_InternFromString("__trunc__");
1706 if (trunc_name == 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);
1718 if (PyInt_Check(res)) {
1719 long value = PyInt_AS_LONG(res);
1721 return PyLong_FromLong(value);
1723 else if (!PyLong_Check(res)) {
1724 PyErr_Format(PyExc_TypeError,
1725 "__long__ returned non-long (type %.200s)",
1726 res->ob_type->tp_name);
1732 if (PyLong_Check(o)) /* A long subclass without nb_long */
1733 return _PyLong_Copy((PyLongObject *)o);
1734 trunc_func = PyObject_GetAttr(o, trunc_name);
1736 PyObject *truncated = PyEval_CallObject(trunc_func, NULL);
1737 PyObject *int_instance;
1738 Py_DECREF(trunc_func);
1739 /* __trunc__ is specified to return an Integral type,
1740 but long() needs to return a long. */
1741 int_instance = _PyNumber_ConvertIntegralToInt(
1743 "__trunc__ returned non-Integral (type %.200s)");
1744 if (int_instance && PyInt_Check(int_instance)) {
1745 /* Make sure that long() returns a long instance. */
1746 long value = PyInt_AS_LONG(int_instance);
1747 Py_DECREF(int_instance);
1748 return PyLong_FromLong(value);
1750 return int_instance;
1752 PyErr_Clear(); /* It's not an error if o.__trunc__ doesn't exist. */
1754 if (PyString_Check(o))
1755 /* need to do extra error checking that PyLong_FromString()
1756 * doesn't do. In particular long('9.5') must raise an
1757 * exception, not truncate the float.
1759 return long_from_string(PyString_AS_STRING(o),
1760 PyString_GET_SIZE(o));
1761 #ifdef Py_USING_UNICODE
1762 if (PyUnicode_Check(o))
1763 /* The above check is done in PyLong_FromUnicode(). */
1764 return PyLong_FromUnicode(PyUnicode_AS_UNICODE(o),
1765 PyUnicode_GET_SIZE(o),
1768 if (!PyObject_AsCharBuffer(o, &buffer, &buffer_len))
1769 return long_from_string(buffer, buffer_len);
1771 return type_error("long() argument must be a string or a "
1772 "number, not '%.200s'", o);
1776 PyNumber_Float(PyObject *o)
1781 return null_error();
1782 m = o->ob_type->tp_as_number;
1783 if (m && m->nb_float) { /* This should include subclasses of float */
1784 PyObject *res = m->nb_float(o);
1785 if (res && !PyFloat_Check(res)) {
1786 PyErr_Format(PyExc_TypeError,
1787 "__float__ returned non-float (type %.200s)",
1788 res->ob_type->tp_name);
1794 if (PyFloat_Check(o)) { /* A float subclass with nb_float == NULL */
1795 PyFloatObject *po = (PyFloatObject *)o;
1796 return PyFloat_FromDouble(po->ob_fval);
1798 return PyFloat_FromString(o, NULL);
1802 PyNumber_ToBase(PyObject *n, int base)
1804 PyObject *res = NULL;
1805 PyObject *index = PyNumber_Index(n);
1809 if (PyLong_Check(index))
1810 res = _PyLong_Format(index, base, 0, 1);
1811 else if (PyInt_Check(index))
1812 res = _PyInt_Format((PyIntObject*)index, base, 1);
1814 /* It should not be possible to get here, as
1815 PyNumber_Index already has a check for the same
1817 PyErr_SetString(PyExc_ValueError, "PyNumber_ToBase: index not "
1824 /* Operations on sequences */
1827 PySequence_Check(PyObject *s)
1831 if (PyInstance_Check(s))
1832 return PyObject_HasAttrString(s, "__getitem__");
1833 if (PyDict_Check(s))
1835 return s->ob_type->tp_as_sequence &&
1836 s->ob_type->tp_as_sequence->sq_item != NULL;
1840 PySequence_Size(PyObject *s)
1842 PySequenceMethods *m;
1849 m = s->ob_type->tp_as_sequence;
1850 if (m && m->sq_length)
1851 return m->sq_length(s);
1853 type_error("object of type '%.200s' has no len()", s);
1857 #undef PySequence_Length
1859 PySequence_Length(PyObject *s)
1861 return PySequence_Size(s);
1863 #define PySequence_Length PySequence_Size
1866 PySequence_Concat(PyObject *s, PyObject *o)
1868 PySequenceMethods *m;
1870 if (s == NULL || o == NULL)
1871 return null_error();
1873 m = s->ob_type->tp_as_sequence;
1874 if (m && m->sq_concat)
1875 return m->sq_concat(s, o);
1877 /* Instances of user classes defining an __add__() method only
1878 have an nb_add slot, not an sq_concat slot. So we fall back
1879 to nb_add if both arguments appear to be sequences. */
1880 if (PySequence_Check(s) && PySequence_Check(o)) {
1881 PyObject *result = binary_op1(s, o, NB_SLOT(nb_add));
1882 if (result != Py_NotImplemented)
1886 return type_error("'%.200s' object can't be concatenated", s);
1890 PySequence_Repeat(PyObject *o, Py_ssize_t count)
1892 PySequenceMethods *m;
1895 return null_error();
1897 m = o->ob_type->tp_as_sequence;
1898 if (m && m->sq_repeat)
1899 return m->sq_repeat(o, count);
1901 /* Instances of user classes defining a __mul__() method only
1902 have an nb_multiply slot, not an sq_repeat slot. so we fall back
1903 to nb_multiply if o appears to be a sequence. */
1904 if (PySequence_Check(o)) {
1905 PyObject *n, *result;
1906 n = PyInt_FromSsize_t(count);
1909 result = binary_op1(o, n, NB_SLOT(nb_multiply));
1911 if (result != Py_NotImplemented)
1915 return type_error("'%.200s' object can't be repeated", o);
1919 PySequence_InPlaceConcat(PyObject *s, PyObject *o)
1921 PySequenceMethods *m;
1923 if (s == NULL || o == NULL)
1924 return null_error();
1926 m = s->ob_type->tp_as_sequence;
1927 if (m && HASINPLACE(s) && m->sq_inplace_concat)
1928 return m->sq_inplace_concat(s, o);
1929 if (m && m->sq_concat)
1930 return m->sq_concat(s, o);
1932 if (PySequence_Check(s) && PySequence_Check(o)) {
1933 PyObject *result = binary_iop1(s, o, NB_SLOT(nb_inplace_add),
1935 if (result != Py_NotImplemented)
1939 return type_error("'%.200s' object can't be concatenated", s);
1943 PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count)
1945 PySequenceMethods *m;
1948 return null_error();
1950 m = o->ob_type->tp_as_sequence;
1951 if (m && HASINPLACE(o) && m->sq_inplace_repeat)
1952 return m->sq_inplace_repeat(o, count);
1953 if (m && m->sq_repeat)
1954 return m->sq_repeat(o, count);
1956 if (PySequence_Check(o)) {
1957 PyObject *n, *result;
1958 n = PyInt_FromSsize_t(count);
1961 result = binary_iop1(o, n, NB_SLOT(nb_inplace_multiply),
1962 NB_SLOT(nb_multiply));
1964 if (result != Py_NotImplemented)
1968 return type_error("'%.200s' object can't be repeated", o);
1972 PySequence_GetItem(PyObject *s, Py_ssize_t i)
1974 PySequenceMethods *m;
1977 return null_error();
1979 m = s->ob_type->tp_as_sequence;
1980 if (m && m->sq_item) {
1983 Py_ssize_t l = (*m->sq_length)(s);
1989 return m->sq_item(s, i);
1992 return type_error("'%.200s' object does not support indexing", s);
1996 PySequence_GetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2)
1998 PySequenceMethods *m;
1999 PyMappingMethods *mp;
2001 if (!s) return null_error();
2003 m = s->ob_type->tp_as_sequence;
2004 if (m && m->sq_slice) {
2005 if (i1 < 0 || i2 < 0) {
2007 Py_ssize_t l = (*m->sq_length)(s);
2016 return m->sq_slice(s, i1, i2);
2017 } else if ((mp = s->ob_type->tp_as_mapping) && mp->mp_subscript) {
2019 PyObject *slice = _PySlice_FromIndices(i1, i2);
2022 res = mp->mp_subscript(s, slice);
2027 return type_error("'%.200s' object is unsliceable", s);
2031 PySequence_SetItem(PyObject *s, Py_ssize_t i, PyObject *o)
2033 PySequenceMethods *m;
2040 m = s->ob_type->tp_as_sequence;
2041 if (m && m->sq_ass_item) {
2044 Py_ssize_t l = (*m->sq_length)(s);
2050 return m->sq_ass_item(s, i, o);
2053 type_error("'%.200s' object does not support item assignment", s);
2058 PySequence_DelItem(PyObject *s, Py_ssize_t i)
2060 PySequenceMethods *m;
2067 m = s->ob_type->tp_as_sequence;
2068 if (m && m->sq_ass_item) {
2071 Py_ssize_t l = (*m->sq_length)(s);
2077 return m->sq_ass_item(s, i, (PyObject *)NULL);
2080 type_error("'%.200s' object doesn't support item deletion", s);
2085 PySequence_SetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2, PyObject *o)
2087 PySequenceMethods *m;
2088 PyMappingMethods *mp;
2095 m = s->ob_type->tp_as_sequence;
2096 if (m && m->sq_ass_slice) {
2097 if (i1 < 0 || i2 < 0) {
2099 Py_ssize_t l = (*m->sq_length)(s);
2108 return m->sq_ass_slice(s, i1, i2, o);
2109 } else if ((mp = s->ob_type->tp_as_mapping) && mp->mp_ass_subscript) {
2111 PyObject *slice = _PySlice_FromIndices(i1, i2);
2114 res = mp->mp_ass_subscript(s, slice, o);
2119 type_error("'%.200s' object doesn't support slice assignment", s);
2124 PySequence_DelSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2)
2126 PySequenceMethods *m;
2133 m = s->ob_type->tp_as_sequence;
2134 if (m && m->sq_ass_slice) {
2135 if (i1 < 0 || i2 < 0) {
2137 Py_ssize_t l = (*m->sq_length)(s);
2146 return m->sq_ass_slice(s, i1, i2, (PyObject *)NULL);
2148 type_error("'%.200s' object doesn't support slice deletion", s);
2153 PySequence_Tuple(PyObject *v)
2155 PyObject *it; /* iter(v) */
2156 Py_ssize_t n; /* guess for result tuple size */
2157 PyObject *result = NULL;
2161 return null_error();
2163 /* Special-case the common tuple and list cases, for efficiency. */
2164 if (PyTuple_CheckExact(v)) {
2165 /* Note that we can't know whether it's safe to return
2166 a tuple *subclass* instance as-is, hence the restriction
2167 to exact tuples here. In contrast, lists always make
2168 a copy, so there's no need for exactness below. */
2172 if (PyList_Check(v))
2173 return PyList_AsTuple(v);
2176 it = PyObject_GetIter(v);
2180 /* Guess result size and allocate space. */
2181 n = _PyObject_LengthHint(v, 10);
2184 result = PyTuple_New(n);
2188 /* Fill the tuple. */
2189 for (j = 0; ; ++j) {
2190 PyObject *item = PyIter_Next(it);
2192 if (PyErr_Occurred())
2197 Py_ssize_t oldn = n;
2198 /* The over-allocation strategy can grow a bit faster
2199 than for lists because unlike lists the
2200 over-allocation isn't permanent -- we reclaim
2201 the excess before the end of this routine.
2202 So, grow by ten and then add 25%.
2207 /* Check for overflow */
2212 if (_PyTuple_Resize(&result, n) != 0) {
2217 PyTuple_SET_ITEM(result, j, item);
2220 /* Cut tuple back if guess was too large. */
2222 _PyTuple_Resize(&result, j) != 0)
2235 PySequence_List(PyObject *v)
2237 PyObject *result; /* result list */
2238 PyObject *rv; /* return value from PyList_Extend */
2241 return null_error();
2243 result = PyList_New(0);
2247 rv = _PyList_Extend((PyListObject *)result, v);
2257 PySequence_Fast(PyObject *v, const char *m)
2262 return null_error();
2264 if (PyList_CheckExact(v) || PyTuple_CheckExact(v)) {
2269 it = PyObject_GetIter(v);
2271 if (PyErr_ExceptionMatches(PyExc_TypeError))
2272 PyErr_SetString(PyExc_TypeError, m);
2276 v = PySequence_List(it);
2282 /* Iterate over seq. Result depends on the operation:
2283 PY_ITERSEARCH_COUNT: -1 if error, else # of times obj appears in seq.
2284 PY_ITERSEARCH_INDEX: 0-based index of first occurrence of obj in seq;
2285 set ValueError and return -1 if none found; also return -1 on error.
2286 Py_ITERSEARCH_CONTAINS: return 1 if obj in seq, else 0; -1 on error.
2289 _PySequence_IterSearch(PyObject *seq, PyObject *obj, int operation)
2292 int wrapped; /* for PY_ITERSEARCH_INDEX, true iff n wrapped around */
2293 PyObject *it; /* iter(seq) */
2295 if (seq == NULL || obj == NULL) {
2300 it = PyObject_GetIter(seq);
2302 type_error("argument of type '%.200s' is not iterable", seq);
2309 PyObject *item = PyIter_Next(it);
2311 if (PyErr_Occurred())
2316 cmp = PyObject_RichCompareBool(obj, item, Py_EQ);
2321 switch (operation) {
2322 case PY_ITERSEARCH_COUNT:
2323 if (n == PY_SSIZE_T_MAX) {
2324 PyErr_SetString(PyExc_OverflowError,
2325 "count exceeds C integer size");
2331 case PY_ITERSEARCH_INDEX:
2333 PyErr_SetString(PyExc_OverflowError,
2334 "index exceeds C integer size");
2339 case PY_ITERSEARCH_CONTAINS:
2344 assert(!"unknown operation");
2348 if (operation == PY_ITERSEARCH_INDEX) {
2349 if (n == PY_SSIZE_T_MAX)
2355 if (operation != PY_ITERSEARCH_INDEX)
2358 PyErr_SetString(PyExc_ValueError,
2359 "sequence.index(x): x not in sequence");
2360 /* fall into failure code */
2370 /* Return # of times o appears in s. */
2372 PySequence_Count(PyObject *s, PyObject *o)
2374 return _PySequence_IterSearch(s, o, PY_ITERSEARCH_COUNT);
2377 /* Return -1 if error; 1 if ob in seq; 0 if ob not in seq.
2378 * Use sq_contains if possible, else defer to _PySequence_IterSearch().
2381 PySequence_Contains(PyObject *seq, PyObject *ob)
2384 if (PyType_HasFeature(seq->ob_type, Py_TPFLAGS_HAVE_SEQUENCE_IN)) {
2385 PySequenceMethods *sqm = seq->ob_type->tp_as_sequence;
2386 if (sqm != NULL && sqm->sq_contains != NULL)
2387 return (*sqm->sq_contains)(seq, ob);
2389 result = _PySequence_IterSearch(seq, ob, PY_ITERSEARCH_CONTAINS);
2390 return Py_SAFE_DOWNCAST(result, Py_ssize_t, int);
2393 /* Backwards compatibility */
2394 #undef PySequence_In
2396 PySequence_In(PyObject *w, PyObject *v)
2398 return PySequence_Contains(w, v);
2402 PySequence_Index(PyObject *s, PyObject *o)
2404 return _PySequence_IterSearch(s, o, PY_ITERSEARCH_INDEX);
2407 /* Operations on mappings */
2410 PyMapping_Check(PyObject *o)
2412 if (o && PyInstance_Check(o))
2413 return PyObject_HasAttrString(o, "__getitem__");
2415 return o && o->ob_type->tp_as_mapping &&
2416 o->ob_type->tp_as_mapping->mp_subscript &&
2417 !(o->ob_type->tp_as_sequence &&
2418 o->ob_type->tp_as_sequence->sq_slice);
2422 PyMapping_Size(PyObject *o)
2424 PyMappingMethods *m;
2431 m = o->ob_type->tp_as_mapping;
2432 if (m && m->mp_length)
2433 return m->mp_length(o);
2435 type_error("object of type '%.200s' has no len()", o);
2439 #undef PyMapping_Length
2441 PyMapping_Length(PyObject *o)
2443 return PyMapping_Size(o);
2445 #define PyMapping_Length PyMapping_Size
2448 PyMapping_GetItemString(PyObject *o, char *key)
2453 return null_error();
2455 okey = PyString_FromString(key);
2458 r = PyObject_GetItem(o, okey);
2464 PyMapping_SetItemString(PyObject *o, char *key, PyObject *value)
2474 okey = PyString_FromString(key);
2477 r = PyObject_SetItem(o, okey, value);
2483 PyMapping_HasKeyString(PyObject *o, char *key)
2487 v = PyMapping_GetItemString(o, key);
2497 PyMapping_HasKey(PyObject *o, PyObject *key)
2501 v = PyObject_GetItem(o, key);
2510 /* Operations on callable objects */
2512 /* XXX PyCallable_Check() is in object.c */
2515 PyObject_CallObject(PyObject *o, PyObject *a)
2517 return PyEval_CallObjectWithKeywords(o, a, NULL);
2521 PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw)
2525 if ((call = func->ob_type->tp_call) != NULL) {
2527 if (Py_EnterRecursiveCall(" while calling a Python object"))
2529 result = (*call)(func, arg, kw);
2530 Py_LeaveRecursiveCall();
2531 if (result == NULL && !PyErr_Occurred())
2534 "NULL result without error in PyObject_Call");
2537 PyErr_Format(PyExc_TypeError, "'%.200s' object is not callable",
2538 func->ob_type->tp_name);
2543 call_function_tail(PyObject *callable, PyObject *args)
2550 if (!PyTuple_Check(args)) {
2558 PyTuple_SET_ITEM(a, 0, args);
2561 retval = PyObject_Call(callable, args, NULL);
2569 PyObject_CallFunction(PyObject *callable, char *format, ...)
2574 if (callable == NULL)
2575 return null_error();
2577 if (format && *format) {
2578 va_start(va, format);
2579 args = Py_VaBuildValue(format, va);
2583 args = PyTuple_New(0);
2585 return call_function_tail(callable, args);
2589 _PyObject_CallFunction_SizeT(PyObject *callable, char *format, ...)
2594 if (callable == NULL)
2595 return null_error();
2597 if (format && *format) {
2598 va_start(va, format);
2599 args = _Py_VaBuildValue_SizeT(format, va);
2603 args = PyTuple_New(0);
2605 return call_function_tail(callable, args);
2609 PyObject_CallMethod(PyObject *o, char *name, char *format, ...)
2613 PyObject *func = NULL;
2614 PyObject *retval = NULL;
2616 if (o == NULL || name == NULL)
2617 return null_error();
2619 func = PyObject_GetAttrString(o, name);
2621 PyErr_SetString(PyExc_AttributeError, name);
2625 if (!PyCallable_Check(func)) {
2626 type_error("attribute of type '%.200s' is not callable", func);
2630 if (format && *format) {
2631 va_start(va, format);
2632 args = Py_VaBuildValue(format, va);
2636 args = PyTuple_New(0);
2638 retval = call_function_tail(func, args);
2641 /* args gets consumed in call_function_tail */
2648 _PyObject_CallMethod_SizeT(PyObject *o, char *name, char *format, ...)
2652 PyObject *func = NULL;
2653 PyObject *retval = NULL;
2655 if (o == NULL || name == NULL)
2656 return null_error();
2658 func = PyObject_GetAttrString(o, name);
2660 PyErr_SetString(PyExc_AttributeError, name);
2664 if (!PyCallable_Check(func)) {
2665 type_error("attribute of type '%.200s' is not callable", func);
2669 if (format && *format) {
2670 va_start(va, format);
2671 args = _Py_VaBuildValue_SizeT(format, va);
2675 args = PyTuple_New(0);
2677 retval = call_function_tail(func, args);
2680 /* args gets consumed in call_function_tail */
2688 objargs_mktuple(va_list va)
2692 PyObject *result, *tmp;
2694 #ifdef VA_LIST_IS_ARRAY
2695 memcpy(countva, va, sizeof(va_list));
2698 __va_copy(countva, va);
2704 while (((PyObject *)va_arg(countva, PyObject *)) != NULL)
2706 result = PyTuple_New(n);
2707 if (result != NULL && n > 0) {
2708 for (i = 0; i < n; ++i) {
2709 tmp = (PyObject *)va_arg(va, PyObject *);
2710 PyTuple_SET_ITEM(result, i, tmp);
2718 PyObject_CallMethodObjArgs(PyObject *callable, PyObject *name, ...)
2720 PyObject *args, *tmp;
2723 if (callable == NULL || name == NULL)
2724 return null_error();
2726 callable = PyObject_GetAttr(callable, name);
2727 if (callable == NULL)
2730 /* count the args */
2731 va_start(vargs, name);
2732 args = objargs_mktuple(vargs);
2735 Py_DECREF(callable);
2738 tmp = PyObject_Call(callable, args, NULL);
2740 Py_DECREF(callable);
2746 PyObject_CallFunctionObjArgs(PyObject *callable, ...)
2748 PyObject *args, *tmp;
2751 if (callable == NULL)
2752 return null_error();
2754 /* count the args */
2755 va_start(vargs, callable);
2756 args = objargs_mktuple(vargs);
2760 tmp = PyObject_Call(callable, args, NULL);
2767 /* isinstance(), issubclass() */
2769 /* abstract_get_bases() has logically 4 return states, with a sort of 0th
2770 * state that will almost never happen.
2772 * 0. creating the __bases__ static string could get a MemoryError
2773 * 1. getattr(cls, '__bases__') could raise an AttributeError
2774 * 2. getattr(cls, '__bases__') could raise some other exception
2775 * 3. getattr(cls, '__bases__') could return a tuple
2776 * 4. getattr(cls, '__bases__') could return something other than a tuple
2778 * Only state #3 is a non-error state and only it returns a non-NULL object
2779 * (it returns the retrieved tuple).
2781 * Any raised AttributeErrors are masked by clearing the exception and
2782 * returning NULL. If an object other than a tuple comes out of __bases__,
2783 * then again, the return value is NULL. So yes, these two situations
2784 * produce exactly the same results: NULL is returned and no error is set.
2786 * If some exception other than AttributeError is raised, then NULL is also
2787 * returned, but the exception is not cleared. That's because we want the
2788 * exception to be propagated along.
2790 * Callers are expected to test for PyErr_Occurred() when the return value
2791 * is NULL to decide whether a valid exception should be propagated or not.
2792 * When there's no exception to propagate, it's customary for the caller to
2796 abstract_get_bases(PyObject *cls)
2798 static PyObject *__bases__ = NULL;
2801 if (__bases__ == NULL) {
2802 __bases__ = PyString_InternFromString("__bases__");
2803 if (__bases__ == NULL)
2806 bases = PyObject_GetAttr(cls, __bases__);
2807 if (bases == NULL) {
2808 if (PyErr_ExceptionMatches(PyExc_AttributeError))
2812 if (!PyTuple_Check(bases)) {
2821 abstract_issubclass(PyObject *derived, PyObject *cls)
2823 PyObject *bases = NULL;
2830 bases = abstract_get_bases(derived);
2831 if (bases == NULL) {
2832 if (PyErr_Occurred())
2836 n = PyTuple_GET_SIZE(bases);
2841 /* Avoid recursivity in the single inheritance case */
2843 derived = PyTuple_GET_ITEM(bases, 0);
2847 for (i = 0; i < n; i++) {
2848 r = abstract_issubclass(PyTuple_GET_ITEM(bases, i), cls);
2858 check_class(PyObject *cls, const char *error)
2860 PyObject *bases = abstract_get_bases(cls);
2861 if (bases == NULL) {
2862 /* Do not mask errors. */
2863 if (!PyErr_Occurred())
2864 PyErr_SetString(PyExc_TypeError, error);
2872 recursive_isinstance(PyObject *inst, PyObject *cls)
2875 static PyObject *__class__ = NULL;
2878 if (__class__ == NULL) {
2879 __class__ = PyString_InternFromString("__class__");
2880 if (__class__ == NULL)
2884 if (PyClass_Check(cls) && PyInstance_Check(inst)) {
2886 (PyObject*)((PyInstanceObject*)inst)->in_class;
2887 retval = PyClass_IsSubclass(inclass, cls);
2889 else if (PyType_Check(cls)) {
2890 retval = PyObject_TypeCheck(inst, (PyTypeObject *)cls);
2892 PyObject *c = PyObject_GetAttr(inst, __class__);
2897 if (c != (PyObject *)(inst->ob_type) &&
2899 retval = PyType_IsSubtype(
2901 (PyTypeObject *)cls);
2907 if (!check_class(cls,
2908 "isinstance() arg 2 must be a class, type,"
2909 " or tuple of classes and types"))
2911 icls = PyObject_GetAttr(inst, __class__);
2917 retval = abstract_issubclass(icls, cls);
2926 PyObject_IsInstance(PyObject *inst, PyObject *cls)
2928 static PyObject *name = NULL;
2930 /* Quick test for an exact match */
2931 if (Py_TYPE(inst) == (PyTypeObject *)cls)
2934 if (PyTuple_Check(cls)) {
2939 if (Py_EnterRecursiveCall(" in __instancecheck__"))
2941 n = PyTuple_GET_SIZE(cls);
2942 for (i = 0; i < n; ++i) {
2943 PyObject *item = PyTuple_GET_ITEM(cls, i);
2944 r = PyObject_IsInstance(inst, item);
2946 /* either found it, or got an error */
2949 Py_LeaveRecursiveCall();
2953 if (!(PyClass_Check(cls) || PyInstance_Check(cls))) {
2955 checker = _PyObject_LookupSpecial(cls, "__instancecheck__", &name);
2956 if (checker != NULL) {
2959 if (Py_EnterRecursiveCall(" in __instancecheck__")) {
2963 res = PyObject_CallFunctionObjArgs(checker, inst, NULL);
2964 Py_LeaveRecursiveCall();
2967 ok = PyObject_IsTrue(res);
2972 else if (PyErr_Occurred())
2975 return recursive_isinstance(inst, cls);
2979 recursive_issubclass(PyObject *derived, PyObject *cls)
2983 if (PyType_Check(cls) && PyType_Check(derived)) {
2984 /* Fast path (non-recursive) */
2985 return PyType_IsSubtype(
2986 (PyTypeObject *)derived, (PyTypeObject *)cls);
2988 if (!PyClass_Check(derived) || !PyClass_Check(cls)) {
2989 if (!check_class(derived,
2990 "issubclass() arg 1 must be a class"))
2993 if (!check_class(cls,
2994 "issubclass() arg 2 must be a class"
2995 " or tuple of classes"))
2997 retval = abstract_issubclass(derived, cls);
3001 if (!(retval = (derived == cls)))
3002 retval = PyClass_IsSubclass(derived, cls);
3009 PyObject_IsSubclass(PyObject *derived, PyObject *cls)
3011 static PyObject *name = NULL;
3013 if (PyTuple_Check(cls)) {
3018 if (Py_EnterRecursiveCall(" in __subclasscheck__"))
3020 n = PyTuple_GET_SIZE(cls);
3021 for (i = 0; i < n; ++i) {
3022 PyObject *item = PyTuple_GET_ITEM(cls, i);
3023 r = PyObject_IsSubclass(derived, item);
3025 /* either found it, or got an error */
3028 Py_LeaveRecursiveCall();
3031 if (!(PyClass_Check(cls) || PyInstance_Check(cls))) {
3033 checker = _PyObject_LookupSpecial(cls, "__subclasscheck__", &name);
3034 if (checker != NULL) {
3037 if (Py_EnterRecursiveCall(" in __subclasscheck__")) {
3041 res = PyObject_CallFunctionObjArgs(checker, derived, NULL);
3042 Py_LeaveRecursiveCall();
3045 ok = PyObject_IsTrue(res);
3050 else if (PyErr_Occurred()) {
3054 return recursive_issubclass(derived, cls);
3058 _PyObject_RealIsInstance(PyObject *inst, PyObject *cls)
3060 return recursive_isinstance(inst, cls);
3064 _PyObject_RealIsSubclass(PyObject *derived, PyObject *cls)
3066 return recursive_issubclass(derived, cls);
3071 PyObject_GetIter(PyObject *o)
3073 PyTypeObject *t = o->ob_type;
3074 getiterfunc f = NULL;
3075 if (PyType_HasFeature(t, Py_TPFLAGS_HAVE_ITER))
3078 if (PySequence_Check(o))
3079 return PySeqIter_New(o);
3080 return type_error("'%.200s' object is not iterable", o);
3083 PyObject *res = (*f)(o);
3084 if (res != NULL && !PyIter_Check(res)) {
3085 PyErr_Format(PyExc_TypeError,
3086 "iter() returned non-iterator "
3088 res->ob_type->tp_name);
3096 /* Return next item.
3097 * If an error occurs, return NULL. PyErr_Occurred() will be true.
3098 * If the iteration terminates normally, return NULL and clear the
3099 * PyExc_StopIteration exception (if it was set). PyErr_Occurred()
3101 * Else return the next object. PyErr_Occurred() will be false.
3104 PyIter_Next(PyObject *iter)
3107 result = (*iter->ob_type->tp_iternext)(iter);
3108 if (result == NULL &&
3110 PyErr_ExceptionMatches(PyExc_StopIteration))