blob: 13a9473454fcfb06ee419a5abe635cf7ec8702ae [file] [log] [blame]
Guido van Rossume15dee51995-07-18 14:12:02 +00001/* Abstract Object Interface (many thanks to Jim Fulton) */
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002
Guido van Rossume15dee51995-07-18 14:12:02 +00003#include "Python.h"
Guido van Rossumfa0b6ab1998-05-22 15:23:36 +00004#include <ctype.h>
Neil Schemenauer5a1f0152001-01-04 01:39:06 +00005#include "structmember.h" /* we need the offsetof() macro from there */
Tim Peters64b5ce32001-09-10 20:52:51 +00006#include "longintrepr.h"
Neil Schemenauer5a1f0152001-01-04 01:39:06 +00007
8#define NEW_STYLE_NUMBER(o) PyType_HasFeature((o)->ob_type, \
Guido van Rossumc3189692001-01-17 15:29:42 +00009 Py_TPFLAGS_CHECKTYPES)
Guido van Rossume15dee51995-07-18 14:12:02 +000010
Guido van Rossum38fff8c2006-03-07 18:50:55 +000011#define HASINDEX(o) PyType_HasFeature((o)->ob_type, Py_TPFLAGS_HAVE_INDEX)
12
Thomas Wouters49fd7fa2006-04-21 10:40:58 +000013
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000014/* Shorthands to return certain errors */
Guido van Rossume15dee51995-07-18 14:12:02 +000015
16static PyObject *
Fred Drake4201b9e2000-07-09 04:34:13 +000017type_error(const char *msg)
Guido van Rossume15dee51995-07-18 14:12:02 +000018{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000019 PyErr_SetString(PyExc_TypeError, msg);
20 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +000021}
22
Guido van Rossum052b7e11996-11-11 15:08:19 +000023static PyObject *
Fred Drake79912472000-07-09 04:06:11 +000024null_error(void)
Guido van Rossume15dee51995-07-18 14:12:02 +000025{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000026 if (!PyErr_Occurred())
27 PyErr_SetString(PyExc_SystemError,
28 "null argument to internal routine");
29 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +000030}
31
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000032/* Operations on any object */
33
34int
Fred Drake79912472000-07-09 04:06:11 +000035PyObject_Cmp(PyObject *o1, PyObject *o2, int *result)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000036{
37 int r;
38
39 if (o1 == NULL || o2 == NULL) {
40 null_error();
41 return -1;
42 }
43 r = PyObject_Compare(o1, o2);
44 if (PyErr_Occurred())
45 return -1;
46 *result = r;
Guido van Rossume15dee51995-07-18 14:12:02 +000047 return 0;
48}
Guido van Rossume15dee51995-07-18 14:12:02 +000049
50PyObject *
Fred Drake79912472000-07-09 04:06:11 +000051PyObject_Type(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +000052{
53 PyObject *v;
54
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000055 if (o == NULL)
56 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +000057 v = (PyObject *)o->ob_type;
58 Py_INCREF(v);
59 return v;
60}
61
Martin v. Löwis18e16552006-02-15 17:27:45 +000062Py_ssize_t
Jeremy Hylton6253f832000-07-12 12:56:19 +000063PyObject_Size(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +000064{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000065 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +000066
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000067 if (o == NULL) {
68 null_error();
69 return -1;
70 }
Guido van Rossume15dee51995-07-18 14:12:02 +000071
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000072 m = o->ob_type->tp_as_sequence;
73 if (m && m->sq_length)
74 return m->sq_length(o);
Guido van Rossume15dee51995-07-18 14:12:02 +000075
Jeremy Hylton6253f832000-07-12 12:56:19 +000076 return PyMapping_Size(o);
Guido van Rossume15dee51995-07-18 14:12:02 +000077}
78
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +000079#undef PyObject_Length
Martin v. Löwis18e16552006-02-15 17:27:45 +000080Py_ssize_t
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +000081PyObject_Length(PyObject *o)
82{
83 return PyObject_Size(o);
84}
85#define PyObject_Length PyObject_Size
86
Martin v. Löwis18e16552006-02-15 17:27:45 +000087Py_ssize_t
Armin Rigof5b3e362006-02-11 21:32:43 +000088_PyObject_LengthHint(PyObject *o)
Raymond Hettinger6b27cda2005-09-24 21:23:05 +000089{
Martin v. Löwis18e16552006-02-15 17:27:45 +000090 Py_ssize_t rv = PyObject_Size(o);
Raymond Hettinger6b27cda2005-09-24 21:23:05 +000091 if (rv != -1)
92 return rv;
93 if (PyErr_ExceptionMatches(PyExc_TypeError) ||
94 PyErr_ExceptionMatches(PyExc_AttributeError)) {
95 PyObject *err_type, *err_value, *err_tb, *ro;
96
97 PyErr_Fetch(&err_type, &err_value, &err_tb);
Armin Rigof5b3e362006-02-11 21:32:43 +000098 ro = PyObject_CallMethod(o, "__length_hint__", NULL);
Raymond Hettinger6b27cda2005-09-24 21:23:05 +000099 if (ro != NULL) {
Martin v. Löwis18e16552006-02-15 17:27:45 +0000100 rv = PyInt_AsLong(ro);
Raymond Hettinger6b27cda2005-09-24 21:23:05 +0000101 Py_DECREF(ro);
102 Py_XDECREF(err_type);
103 Py_XDECREF(err_value);
104 Py_XDECREF(err_tb);
105 return rv;
106 }
107 PyErr_Restore(err_type, err_value, err_tb);
108 }
109 return -1;
110}
111
Guido van Rossume15dee51995-07-18 14:12:02 +0000112PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000113PyObject_GetItem(PyObject *o, PyObject *key)
Guido van Rossume15dee51995-07-18 14:12:02 +0000114{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000115 PyMappingMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +0000116
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000117 if (o == NULL || key == NULL)
118 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +0000119
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000120 m = o->ob_type->tp_as_mapping;
121 if (m && m->mp_subscript)
122 return m->mp_subscript(o, key);
Guido van Rossume15dee51995-07-18 14:12:02 +0000123
Guido van Rossum21308241998-08-13 16:44:44 +0000124 if (o->ob_type->tp_as_sequence) {
Guido van Rossum38fff8c2006-03-07 18:50:55 +0000125 PyNumberMethods *nb = key->ob_type->tp_as_number;
126 if (nb != NULL && HASINDEX(key) && nb->nb_index != NULL) {
127 Py_ssize_t key_value = nb->nb_index(key);
Andrew M. Kuchling0f223d22000-02-23 22:21:50 +0000128 if (key_value == -1 && PyErr_Occurred())
129 return NULL;
130 return PySequence_GetItem(o, key_value);
131 }
Guido van Rossum64585f62001-11-24 18:24:47 +0000132 else if (o->ob_type->tp_as_sequence->sq_item)
133 return type_error("sequence index must be integer");
Guido van Rossum21308241998-08-13 16:44:44 +0000134 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000135
136 return type_error("unsubscriptable object");
Guido van Rossume15dee51995-07-18 14:12:02 +0000137}
138
139int
Fred Drake79912472000-07-09 04:06:11 +0000140PyObject_SetItem(PyObject *o, PyObject *key, PyObject *value)
Guido van Rossume15dee51995-07-18 14:12:02 +0000141{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000142 PyMappingMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +0000143
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000144 if (o == NULL || key == NULL || value == NULL) {
145 null_error();
146 return -1;
147 }
148 m = o->ob_type->tp_as_mapping;
149 if (m && m->mp_ass_subscript)
150 return m->mp_ass_subscript(o, key, value);
Guido van Rossume15dee51995-07-18 14:12:02 +0000151
Guido van Rossum21308241998-08-13 16:44:44 +0000152 if (o->ob_type->tp_as_sequence) {
Guido van Rossum38fff8c2006-03-07 18:50:55 +0000153 PyNumberMethods *nb = key->ob_type->tp_as_number;
154 if (nb != NULL && HASINDEX(key) && nb->nb_index != NULL) {
155 Py_ssize_t key_value = nb->nb_index(key);
Andrew M. Kuchling0f223d22000-02-23 22:21:50 +0000156 if (key_value == -1 && PyErr_Occurred())
157 return -1;
158 return PySequence_SetItem(o, key_value, value);
159 }
Guido van Rossum64585f62001-11-24 18:24:47 +0000160 else if (o->ob_type->tp_as_sequence->sq_ass_item) {
161 type_error("sequence index must be integer");
162 return -1;
163 }
Guido van Rossum21308241998-08-13 16:44:44 +0000164 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000165
166 type_error("object does not support item assignment");
167 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +0000168}
169
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000170int
Fred Drake79912472000-07-09 04:06:11 +0000171PyObject_DelItem(PyObject *o, PyObject *key)
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000172{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000173 PyMappingMethods *m;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000174
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000175 if (o == NULL || key == NULL) {
176 null_error();
177 return -1;
178 }
179 m = o->ob_type->tp_as_mapping;
180 if (m && m->mp_ass_subscript)
181 return m->mp_ass_subscript(o, key, (PyObject*)NULL);
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000182
Guido van Rossum21308241998-08-13 16:44:44 +0000183 if (o->ob_type->tp_as_sequence) {
Guido van Rossum38fff8c2006-03-07 18:50:55 +0000184 PyNumberMethods *nb = key->ob_type->tp_as_number;
185 if (nb != NULL && HASINDEX(key) && nb->nb_index != NULL) {
186 Py_ssize_t key_value = nb->nb_index(key);
Andrew M. Kuchling0f223d22000-02-23 22:21:50 +0000187 if (key_value == -1 && PyErr_Occurred())
188 return -1;
189 return PySequence_DelItem(o, key_value);
190 }
Guido van Rossum64585f62001-11-24 18:24:47 +0000191 else if (o->ob_type->tp_as_sequence->sq_ass_item) {
192 type_error("sequence index must be integer");
193 return -1;
194 }
Guido van Rossum21308241998-08-13 16:44:44 +0000195 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000196
197 type_error("object does not support item deletion");
198 return -1;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000199}
200
Martin v. Löwisb0d71d02002-01-05 10:50:30 +0000201int
202PyObject_DelItemString(PyObject *o, char *key)
203{
204 PyObject *okey;
205 int ret;
206
207 if (o == NULL || key == NULL) {
208 null_error();
209 return -1;
210 }
211 okey = PyString_FromString(key);
212 if (okey == NULL)
213 return -1;
214 ret = PyObject_DelItem(o, okey);
215 Py_DECREF(okey);
216 return ret;
217}
218
Guido van Rossum4c08d552000-03-10 22:55:18 +0000219int PyObject_AsCharBuffer(PyObject *obj,
220 const char **buffer,
Martin v. Löwis18e16552006-02-15 17:27:45 +0000221 Py_ssize_t *buffer_len)
Guido van Rossum4c08d552000-03-10 22:55:18 +0000222{
223 PyBufferProcs *pb;
Martin v. Löwis15e62742006-02-27 16:46:16 +0000224 char *pp;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000225 Py_ssize_t len;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000226
227 if (obj == NULL || buffer == NULL || buffer_len == NULL) {
228 null_error();
229 return -1;
230 }
231 pb = obj->ob_type->tp_as_buffer;
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000232 if (pb == NULL ||
Guido van Rossum4c08d552000-03-10 22:55:18 +0000233 pb->bf_getcharbuffer == NULL ||
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000234 pb->bf_getsegcount == NULL) {
Guido van Rossum4c08d552000-03-10 22:55:18 +0000235 PyErr_SetString(PyExc_TypeError,
236 "expected a character buffer object");
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000237 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000238 }
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000239 if ((*pb->bf_getsegcount)(obj,NULL) != 1) {
Guido van Rossum4c08d552000-03-10 22:55:18 +0000240 PyErr_SetString(PyExc_TypeError,
241 "expected a single-segment buffer object");
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000242 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000243 }
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000244 len = (*pb->bf_getcharbuffer)(obj, 0, &pp);
Guido van Rossum4c08d552000-03-10 22:55:18 +0000245 if (len < 0)
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000246 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000247 *buffer = pp;
248 *buffer_len = len;
249 return 0;
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000250}
Guido van Rossum4c08d552000-03-10 22:55:18 +0000251
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000252int
253PyObject_CheckReadBuffer(PyObject *obj)
254{
255 PyBufferProcs *pb = obj->ob_type->tp_as_buffer;
256
257 if (pb == NULL ||
258 pb->bf_getreadbuffer == NULL ||
259 pb->bf_getsegcount == NULL ||
260 (*pb->bf_getsegcount)(obj, NULL) != 1)
261 return 0;
262 return 1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000263}
264
265int PyObject_AsReadBuffer(PyObject *obj,
266 const void **buffer,
Martin v. Löwis18e16552006-02-15 17:27:45 +0000267 Py_ssize_t *buffer_len)
Guido van Rossum4c08d552000-03-10 22:55:18 +0000268{
269 PyBufferProcs *pb;
270 void *pp;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000271 Py_ssize_t len;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000272
273 if (obj == NULL || buffer == NULL || buffer_len == NULL) {
274 null_error();
275 return -1;
276 }
277 pb = obj->ob_type->tp_as_buffer;
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000278 if (pb == NULL ||
Guido van Rossum4c08d552000-03-10 22:55:18 +0000279 pb->bf_getreadbuffer == NULL ||
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000280 pb->bf_getsegcount == NULL) {
Guido van Rossum4c08d552000-03-10 22:55:18 +0000281 PyErr_SetString(PyExc_TypeError,
282 "expected a readable buffer object");
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000283 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000284 }
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000285 if ((*pb->bf_getsegcount)(obj, NULL) != 1) {
Guido van Rossum4c08d552000-03-10 22:55:18 +0000286 PyErr_SetString(PyExc_TypeError,
287 "expected a single-segment buffer object");
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000288 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000289 }
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000290 len = (*pb->bf_getreadbuffer)(obj, 0, &pp);
Guido van Rossum4c08d552000-03-10 22:55:18 +0000291 if (len < 0)
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000292 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000293 *buffer = pp;
294 *buffer_len = len;
295 return 0;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000296}
297
298int PyObject_AsWriteBuffer(PyObject *obj,
299 void **buffer,
Martin v. Löwis18e16552006-02-15 17:27:45 +0000300 Py_ssize_t *buffer_len)
Guido van Rossum4c08d552000-03-10 22:55:18 +0000301{
302 PyBufferProcs *pb;
303 void*pp;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000304 Py_ssize_t len;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000305
306 if (obj == NULL || buffer == NULL || buffer_len == NULL) {
307 null_error();
308 return -1;
309 }
310 pb = obj->ob_type->tp_as_buffer;
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000311 if (pb == NULL ||
Guido van Rossum4c08d552000-03-10 22:55:18 +0000312 pb->bf_getwritebuffer == NULL ||
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000313 pb->bf_getsegcount == NULL) {
Guido van Rossum4c08d552000-03-10 22:55:18 +0000314 PyErr_SetString(PyExc_TypeError,
315 "expected a writeable buffer object");
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000316 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000317 }
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000318 if ((*pb->bf_getsegcount)(obj, NULL) != 1) {
Guido van Rossum4c08d552000-03-10 22:55:18 +0000319 PyErr_SetString(PyExc_TypeError,
320 "expected a single-segment buffer object");
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000321 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000322 }
323 len = (*pb->bf_getwritebuffer)(obj,0,&pp);
324 if (len < 0)
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000325 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000326 *buffer = pp;
327 *buffer_len = len;
328 return 0;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000329}
330
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000331/* Operations on numbers */
332
333int
Fred Drake79912472000-07-09 04:06:11 +0000334PyNumber_Check(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +0000335{
Guido van Rossum6921eca2003-02-18 16:36:28 +0000336 return o && o->ob_type->tp_as_number &&
337 (o->ob_type->tp_as_number->nb_int ||
338 o->ob_type->tp_as_number->nb_float);
Guido van Rossume15dee51995-07-18 14:12:02 +0000339}
340
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000341/* Binary operators */
Guido van Rossume15dee51995-07-18 14:12:02 +0000342
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000343/* New style number protocol support */
Guido van Rossume15dee51995-07-18 14:12:02 +0000344
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000345#define NB_SLOT(x) offsetof(PyNumberMethods, x)
346#define NB_BINOP(nb_methods, slot) \
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000347 (*(binaryfunc*)(& ((char*)nb_methods)[slot]))
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000348#define NB_TERNOP(nb_methods, slot) \
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000349 (*(ternaryfunc*)(& ((char*)nb_methods)[slot]))
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000350
351/*
352 Calling scheme used for binary operations:
353
354 v w Action
355 -------------------------------------------------------------------
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000356 new new w.op(v,w)[*], v.op(v,w), w.op(v,w)
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000357 new old v.op(v,w), coerce(v,w), v.op(v,w)
358 old new w.op(v,w), coerce(v,w), v.op(v,w)
359 old old coerce(v,w), v.op(v,w)
360
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000361 [*] only when v->ob_type != w->ob_type && w->ob_type is a subclass of
362 v->ob_type
363
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000364 Legend:
365 -------
366 * new == new style number
367 * old == old style number
368 * Action indicates the order in which operations are tried until either
369 a valid result is produced or an error occurs.
370
371 */
372
373static PyObject *
374binary_op1(PyObject *v, PyObject *w, const int op_slot)
Guido van Rossume15dee51995-07-18 14:12:02 +0000375{
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000376 PyObject *x;
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000377 binaryfunc slotv = NULL;
378 binaryfunc slotw = NULL;
379
380 if (v->ob_type->tp_as_number != NULL && NEW_STYLE_NUMBER(v))
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000381 slotv = NB_BINOP(v->ob_type->tp_as_number, op_slot);
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000382 if (w->ob_type != v->ob_type &&
383 w->ob_type->tp_as_number != NULL && NEW_STYLE_NUMBER(w)) {
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000384 slotw = NB_BINOP(w->ob_type->tp_as_number, op_slot);
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000385 if (slotw == slotv)
386 slotw = NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +0000387 }
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000388 if (slotv) {
Guido van Rossum89c42642001-10-01 17:10:18 +0000389 if (slotw && PyType_IsSubtype(w->ob_type, v->ob_type)) {
390 x = slotw(v, w);
391 if (x != Py_NotImplemented)
392 return x;
393 Py_DECREF(x); /* can't do it */
394 slotw = NULL;
395 }
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000396 x = slotv(v, w);
397 if (x != Py_NotImplemented)
398 return x;
399 Py_DECREF(x); /* can't do it */
400 }
401 if (slotw) {
402 x = slotw(v, w);
403 if (x != Py_NotImplemented)
404 return x;
405 Py_DECREF(x); /* can't do it */
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000406 }
407 if (!NEW_STYLE_NUMBER(v) || !NEW_STYLE_NUMBER(w)) {
408 int err = PyNumber_CoerceEx(&v, &w);
409 if (err < 0) {
410 return NULL;
411 }
412 if (err == 0) {
413 PyNumberMethods *mv = v->ob_type->tp_as_number;
414 if (mv) {
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000415 binaryfunc slot;
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000416 slot = NB_BINOP(mv, op_slot);
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000417 if (slot) {
Neal Norwitz0c6e2f12006-01-08 06:13:44 +0000418 x = slot(v, w);
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000419 Py_DECREF(v);
420 Py_DECREF(w);
421 return x;
422 }
423 }
424 /* CoerceEx incremented the reference counts */
425 Py_DECREF(v);
426 Py_DECREF(w);
427 }
428 }
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000429 Py_INCREF(Py_NotImplemented);
430 return Py_NotImplemented;
431}
Guido van Rossum77660912002-04-16 16:32:50 +0000432
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000433static PyObject *
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000434binop_type_error(PyObject *v, PyObject *w, const char *op_name)
435{
436 PyErr_Format(PyExc_TypeError,
437 "unsupported operand type(s) for %s: '%s' and '%s'",
438 op_name,
439 v->ob_type->tp_name,
440 w->ob_type->tp_name);
441 return NULL;
442}
443
444static PyObject *
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000445binary_op(PyObject *v, PyObject *w, const int op_slot, const char *op_name)
446{
447 PyObject *result = binary_op1(v, w, op_slot);
448 if (result == Py_NotImplemented) {
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000449 Py_DECREF(result);
450 return binop_type_error(v, w, op_name);
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000451 }
452 return result;
Guido van Rossume15dee51995-07-18 14:12:02 +0000453}
454
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000455
456/*
457 Calling scheme used for ternary operations:
458
Guido van Rossum84675ac2001-09-29 01:05:03 +0000459 *** In some cases, w.op is called before v.op; see binary_op1. ***
460
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000461 v w z Action
462 -------------------------------------------------------------------
463 new new new v.op(v,w,z), w.op(v,w,z), z.op(v,w,z)
464 new old new v.op(v,w,z), z.op(v,w,z), coerce(v,w,z), v.op(v,w,z)
465 old new new w.op(v,w,z), z.op(v,w,z), coerce(v,w,z), v.op(v,w,z)
466 old old new z.op(v,w,z), coerce(v,w,z), v.op(v,w,z)
467 new new old v.op(v,w,z), w.op(v,w,z), coerce(v,w,z), v.op(v,w,z)
468 new old old v.op(v,w,z), coerce(v,w,z), v.op(v,w,z)
469 old new old w.op(v,w,z), coerce(v,w,z), v.op(v,w,z)
470 old old old coerce(v,w,z), v.op(v,w,z)
471
472 Legend:
473 -------
474 * new == new style number
475 * old == old style number
476 * Action indicates the order in which operations are tried until either
477 a valid result is produced or an error occurs.
478 * coerce(v,w,z) actually does: coerce(v,w), coerce(v,z), coerce(w,z) and
479 only if z != Py_None; if z == Py_None, then it is treated as absent
480 variable and only coerce(v,w) is tried.
481
482 */
483
484static PyObject *
485ternary_op(PyObject *v,
486 PyObject *w,
487 PyObject *z,
488 const int op_slot,
489 const char *op_name)
Guido van Rossume15dee51995-07-18 14:12:02 +0000490{
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000491 PyNumberMethods *mv, *mw, *mz;
Guido van Rossum84675ac2001-09-29 01:05:03 +0000492 PyObject *x = NULL;
493 ternaryfunc slotv = NULL;
494 ternaryfunc slotw = NULL;
495 ternaryfunc slotz = NULL;
Guido van Rossum77660912002-04-16 16:32:50 +0000496
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000497 mv = v->ob_type->tp_as_number;
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000498 mw = w->ob_type->tp_as_number;
Guido van Rossum84675ac2001-09-29 01:05:03 +0000499 if (mv != NULL && NEW_STYLE_NUMBER(v))
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000500 slotv = NB_TERNOP(mv, op_slot);
Guido van Rossum84675ac2001-09-29 01:05:03 +0000501 if (w->ob_type != v->ob_type &&
Raymond Hettingerc2e095f2002-12-07 10:05:27 +0000502 mw != NULL && NEW_STYLE_NUMBER(w)) {
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000503 slotw = NB_TERNOP(mw, op_slot);
Guido van Rossum84675ac2001-09-29 01:05:03 +0000504 if (slotw == slotv)
505 slotw = NULL;
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000506 }
Guido van Rossum84675ac2001-09-29 01:05:03 +0000507 if (slotv) {
Guido van Rossum89c42642001-10-01 17:10:18 +0000508 if (slotw && PyType_IsSubtype(w->ob_type, v->ob_type)) {
509 x = slotw(v, w, z);
510 if (x != Py_NotImplemented)
511 return x;
512 Py_DECREF(x); /* can't do it */
513 slotw = NULL;
514 }
Guido van Rossum84675ac2001-09-29 01:05:03 +0000515 x = slotv(v, w, z);
516 if (x != Py_NotImplemented)
517 return x;
518 Py_DECREF(x); /* can't do it */
519 }
520 if (slotw) {
521 x = slotw(v, w, z);
522 if (x != Py_NotImplemented)
523 return x;
524 Py_DECREF(x); /* can't do it */
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000525 }
526 mz = z->ob_type->tp_as_number;
527 if (mz != NULL && NEW_STYLE_NUMBER(z)) {
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000528 slotz = NB_TERNOP(mz, op_slot);
Guido van Rossum84675ac2001-09-29 01:05:03 +0000529 if (slotz == slotv || slotz == slotw)
530 slotz = NULL;
531 if (slotz) {
532 x = slotz(v, w, z);
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000533 if (x != Py_NotImplemented)
534 return x;
Guido van Rossum84675ac2001-09-29 01:05:03 +0000535 Py_DECREF(x); /* can't do it */
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000536 }
537 }
538
539 if (!NEW_STYLE_NUMBER(v) || !NEW_STYLE_NUMBER(w) ||
540 (z != Py_None && !NEW_STYLE_NUMBER(z))) {
541 /* we have an old style operand, coerce */
542 PyObject *v1, *z1, *w2, *z2;
543 int c;
Guido van Rossum77660912002-04-16 16:32:50 +0000544
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000545 c = PyNumber_Coerce(&v, &w);
546 if (c != 0)
547 goto error3;
548
549 /* Special case: if the third argument is None, it is
550 treated as absent argument and not coerced. */
551 if (z == Py_None) {
552 if (v->ob_type->tp_as_number) {
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000553 slotz = NB_TERNOP(v->ob_type->tp_as_number,
554 op_slot);
Guido van Rossum84675ac2001-09-29 01:05:03 +0000555 if (slotz)
556 x = slotz(v, w, z);
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000557 else
558 c = -1;
559 }
560 else
561 c = -1;
562 goto error2;
563 }
564 v1 = v;
565 z1 = z;
566 c = PyNumber_Coerce(&v1, &z1);
567 if (c != 0)
568 goto error2;
569 w2 = w;
570 z2 = z1;
571 c = PyNumber_Coerce(&w2, &z2);
572 if (c != 0)
573 goto error1;
574
575 if (v1->ob_type->tp_as_number != NULL) {
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000576 slotv = NB_TERNOP(v1->ob_type->tp_as_number,
577 op_slot);
Guido van Rossum84675ac2001-09-29 01:05:03 +0000578 if (slotv)
579 x = slotv(v1, w2, z2);
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000580 else
581 c = -1;
582 }
583 else
584 c = -1;
585
586 Py_DECREF(w2);
587 Py_DECREF(z2);
588 error1:
589 Py_DECREF(v1);
590 Py_DECREF(z1);
591 error2:
Guido van Rossume15dee51995-07-18 14:12:02 +0000592 Py_DECREF(v);
593 Py_DECREF(w);
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000594 error3:
595 if (c >= 0)
Guido van Rossume15dee51995-07-18 14:12:02 +0000596 return x;
597 }
Guido van Rossum5c66a262001-10-22 04:12:44 +0000598
599 if (z == Py_None)
600 PyErr_Format(
601 PyExc_TypeError,
602 "unsupported operand type(s) for ** or pow(): "
603 "'%s' and '%s'",
604 v->ob_type->tp_name,
605 w->ob_type->tp_name);
606 else
607 PyErr_Format(
608 PyExc_TypeError,
609 "unsupported operand type(s) for pow(): "
610 "'%s', '%s', '%s'",
611 v->ob_type->tp_name,
612 w->ob_type->tp_name,
613 z->ob_type->tp_name);
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000614 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +0000615}
616
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000617#define BINARY_FUNC(func, op, op_name) \
618 PyObject * \
619 func(PyObject *v, PyObject *w) { \
620 return binary_op(v, w, NB_SLOT(op), op_name); \
621 }
Guido van Rossume15dee51995-07-18 14:12:02 +0000622
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000623BINARY_FUNC(PyNumber_Or, nb_or, "|")
624BINARY_FUNC(PyNumber_Xor, nb_xor, "^")
625BINARY_FUNC(PyNumber_And, nb_and, "&")
626BINARY_FUNC(PyNumber_Lshift, nb_lshift, "<<")
627BINARY_FUNC(PyNumber_Rshift, nb_rshift, ">>")
628BINARY_FUNC(PyNumber_Subtract, nb_subtract, "-")
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000629BINARY_FUNC(PyNumber_Divmod, nb_divmod, "divmod()")
Guido van Rossume15dee51995-07-18 14:12:02 +0000630
631PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000632PyNumber_Add(PyObject *v, PyObject *w)
Guido van Rossume15dee51995-07-18 14:12:02 +0000633{
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000634 PyObject *result = binary_op1(v, w, NB_SLOT(nb_add));
635 if (result == Py_NotImplemented) {
636 PySequenceMethods *m = v->ob_type->tp_as_sequence;
Armin Rigofd163f92005-12-29 15:59:19 +0000637 Py_DECREF(result);
Jeremy Hylton0522d982002-03-08 21:28:54 +0000638 if (m && m->sq_concat) {
Armin Rigofd163f92005-12-29 15:59:19 +0000639 return (*m->sq_concat)(v, w);
Jeremy Hylton0522d982002-03-08 21:28:54 +0000640 }
Armin Rigofd163f92005-12-29 15:59:19 +0000641 result = binop_type_error(v, w, "+");
Guido van Rossume15dee51995-07-18 14:12:02 +0000642 }
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000643 return result;
Guido van Rossume15dee51995-07-18 14:12:02 +0000644}
645
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000646static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000647sequence_repeat(ssizeargfunc repeatfunc, PyObject *seq, PyObject *n)
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000648{
Guido van Rossum38fff8c2006-03-07 18:50:55 +0000649 Py_ssize_t count;
650 PyNumberMethods *nb = n->ob_type->tp_as_number;
651 if (nb != NULL && HASINDEX(n) && nb->nb_index != NULL) {
652 count = nb->nb_index(n);
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000653 if (count == -1 && PyErr_Occurred())
654 return NULL;
655 }
656 else {
657 return type_error(
Raymond Hettinger10c66062004-05-12 21:35:06 +0000658 "can't multiply sequence by non-int");
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000659 }
Guido van Rossum38fff8c2006-03-07 18:50:55 +0000660 return (*repeatfunc)(seq, count);
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000661}
662
663PyObject *
664PyNumber_Multiply(PyObject *v, PyObject *w)
665{
666 PyObject *result = binary_op1(v, w, NB_SLOT(nb_multiply));
667 if (result == Py_NotImplemented) {
668 PySequenceMethods *mv = v->ob_type->tp_as_sequence;
669 PySequenceMethods *mw = w->ob_type->tp_as_sequence;
Guido van Rossuma3a243e2002-12-31 19:50:03 +0000670 Py_DECREF(result);
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000671 if (mv && mv->sq_repeat) {
672 return sequence_repeat(mv->sq_repeat, v, w);
673 }
674 else if (mw && mw->sq_repeat) {
675 return sequence_repeat(mw->sq_repeat, w, v);
676 }
677 result = binop_type_error(v, w, "*");
678 }
679 return result;
680}
681
Guido van Rossume15dee51995-07-18 14:12:02 +0000682PyObject *
Guido van Rossum4668b002001-08-08 05:00:18 +0000683PyNumber_FloorDivide(PyObject *v, PyObject *w)
684{
685 /* XXX tp_flags test */
686 return binary_op(v, w, NB_SLOT(nb_floor_divide), "//");
687}
688
689PyObject *
690PyNumber_TrueDivide(PyObject *v, PyObject *w)
691{
692 /* XXX tp_flags test */
693 return binary_op(v, w, NB_SLOT(nb_true_divide), "/");
694}
695
696PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000697PyNumber_Remainder(PyObject *v, PyObject *w)
Guido van Rossume15dee51995-07-18 14:12:02 +0000698{
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000699 return binary_op(v, w, NB_SLOT(nb_remainder), "%");
Guido van Rossume15dee51995-07-18 14:12:02 +0000700}
701
702PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000703PyNumber_Power(PyObject *v, PyObject *w, PyObject *z)
Guido van Rossume15dee51995-07-18 14:12:02 +0000704{
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000705 return ternary_op(v, w, z, NB_SLOT(nb_power), "** or pow()");
Guido van Rossume15dee51995-07-18 14:12:02 +0000706}
707
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000708/* Binary in-place operators */
709
710/* The in-place operators are defined to fall back to the 'normal',
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000711 non in-place operations, if the in-place methods are not in place.
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000712
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000713 - If the left hand object has the appropriate struct members, and
714 they are filled, call the appropriate function and return the
715 result. No coercion is done on the arguments; the left-hand object
716 is the one the operation is performed on, and it's up to the
717 function to deal with the right-hand object.
Guido van Rossum77660912002-04-16 16:32:50 +0000718
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000719 - Otherwise, in-place modification is not supported. Handle it exactly as
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000720 a non in-place operation of the same kind.
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000721
722 */
723
Guido van Rossum77660912002-04-16 16:32:50 +0000724#define HASINPLACE(t) \
725 PyType_HasFeature((t)->ob_type, Py_TPFLAGS_HAVE_INPLACEOPS)
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000726
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000727static PyObject *
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000728binary_iop1(PyObject *v, PyObject *w, const int iop_slot, const int op_slot)
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000729{
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000730 PyNumberMethods *mv = v->ob_type->tp_as_number;
731 if (mv != NULL && HASINPLACE(v)) {
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000732 binaryfunc slot = NB_BINOP(mv, iop_slot);
733 if (slot) {
734 PyObject *x = (slot)(v, w);
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000735 if (x != Py_NotImplemented) {
736 return x;
737 }
738 Py_DECREF(x);
739 }
Thomas Woutersf2b332d2000-09-02 08:34:40 +0000740 }
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000741 return binary_op1(v, w, op_slot);
742}
743
744static PyObject *
745binary_iop(PyObject *v, PyObject *w, const int iop_slot, const int op_slot,
746 const char *op_name)
747{
748 PyObject *result = binary_iop1(v, w, iop_slot, op_slot);
749 if (result == Py_NotImplemented) {
750 Py_DECREF(result);
751 return binop_type_error(v, w, op_name);
752 }
753 return result;
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000754}
755
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000756#define INPLACE_BINOP(func, iop, op, op_name) \
757 PyObject * \
758 func(PyObject *v, PyObject *w) { \
759 return binary_iop(v, w, NB_SLOT(iop), NB_SLOT(op), op_name); \
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000760 }
761
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000762INPLACE_BINOP(PyNumber_InPlaceOr, nb_inplace_or, nb_or, "|=")
763INPLACE_BINOP(PyNumber_InPlaceXor, nb_inplace_xor, nb_xor, "^=")
764INPLACE_BINOP(PyNumber_InPlaceAnd, nb_inplace_and, nb_and, "&=")
765INPLACE_BINOP(PyNumber_InPlaceLshift, nb_inplace_lshift, nb_lshift, "<<=")
766INPLACE_BINOP(PyNumber_InPlaceRshift, nb_inplace_rshift, nb_rshift, ">>=")
767INPLACE_BINOP(PyNumber_InPlaceSubtract, nb_inplace_subtract, nb_subtract, "-=")
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000768
769PyObject *
Guido van Rossum4668b002001-08-08 05:00:18 +0000770PyNumber_InPlaceFloorDivide(PyObject *v, PyObject *w)
771{
772 /* XXX tp_flags test */
773 return binary_iop(v, w, NB_SLOT(nb_inplace_floor_divide),
774 NB_SLOT(nb_floor_divide), "//=");
775}
776
777PyObject *
778PyNumber_InPlaceTrueDivide(PyObject *v, PyObject *w)
779{
780 /* XXX tp_flags test */
781 return binary_iop(v, w, NB_SLOT(nb_inplace_true_divide),
782 NB_SLOT(nb_true_divide), "/=");
783}
784
785PyObject *
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000786PyNumber_InPlaceAdd(PyObject *v, PyObject *w)
787{
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000788 PyObject *result = binary_iop1(v, w, NB_SLOT(nb_inplace_add),
789 NB_SLOT(nb_add));
790 if (result == Py_NotImplemented) {
791 PySequenceMethods *m = v->ob_type->tp_as_sequence;
792 Py_DECREF(result);
793 if (m != NULL) {
794 binaryfunc f = NULL;
795 if (HASINPLACE(v))
796 f = m->sq_inplace_concat;
797 if (f == NULL)
798 f = m->sq_concat;
799 if (f != NULL)
800 return (*f)(v, w);
801 }
802 result = binop_type_error(v, w, "+=");
Guido van Rossumbb8be932000-09-01 23:27:32 +0000803 }
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000804 return result;
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000805}
806
807PyObject *
808PyNumber_InPlaceMultiply(PyObject *v, PyObject *w)
809{
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000810 PyObject *result = binary_iop1(v, w, NB_SLOT(nb_inplace_multiply),
811 NB_SLOT(nb_multiply));
812 if (result == Py_NotImplemented) {
Martin v. Löwis18e16552006-02-15 17:27:45 +0000813 ssizeargfunc f = NULL;
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000814 PySequenceMethods *mv = v->ob_type->tp_as_sequence;
815 PySequenceMethods *mw = w->ob_type->tp_as_sequence;
816 Py_DECREF(result);
817 if (mv != NULL) {
818 if (HASINPLACE(v))
819 f = mv->sq_inplace_repeat;
820 if (f == NULL)
821 f = mv->sq_repeat;
822 if (f != NULL)
823 return sequence_repeat(f, v, w);
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000824 }
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000825 else if (mw != NULL) {
826 /* Note that the right hand operand should not be
827 * mutated in this case so sq_inplace_repeat is not
828 * used. */
829 if (mw->sq_repeat)
830 return sequence_repeat(mw->sq_repeat, w, v);
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000831 }
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000832 result = binop_type_error(v, w, "*=");
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000833 }
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000834 return result;
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000835}
836
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000837PyObject *
838PyNumber_InPlaceRemainder(PyObject *v, PyObject *w)
839{
Neil Schemenauerd46fbc32002-11-24 01:07:42 +0000840 return binary_iop(v, w, NB_SLOT(nb_inplace_remainder),
841 NB_SLOT(nb_remainder), "%=");
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000842}
843
844PyObject *
845PyNumber_InPlacePower(PyObject *v, PyObject *w, PyObject *z)
846{
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000847 if (HASINPLACE(v) && v->ob_type->tp_as_number &&
848 v->ob_type->tp_as_number->nb_inplace_power != NULL) {
849 return ternary_op(v, w, z, NB_SLOT(nb_inplace_power), "**=");
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000850 }
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000851 else {
852 return ternary_op(v, w, z, NB_SLOT(nb_power), "**=");
853 }
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000854}
855
856
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000857/* Unary operators and functions */
Guido van Rossume15dee51995-07-18 14:12:02 +0000858
859PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000860PyNumber_Negative(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +0000861{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000862 PyNumberMethods *m;
863
864 if (o == NULL)
865 return null_error();
866 m = o->ob_type->tp_as_number;
867 if (m && m->nb_negative)
868 return (*m->nb_negative)(o);
869
870 return type_error("bad operand type for unary -");
Guido van Rossume15dee51995-07-18 14:12:02 +0000871}
872
873PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000874PyNumber_Positive(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +0000875{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000876 PyNumberMethods *m;
877
878 if (o == NULL)
879 return null_error();
880 m = o->ob_type->tp_as_number;
881 if (m && m->nb_positive)
882 return (*m->nb_positive)(o);
883
884 return type_error("bad operand type for unary +");
Guido van Rossume15dee51995-07-18 14:12:02 +0000885}
886
887PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000888PyNumber_Invert(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +0000889{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000890 PyNumberMethods *m;
891
892 if (o == NULL)
893 return null_error();
894 m = o->ob_type->tp_as_number;
895 if (m && m->nb_invert)
896 return (*m->nb_invert)(o);
897
898 return type_error("bad operand type for unary ~");
Guido van Rossume15dee51995-07-18 14:12:02 +0000899}
900
901PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000902PyNumber_Absolute(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +0000903{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000904 PyNumberMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +0000905
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000906 if (o == NULL)
907 return null_error();
908 m = o->ob_type->tp_as_number;
909 if (m && m->nb_absolute)
910 return m->nb_absolute(o);
Guido van Rossume15dee51995-07-18 14:12:02 +0000911
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000912 return type_error("bad operand type for abs()");
Guido van Rossume15dee51995-07-18 14:12:02 +0000913}
914
Guido van Rossum9e896b32000-04-05 20:11:21 +0000915/* Add a check for embedded NULL-bytes in the argument. */
916static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000917int_from_string(const char *s, Py_ssize_t len)
Guido van Rossum9e896b32000-04-05 20:11:21 +0000918{
919 char *end;
920 PyObject *x;
921
922 x = PyInt_FromString((char*)s, &end, 10);
923 if (x == NULL)
924 return NULL;
925 if (end != s + len) {
926 PyErr_SetString(PyExc_ValueError,
927 "null byte in argument for int()");
928 Py_DECREF(x);
929 return NULL;
930 }
931 return x;
932}
933
Guido van Rossum38fff8c2006-03-07 18:50:55 +0000934/* Return a Py_ssize_t integer from the object item */
935Py_ssize_t
936PyNumber_Index(PyObject *item)
937{
938 Py_ssize_t value = -1;
939 PyNumberMethods *nb = item->ob_type->tp_as_number;
940 if (nb != NULL && HASINDEX(item) && nb->nb_index != NULL) {
941 value = nb->nb_index(item);
942 }
943 else {
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000944 PyErr_Format(PyExc_TypeError,
945 "'%.200s' object cannot be interpreted "
946 "as an index", item->ob_type->tp_name);
Guido van Rossum38fff8c2006-03-07 18:50:55 +0000947 }
948 return value;
949}
950
Guido van Rossume15dee51995-07-18 14:12:02 +0000951PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000952PyNumber_Int(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +0000953{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000954 PyNumberMethods *m;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000955 const char *buffer;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000956 Py_ssize_t buffer_len;
Guido van Rossume15dee51995-07-18 14:12:02 +0000957
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000958 if (o == NULL)
959 return null_error();
Tim Peters64b5ce32001-09-10 20:52:51 +0000960 if (PyInt_CheckExact(o)) {
Guido van Rossum9e896b32000-04-05 20:11:21 +0000961 Py_INCREF(o);
962 return o;
963 }
Brett Cannonc3647ac2005-04-26 03:45:26 +0000964 m = o->ob_type->tp_as_number;
965 if (m && m->nb_int) { /* This should include subclasses of int */
966 PyObject *res = m->nb_int(o);
967 if (res && (!PyInt_Check(res) && !PyLong_Check(res))) {
968 PyErr_Format(PyExc_TypeError,
969 "__int__ returned non-int (type %.200s)",
970 res->ob_type->tp_name);
971 Py_DECREF(res);
972 return NULL;
973 }
974 return res;
975 }
976 if (PyInt_Check(o)) { /* A int subclass without nb_int */
Tim Peters64b5ce32001-09-10 20:52:51 +0000977 PyIntObject *io = (PyIntObject*)o;
978 return PyInt_FromLong(io->ob_ival);
979 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000980 if (PyString_Check(o))
Guido van Rossum77660912002-04-16 16:32:50 +0000981 return int_from_string(PyString_AS_STRING(o),
Guido van Rossum9e896b32000-04-05 20:11:21 +0000982 PyString_GET_SIZE(o));
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000983#ifdef Py_USING_UNICODE
Guido van Rossum9e896b32000-04-05 20:11:21 +0000984 if (PyUnicode_Check(o))
985 return PyInt_FromUnicode(PyUnicode_AS_UNICODE(o),
986 PyUnicode_GET_SIZE(o),
987 10);
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000988#endif
Guido van Rossum4c08d552000-03-10 22:55:18 +0000989 if (!PyObject_AsCharBuffer(o, &buffer, &buffer_len))
Guido van Rossum9e896b32000-04-05 20:11:21 +0000990 return int_from_string((char*)buffer, buffer_len);
Guido van Rossume15dee51995-07-18 14:12:02 +0000991
Raymond Hettinger478d47a2002-06-06 15:45:38 +0000992 return type_error("int() argument must be a string or a number");
Guido van Rossume15dee51995-07-18 14:12:02 +0000993}
994
Guido van Rossum9e896b32000-04-05 20:11:21 +0000995/* Add a check for embedded NULL-bytes in the argument. */
Barry Warsaw226ae6c1999-10-12 19:54:53 +0000996static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000997long_from_string(const char *s, Py_ssize_t len)
Barry Warsaw226ae6c1999-10-12 19:54:53 +0000998{
Guido van Rossum4c08d552000-03-10 22:55:18 +0000999 char *end;
Barry Warsaw226ae6c1999-10-12 19:54:53 +00001000 PyObject *x;
Barry Warsaw226ae6c1999-10-12 19:54:53 +00001001
Guido van Rossum4c08d552000-03-10 22:55:18 +00001002 x = PyLong_FromString((char*)s, &end, 10);
Guido van Rossum9e896b32000-04-05 20:11:21 +00001003 if (x == NULL)
Barry Warsaw226ae6c1999-10-12 19:54:53 +00001004 return NULL;
Guido van Rossum9e896b32000-04-05 20:11:21 +00001005 if (end != s + len) {
Barry Warsaw226ae6c1999-10-12 19:54:53 +00001006 PyErr_SetString(PyExc_ValueError,
1007 "null byte in argument for long()");
Guido van Rossum9e896b32000-04-05 20:11:21 +00001008 Py_DECREF(x);
Barry Warsaw226ae6c1999-10-12 19:54:53 +00001009 return NULL;
1010 }
1011 return x;
1012}
1013
Guido van Rossume15dee51995-07-18 14:12:02 +00001014PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001015PyNumber_Long(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001016{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001017 PyNumberMethods *m;
Guido van Rossum4c08d552000-03-10 22:55:18 +00001018 const char *buffer;
Martin v. Löwis18e16552006-02-15 17:27:45 +00001019 Py_ssize_t buffer_len;
Guido van Rossume15dee51995-07-18 14:12:02 +00001020
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001021 if (o == NULL)
1022 return null_error();
Brett Cannonc3647ac2005-04-26 03:45:26 +00001023 m = o->ob_type->tp_as_number;
1024 if (m && m->nb_long) { /* This should include subclasses of long */
1025 PyObject *res = m->nb_long(o);
1026 if (res && (!PyInt_Check(res) && !PyLong_Check(res))) {
1027 PyErr_Format(PyExc_TypeError,
1028 "__long__ returned non-long (type %.200s)",
1029 res->ob_type->tp_name);
1030 Py_DECREF(res);
1031 return NULL;
1032 }
1033 return res;
Guido van Rossum9e896b32000-04-05 20:11:21 +00001034 }
Brett Cannonc3647ac2005-04-26 03:45:26 +00001035 if (PyLong_Check(o)) /* A long subclass without nb_long */
Tim Petersdb30ac42002-03-02 04:14:21 +00001036 return _PyLong_Copy((PyLongObject *)o);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001037 if (PyString_Check(o))
Guido van Rossum77660912002-04-16 16:32:50 +00001038 /* need to do extra error checking that PyLong_FromString()
Barry Warsaw226ae6c1999-10-12 19:54:53 +00001039 * doesn't do. In particular long('9.5') must raise an
1040 * exception, not truncate the float.
1041 */
Guido van Rossum4c08d552000-03-10 22:55:18 +00001042 return long_from_string(PyString_AS_STRING(o),
1043 PyString_GET_SIZE(o));
Martin v. Löwis339d0f72001-08-17 18:39:25 +00001044#ifdef Py_USING_UNICODE
Guido van Rossum9e896b32000-04-05 20:11:21 +00001045 if (PyUnicode_Check(o))
1046 /* The above check is done in PyLong_FromUnicode(). */
1047 return PyLong_FromUnicode(PyUnicode_AS_UNICODE(o),
1048 PyUnicode_GET_SIZE(o),
1049 10);
Martin v. Löwis339d0f72001-08-17 18:39:25 +00001050#endif
Guido van Rossum4c08d552000-03-10 22:55:18 +00001051 if (!PyObject_AsCharBuffer(o, &buffer, &buffer_len))
1052 return long_from_string(buffer, buffer_len);
Guido van Rossume15dee51995-07-18 14:12:02 +00001053
Raymond Hettinger478d47a2002-06-06 15:45:38 +00001054 return type_error("long() argument must be a string or a number");
Guido van Rossume15dee51995-07-18 14:12:02 +00001055}
1056
1057PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001058PyNumber_Float(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001059{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001060 PyNumberMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001061
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001062 if (o == NULL)
1063 return null_error();
Brett Cannonc3647ac2005-04-26 03:45:26 +00001064 m = o->ob_type->tp_as_number;
1065 if (m && m->nb_float) { /* This should include subclasses of float */
1066 PyObject *res = m->nb_float(o);
1067 if (res && !PyFloat_Check(res)) {
1068 PyErr_Format(PyExc_TypeError,
1069 "__float__ returned non-float (type %.200s)",
1070 res->ob_type->tp_name);
1071 Py_DECREF(res);
1072 return NULL;
1073 }
1074 return res;
Guido van Rossum9e896b32000-04-05 20:11:21 +00001075 }
Brett Cannonc3647ac2005-04-26 03:45:26 +00001076 if (PyFloat_Check(o)) { /* A float subclass with nb_float == NULL */
Tim Peters7a50f252001-09-10 21:28:20 +00001077 PyFloatObject *po = (PyFloatObject *)o;
1078 return PyFloat_FromDouble(po->ob_fval);
1079 }
Guido van Rossum4c08d552000-03-10 22:55:18 +00001080 return PyFloat_FromString(o, NULL);
Guido van Rossume15dee51995-07-18 14:12:02 +00001081}
1082
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001083/* Operations on sequences */
Guido van Rossume15dee51995-07-18 14:12:02 +00001084
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001085int
Fred Drake79912472000-07-09 04:06:11 +00001086PySequence_Check(PyObject *s)
Guido van Rossume15dee51995-07-18 14:12:02 +00001087{
Raymond Hettinger1be1a792004-09-19 06:00:15 +00001088 if (s && PyInstance_Check(s))
Raymond Hettingere2eda602004-04-04 08:51:41 +00001089 return PyObject_HasAttrString(s, "__getitem__");
Guido van Rossum8700b422001-09-07 20:20:11 +00001090 return s != NULL && s->ob_type->tp_as_sequence &&
1091 s->ob_type->tp_as_sequence->sq_item != NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +00001092}
1093
Martin v. Löwis18e16552006-02-15 17:27:45 +00001094Py_ssize_t
Jeremy Hylton6253f832000-07-12 12:56:19 +00001095PySequence_Size(PyObject *s)
Guido van Rossume15dee51995-07-18 14:12:02 +00001096{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001097 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001098
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001099 if (s == NULL) {
1100 null_error();
1101 return -1;
1102 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001103
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001104 m = s->ob_type->tp_as_sequence;
1105 if (m && m->sq_length)
1106 return m->sq_length(s);
Guido van Rossume15dee51995-07-18 14:12:02 +00001107
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001108 type_error("len() of unsized object");
1109 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +00001110}
1111
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +00001112#undef PySequence_Length
Martin v. Löwis18e16552006-02-15 17:27:45 +00001113Py_ssize_t
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +00001114PySequence_Length(PyObject *s)
1115{
1116 return PySequence_Size(s);
1117}
1118#define PySequence_Length PySequence_Size
1119
Guido van Rossume15dee51995-07-18 14:12:02 +00001120PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001121PySequence_Concat(PyObject *s, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001122{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001123 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001124
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001125 if (s == NULL || o == NULL)
1126 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001127
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001128 m = s->ob_type->tp_as_sequence;
1129 if (m && m->sq_concat)
1130 return m->sq_concat(s, o);
1131
Armin Rigofd163f92005-12-29 15:59:19 +00001132 /* Instances of user classes defining an __add__() method only
1133 have an nb_add slot, not an sq_concat slot. So we fall back
1134 to nb_add if both arguments appear to be sequences. */
1135 if (PySequence_Check(s) && PySequence_Check(o)) {
1136 PyObject *result = binary_op1(s, o, NB_SLOT(nb_add));
1137 if (result != Py_NotImplemented)
1138 return result;
1139 Py_DECREF(result);
1140 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001141 return type_error("object can't be concatenated");
Guido van Rossume15dee51995-07-18 14:12:02 +00001142}
1143
1144PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +00001145PySequence_Repeat(PyObject *o, Py_ssize_t count)
Guido van Rossume15dee51995-07-18 14:12:02 +00001146{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001147 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001148
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001149 if (o == NULL)
1150 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001151
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001152 m = o->ob_type->tp_as_sequence;
1153 if (m && m->sq_repeat)
1154 return m->sq_repeat(o, count);
1155
Armin Rigofd163f92005-12-29 15:59:19 +00001156 /* Instances of user classes defining a __mul__() method only
1157 have an nb_multiply slot, not an sq_repeat slot. so we fall back
1158 to nb_multiply if o appears to be a sequence. */
1159 if (PySequence_Check(o)) {
1160 PyObject *n, *result;
Martin v. Löwiseb079f12006-02-16 14:32:27 +00001161 n = PyInt_FromSsize_t(count);
Armin Rigofd163f92005-12-29 15:59:19 +00001162 if (n == NULL)
1163 return NULL;
1164 result = binary_op1(o, n, NB_SLOT(nb_multiply));
1165 Py_DECREF(n);
1166 if (result != Py_NotImplemented)
1167 return result;
1168 Py_DECREF(result);
1169 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001170 return type_error("object can't be repeated");
Guido van Rossume15dee51995-07-18 14:12:02 +00001171}
1172
1173PyObject *
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001174PySequence_InPlaceConcat(PyObject *s, PyObject *o)
1175{
1176 PySequenceMethods *m;
1177
1178 if (s == NULL || o == NULL)
1179 return null_error();
1180
1181 m = s->ob_type->tp_as_sequence;
1182 if (m && HASINPLACE(s) && m->sq_inplace_concat)
1183 return m->sq_inplace_concat(s, o);
1184 if (m && m->sq_concat)
1185 return m->sq_concat(s, o);
1186
Armin Rigofd163f92005-12-29 15:59:19 +00001187 if (PySequence_Check(s) && PySequence_Check(o)) {
1188 PyObject *result = binary_iop1(s, o, NB_SLOT(nb_inplace_add),
1189 NB_SLOT(nb_add));
1190 if (result != Py_NotImplemented)
1191 return result;
1192 Py_DECREF(result);
1193 }
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001194 return type_error("object can't be concatenated");
1195}
1196
1197PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +00001198PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count)
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001199{
1200 PySequenceMethods *m;
1201
1202 if (o == NULL)
1203 return null_error();
1204
1205 m = o->ob_type->tp_as_sequence;
1206 if (m && HASINPLACE(o) && m->sq_inplace_repeat)
1207 return m->sq_inplace_repeat(o, count);
1208 if (m && m->sq_repeat)
1209 return m->sq_repeat(o, count);
1210
Armin Rigofd163f92005-12-29 15:59:19 +00001211 if (PySequence_Check(o)) {
1212 PyObject *n, *result;
Martin v. Löwiseb079f12006-02-16 14:32:27 +00001213 n = PyInt_FromSsize_t(count);
Armin Rigofd163f92005-12-29 15:59:19 +00001214 if (n == NULL)
1215 return NULL;
1216 result = binary_iop1(o, n, NB_SLOT(nb_inplace_multiply),
1217 NB_SLOT(nb_multiply));
1218 Py_DECREF(n);
1219 if (result != Py_NotImplemented)
1220 return result;
1221 Py_DECREF(result);
1222 }
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001223 return type_error("object can't be repeated");
1224}
1225
1226PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +00001227PySequence_GetItem(PyObject *s, Py_ssize_t i)
Guido van Rossume15dee51995-07-18 14:12:02 +00001228{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001229 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001230
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001231 if (s == NULL)
1232 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001233
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001234 m = s->ob_type->tp_as_sequence;
1235 if (m && m->sq_item) {
1236 if (i < 0) {
1237 if (m->sq_length) {
Martin v. Löwis18e16552006-02-15 17:27:45 +00001238 Py_ssize_t l = (*m->sq_length)(s);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001239 if (l < 0)
1240 return NULL;
1241 i += l;
1242 }
1243 }
1244 return m->sq_item(s, i);
1245 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001246
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001247 return type_error("unindexable object");
Guido van Rossume15dee51995-07-18 14:12:02 +00001248}
1249
1250PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +00001251PySequence_GetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2)
Guido van Rossume15dee51995-07-18 14:12:02 +00001252{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001253 PySequenceMethods *m;
Thomas Wouters1d75a792000-08-17 22:37:32 +00001254 PyMappingMethods *mp;
Guido van Rossume15dee51995-07-18 14:12:02 +00001255
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001256 if (!s) return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001257
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001258 m = s->ob_type->tp_as_sequence;
1259 if (m && m->sq_slice) {
1260 if (i1 < 0 || i2 < 0) {
1261 if (m->sq_length) {
Martin v. Löwis18e16552006-02-15 17:27:45 +00001262 Py_ssize_t l = (*m->sq_length)(s);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001263 if (l < 0)
1264 return NULL;
1265 if (i1 < 0)
1266 i1 += l;
1267 if (i2 < 0)
1268 i2 += l;
1269 }
1270 }
1271 return m->sq_slice(s, i1, i2);
Thomas Wouters1d75a792000-08-17 22:37:32 +00001272 } else if ((mp = s->ob_type->tp_as_mapping) && mp->mp_subscript) {
1273 PyObject *res;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001274 PyObject *slice = _PySlice_FromIndices(i1, i2);
Thomas Wouters1d75a792000-08-17 22:37:32 +00001275 if (!slice)
1276 return NULL;
1277 res = mp->mp_subscript(s, slice);
1278 Py_DECREF(slice);
1279 return res;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001280 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001281
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001282 return type_error("unsliceable object");
Guido van Rossume15dee51995-07-18 14:12:02 +00001283}
1284
1285int
Martin v. Löwis18e16552006-02-15 17:27:45 +00001286PySequence_SetItem(PyObject *s, Py_ssize_t i, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001287{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001288 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001289
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001290 if (s == NULL) {
1291 null_error();
1292 return -1;
1293 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001294
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001295 m = s->ob_type->tp_as_sequence;
1296 if (m && m->sq_ass_item) {
1297 if (i < 0) {
1298 if (m->sq_length) {
Martin v. Löwis18e16552006-02-15 17:27:45 +00001299 Py_ssize_t l = (*m->sq_length)(s);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001300 if (l < 0)
Guido van Rossumed6219b1998-05-29 02:59:33 +00001301 return -1;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001302 i += l;
1303 }
1304 }
1305 return m->sq_ass_item(s, i, o);
1306 }
1307
Raymond Hettinger98779e02003-10-27 09:22:16 +00001308 type_error("object does not support item assignment");
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001309 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +00001310}
1311
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001312int
Martin v. Löwis18e16552006-02-15 17:27:45 +00001313PySequence_DelItem(PyObject *s, Py_ssize_t i)
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001314{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001315 PySequenceMethods *m;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001316
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001317 if (s == NULL) {
1318 null_error();
1319 return -1;
1320 }
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001321
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001322 m = s->ob_type->tp_as_sequence;
1323 if (m && m->sq_ass_item) {
1324 if (i < 0) {
1325 if (m->sq_length) {
Martin v. Löwis18e16552006-02-15 17:27:45 +00001326 Py_ssize_t l = (*m->sq_length)(s);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001327 if (l < 0)
Guido van Rossumed6219b1998-05-29 02:59:33 +00001328 return -1;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001329 i += l;
1330 }
1331 }
1332 return m->sq_ass_item(s, i, (PyObject *)NULL);
1333 }
1334
1335 type_error("object doesn't support item deletion");
1336 return -1;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001337}
1338
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001339int
Martin v. Löwis18e16552006-02-15 17:27:45 +00001340PySequence_SetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001341{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001342 PySequenceMethods *m;
Thomas Wouters1d75a792000-08-17 22:37:32 +00001343 PyMappingMethods *mp;
Guido van Rossume15dee51995-07-18 14:12:02 +00001344
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001345 if (s == NULL) {
1346 null_error();
1347 return -1;
1348 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001349
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001350 m = s->ob_type->tp_as_sequence;
1351 if (m && m->sq_ass_slice) {
1352 if (i1 < 0 || i2 < 0) {
1353 if (m->sq_length) {
Martin v. Löwis18e16552006-02-15 17:27:45 +00001354 Py_ssize_t l = (*m->sq_length)(s);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001355 if (l < 0)
Guido van Rossumed6219b1998-05-29 02:59:33 +00001356 return -1;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001357 if (i1 < 0)
1358 i1 += l;
1359 if (i2 < 0)
1360 i2 += l;
1361 }
1362 }
1363 return m->sq_ass_slice(s, i1, i2, o);
Thomas Wouters1d75a792000-08-17 22:37:32 +00001364 } else if ((mp = s->ob_type->tp_as_mapping) && mp->mp_ass_subscript) {
1365 int res;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001366 PyObject *slice = _PySlice_FromIndices(i1, i2);
Thomas Wouters1d75a792000-08-17 22:37:32 +00001367 if (!slice)
1368 return -1;
1369 res = mp->mp_ass_subscript(s, slice, o);
1370 Py_DECREF(slice);
1371 return res;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001372 }
Thomas Wouters1d75a792000-08-17 22:37:32 +00001373
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001374 type_error("object doesn't support slice assignment");
1375 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +00001376}
1377
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001378int
Martin v. Löwis18e16552006-02-15 17:27:45 +00001379PySequence_DelSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2)
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001380{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001381 PySequenceMethods *m;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001382
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001383 if (s == NULL) {
1384 null_error();
1385 return -1;
1386 }
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001387
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001388 m = s->ob_type->tp_as_sequence;
1389 if (m && m->sq_ass_slice) {
1390 if (i1 < 0 || i2 < 0) {
1391 if (m->sq_length) {
Martin v. Löwis18e16552006-02-15 17:27:45 +00001392 Py_ssize_t l = (*m->sq_length)(s);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001393 if (l < 0)
Guido van Rossumed6219b1998-05-29 02:59:33 +00001394 return -1;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001395 if (i1 < 0)
1396 i1 += l;
1397 if (i2 < 0)
1398 i2 += l;
1399 }
1400 }
1401 return m->sq_ass_slice(s, i1, i2, (PyObject *)NULL);
1402 }
1403 type_error("object doesn't support slice deletion");
1404 return -1;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001405}
1406
Guido van Rossume15dee51995-07-18 14:12:02 +00001407PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001408PySequence_Tuple(PyObject *v)
Guido van Rossume15dee51995-07-18 14:12:02 +00001409{
Tim Peters6912d4d2001-05-05 03:56:37 +00001410 PyObject *it; /* iter(v) */
Martin v. Löwis18e16552006-02-15 17:27:45 +00001411 Py_ssize_t n; /* guess for result tuple size */
Tim Peters6912d4d2001-05-05 03:56:37 +00001412 PyObject *result;
Martin v. Löwis18e16552006-02-15 17:27:45 +00001413 Py_ssize_t j;
Guido van Rossume15dee51995-07-18 14:12:02 +00001414
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001415 if (v == NULL)
1416 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001417
Tim Peters6912d4d2001-05-05 03:56:37 +00001418 /* Special-case the common tuple and list cases, for efficiency. */
Tim Peters4c3a0a32001-09-10 23:37:46 +00001419 if (PyTuple_CheckExact(v)) {
1420 /* Note that we can't know whether it's safe to return
1421 a tuple *subclass* instance as-is, hence the restriction
Tim Peters8ff70a92001-09-10 23:53:53 +00001422 to exact tuples here. In contrast, lists always make
1423 a copy, so there's no need for exactness below. */
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001424 Py_INCREF(v);
1425 return v;
Guido van Rossume15dee51995-07-18 14:12:02 +00001426 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001427 if (PyList_Check(v))
1428 return PyList_AsTuple(v);
1429
Tim Peters6912d4d2001-05-05 03:56:37 +00001430 /* Get iterator. */
1431 it = PyObject_GetIter(v);
1432 if (it == NULL)
Tim Peters1fc240e2001-10-26 05:06:50 +00001433 return NULL;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001434
Tim Peters6912d4d2001-05-05 03:56:37 +00001435 /* Guess result size and allocate space. */
Armin Rigof5b3e362006-02-11 21:32:43 +00001436 n = _PyObject_LengthHint(v);
Tim Peters6912d4d2001-05-05 03:56:37 +00001437 if (n < 0) {
Raymond Hettingera710b332005-08-21 11:03:59 +00001438 if (!PyErr_ExceptionMatches(PyExc_TypeError) &&
1439 !PyErr_ExceptionMatches(PyExc_AttributeError)) {
1440 Py_DECREF(it);
1441 return NULL;
1442 }
Tim Peters6912d4d2001-05-05 03:56:37 +00001443 PyErr_Clear();
1444 n = 10; /* arbitrary */
1445 }
1446 result = PyTuple_New(n);
1447 if (result == NULL)
1448 goto Fail;
1449
1450 /* Fill the tuple. */
1451 for (j = 0; ; ++j) {
1452 PyObject *item = PyIter_Next(it);
1453 if (item == NULL) {
1454 if (PyErr_Occurred())
1455 goto Fail;
1456 break;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001457 }
Tim Peters6912d4d2001-05-05 03:56:37 +00001458 if (j >= n) {
Martin v. Löwis18e16552006-02-15 17:27:45 +00001459 Py_ssize_t oldn = n;
Raymond Hettinger4d012592004-12-16 10:38:38 +00001460 /* The over-allocation strategy can grow a bit faster
1461 than for lists because unlike lists the
1462 over-allocation isn't permanent -- we reclaim
1463 the excess before the end of this routine.
1464 So, grow by ten and then add 25%.
1465 */
1466 n += 10;
1467 n += n >> 2;
1468 if (n < oldn) {
1469 /* Check for overflow */
1470 PyErr_NoMemory();
Raymond Hettingere6bdb372004-12-16 15:10:21 +00001471 Py_DECREF(item);
Raymond Hettinger4d012592004-12-16 10:38:38 +00001472 goto Fail;
1473 }
Tim Peters4324aa32001-05-28 22:30:08 +00001474 if (_PyTuple_Resize(&result, n) != 0) {
Tim Peters12d0a6c2001-05-05 04:10:25 +00001475 Py_DECREF(item);
Tim Peters6912d4d2001-05-05 03:56:37 +00001476 goto Fail;
Tim Peters12d0a6c2001-05-05 04:10:25 +00001477 }
Tim Peters6912d4d2001-05-05 03:56:37 +00001478 }
1479 PyTuple_SET_ITEM(result, j, item);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001480 }
1481
Tim Peters6912d4d2001-05-05 03:56:37 +00001482 /* Cut tuple back if guess was too large. */
1483 if (j < n &&
Tim Peters4324aa32001-05-28 22:30:08 +00001484 _PyTuple_Resize(&result, j) != 0)
Tim Peters6912d4d2001-05-05 03:56:37 +00001485 goto Fail;
1486
1487 Py_DECREF(it);
1488 return result;
1489
1490Fail:
1491 Py_XDECREF(result);
1492 Py_DECREF(it);
1493 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +00001494}
1495
Guido van Rossum3c5936a1996-12-05 21:51:24 +00001496PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001497PySequence_List(PyObject *v)
Guido van Rossum3c5936a1996-12-05 21:51:24 +00001498{
Tim Petersf553f892001-05-01 20:45:31 +00001499 PyObject *result; /* result list */
Raymond Hettinger8ca92ae2004-03-11 09:13:12 +00001500 PyObject *rv; /* return value from PyList_Extend */
Guido van Rossum4669fb41997-04-02 05:31:09 +00001501
Guido van Rossum5dba9e81998-07-10 18:03:50 +00001502 if (v == NULL)
1503 return null_error();
1504
Raymond Hettinger8ca92ae2004-03-11 09:13:12 +00001505 result = PyList_New(0);
1506 if (result == NULL)
Tim Petersf553f892001-05-01 20:45:31 +00001507 return NULL;
1508
Raymond Hettinger8ca92ae2004-03-11 09:13:12 +00001509 rv = _PyList_Extend((PyListObject *)result, v);
1510 if (rv == NULL) {
1511 Py_DECREF(result);
Tim Petersf553f892001-05-01 20:45:31 +00001512 return NULL;
1513 }
Raymond Hettinger969d8c02004-03-17 05:24:23 +00001514 Py_DECREF(rv);
Tim Petersf553f892001-05-01 20:45:31 +00001515 return result;
Guido van Rossum3c5936a1996-12-05 21:51:24 +00001516}
1517
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001518PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001519PySequence_Fast(PyObject *v, const char *m)
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001520{
Raymond Hettinger2fb70292004-01-11 23:26:51 +00001521 PyObject *it;
1522
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001523 if (v == NULL)
1524 return null_error();
1525
Michael W. Hudson2801fe12002-11-05 18:05:49 +00001526 if (PyList_CheckExact(v) || PyTuple_CheckExact(v)) {
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001527 Py_INCREF(v);
1528 return v;
1529 }
1530
Raymond Hettinger2fb70292004-01-11 23:26:51 +00001531 it = PyObject_GetIter(v);
1532 if (it == NULL) {
1533 if (PyErr_ExceptionMatches(PyExc_TypeError))
1534 return type_error(m);
1535 return NULL;
1536 }
1537
Raymond Hettinger193814c2004-12-18 19:00:59 +00001538 v = PySequence_List(it);
Raymond Hettinger2fb70292004-01-11 23:26:51 +00001539 Py_DECREF(it);
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001540
1541 return v;
1542}
1543
Tim Peters16a77ad2001-09-08 04:00:12 +00001544/* Iterate over seq. Result depends on the operation:
1545 PY_ITERSEARCH_COUNT: -1 if error, else # of times obj appears in seq.
1546 PY_ITERSEARCH_INDEX: 0-based index of first occurence of obj in seq;
1547 set ValueError and return -1 if none found; also return -1 on error.
1548 Py_ITERSEARCH_CONTAINS: return 1 if obj in seq, else 0; -1 on error.
1549*/
Neal Norwitz1fc4b772006-03-04 18:49:58 +00001550Py_ssize_t
Tim Peters16a77ad2001-09-08 04:00:12 +00001551_PySequence_IterSearch(PyObject *seq, PyObject *obj, int operation)
Guido van Rossume15dee51995-07-18 14:12:02 +00001552{
Neal Norwitz1fc4b772006-03-04 18:49:58 +00001553 Py_ssize_t n;
Tim Peters16a77ad2001-09-08 04:00:12 +00001554 int wrapped; /* for PY_ITERSEARCH_INDEX, true iff n wrapped around */
1555 PyObject *it; /* iter(seq) */
Guido van Rossume15dee51995-07-18 14:12:02 +00001556
Tim Peters16a77ad2001-09-08 04:00:12 +00001557 if (seq == NULL || obj == NULL) {
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001558 null_error();
1559 return -1;
1560 }
Tim Peters75f8e352001-05-05 11:33:43 +00001561
Tim Peters16a77ad2001-09-08 04:00:12 +00001562 it = PyObject_GetIter(seq);
Tim Peters75f8e352001-05-05 11:33:43 +00001563 if (it == NULL) {
Tim Peters16a77ad2001-09-08 04:00:12 +00001564 type_error("iterable argument required");
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001565 return -1;
Tim Peters75f8e352001-05-05 11:33:43 +00001566 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001567
Tim Peters16a77ad2001-09-08 04:00:12 +00001568 n = wrapped = 0;
Tim Peters75f8e352001-05-05 11:33:43 +00001569 for (;;) {
1570 int cmp;
1571 PyObject *item = PyIter_Next(it);
1572 if (item == NULL) {
1573 if (PyErr_Occurred())
1574 goto Fail;
1575 break;
1576 }
Tim Peters16a77ad2001-09-08 04:00:12 +00001577
1578 cmp = PyObject_RichCompareBool(obj, item, Py_EQ);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001579 Py_DECREF(item);
Tim Peters75f8e352001-05-05 11:33:43 +00001580 if (cmp < 0)
1581 goto Fail;
1582 if (cmp > 0) {
Tim Peters16a77ad2001-09-08 04:00:12 +00001583 switch (operation) {
1584 case PY_ITERSEARCH_COUNT:
1585 ++n;
1586 if (n <= 0) {
Neal Norwitz1fc4b772006-03-04 18:49:58 +00001587 /* XXX(nnorwitz): int means ssize_t */
Tim Peters16a77ad2001-09-08 04:00:12 +00001588 PyErr_SetString(PyExc_OverflowError,
Tim Peters75f8e352001-05-05 11:33:43 +00001589 "count exceeds C int size");
Tim Peters16a77ad2001-09-08 04:00:12 +00001590 goto Fail;
1591 }
1592 break;
1593
1594 case PY_ITERSEARCH_INDEX:
1595 if (wrapped) {
Neal Norwitz1fc4b772006-03-04 18:49:58 +00001596 /* XXX(nnorwitz): int means ssize_t */
Tim Peters16a77ad2001-09-08 04:00:12 +00001597 PyErr_SetString(PyExc_OverflowError,
1598 "index exceeds C int size");
1599 goto Fail;
1600 }
1601 goto Done;
1602
1603 case PY_ITERSEARCH_CONTAINS:
1604 n = 1;
1605 goto Done;
1606
1607 default:
1608 assert(!"unknown operation");
Tim Peters75f8e352001-05-05 11:33:43 +00001609 }
Tim Peters16a77ad2001-09-08 04:00:12 +00001610 }
1611
1612 if (operation == PY_ITERSEARCH_INDEX) {
1613 ++n;
1614 if (n <= 0)
1615 wrapped = 1;
Tim Peters75f8e352001-05-05 11:33:43 +00001616 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001617 }
Tim Peters16a77ad2001-09-08 04:00:12 +00001618
1619 if (operation != PY_ITERSEARCH_INDEX)
1620 goto Done;
1621
1622 PyErr_SetString(PyExc_ValueError,
1623 "sequence.index(x): x not in sequence");
1624 /* fall into failure code */
1625Fail:
1626 n = -1;
1627 /* fall through */
1628Done:
Tim Peters75f8e352001-05-05 11:33:43 +00001629 Py_DECREF(it);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001630 return n;
Tim Peters75f8e352001-05-05 11:33:43 +00001631
Guido van Rossume15dee51995-07-18 14:12:02 +00001632}
1633
Tim Peters16a77ad2001-09-08 04:00:12 +00001634/* Return # of times o appears in s. */
Neal Norwitz1fc4b772006-03-04 18:49:58 +00001635Py_ssize_t
Tim Peters16a77ad2001-09-08 04:00:12 +00001636PySequence_Count(PyObject *s, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001637{
Tim Peters16a77ad2001-09-08 04:00:12 +00001638 return _PySequence_IterSearch(s, o, PY_ITERSEARCH_COUNT);
Guido van Rossume15dee51995-07-18 14:12:02 +00001639}
1640
Tim Peterscb8d3682001-05-05 21:05:01 +00001641/* Return -1 if error; 1 if ob in seq; 0 if ob not in seq.
Tim Peters16a77ad2001-09-08 04:00:12 +00001642 * Use sq_contains if possible, else defer to _PySequence_IterSearch().
Tim Peterscb8d3682001-05-05 21:05:01 +00001643 */
1644int
1645PySequence_Contains(PyObject *seq, PyObject *ob)
1646{
Neal Norwitz1fc4b772006-03-04 18:49:58 +00001647 Py_ssize_t result;
Tim Peterscb8d3682001-05-05 21:05:01 +00001648 if (PyType_HasFeature(seq->ob_type, Py_TPFLAGS_HAVE_SEQUENCE_IN)) {
1649 PySequenceMethods *sqm = seq->ob_type->tp_as_sequence;
1650 if (sqm != NULL && sqm->sq_contains != NULL)
1651 return (*sqm->sq_contains)(seq, ob);
1652 }
Neal Norwitz1fc4b772006-03-04 18:49:58 +00001653 result = _PySequence_IterSearch(seq, ob, PY_ITERSEARCH_CONTAINS);
1654 return Py_SAFE_DOWNCAST(result, Py_ssize_t, int);
Tim Peterscb8d3682001-05-05 21:05:01 +00001655}
1656
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001657/* Backwards compatibility */
1658#undef PySequence_In
1659int
Fred Drake79912472000-07-09 04:06:11 +00001660PySequence_In(PyObject *w, PyObject *v)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001661{
1662 return PySequence_Contains(w, v);
1663}
1664
Neal Norwitz1fc4b772006-03-04 18:49:58 +00001665Py_ssize_t
Fred Drake79912472000-07-09 04:06:11 +00001666PySequence_Index(PyObject *s, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001667{
Tim Peters16a77ad2001-09-08 04:00:12 +00001668 return _PySequence_IterSearch(s, o, PY_ITERSEARCH_INDEX);
Guido van Rossume15dee51995-07-18 14:12:02 +00001669}
1670
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001671/* Operations on mappings */
1672
1673int
Fred Drake79912472000-07-09 04:06:11 +00001674PyMapping_Check(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001675{
Raymond Hettinger1be1a792004-09-19 06:00:15 +00001676 if (o && PyInstance_Check(o))
Raymond Hettingere2eda602004-04-04 08:51:41 +00001677 return PyObject_HasAttrString(o, "__getitem__");
1678
1679 return o && o->ob_type->tp_as_mapping &&
1680 o->ob_type->tp_as_mapping->mp_subscript &&
Raymond Hettingered9192e2004-04-05 08:14:48 +00001681 !(o->ob_type->tp_as_sequence &&
1682 o->ob_type->tp_as_sequence->sq_slice);
Guido van Rossume15dee51995-07-18 14:12:02 +00001683}
1684
Martin v. Löwis18e16552006-02-15 17:27:45 +00001685Py_ssize_t
Jeremy Hylton6253f832000-07-12 12:56:19 +00001686PyMapping_Size(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001687{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001688 PyMappingMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001689
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001690 if (o == NULL) {
1691 null_error();
1692 return -1;
1693 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001694
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001695 m = o->ob_type->tp_as_mapping;
1696 if (m && m->mp_length)
1697 return m->mp_length(o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001698
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001699 type_error("len() of unsized object");
1700 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +00001701}
1702
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +00001703#undef PyMapping_Length
Martin v. Löwis18e16552006-02-15 17:27:45 +00001704Py_ssize_t
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +00001705PyMapping_Length(PyObject *o)
1706{
1707 return PyMapping_Size(o);
1708}
1709#define PyMapping_Length PyMapping_Size
1710
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001711PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001712PyMapping_GetItemString(PyObject *o, char *key)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001713{
1714 PyObject *okey, *r;
1715
1716 if (key == NULL)
1717 return null_error();
1718
1719 okey = PyString_FromString(key);
1720 if (okey == NULL)
1721 return NULL;
1722 r = PyObject_GetItem(o, okey);
1723 Py_DECREF(okey);
1724 return r;
1725}
1726
1727int
Fred Drake79912472000-07-09 04:06:11 +00001728PyMapping_SetItemString(PyObject *o, char *key, PyObject *value)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001729{
1730 PyObject *okey;
1731 int r;
1732
1733 if (key == NULL) {
1734 null_error();
1735 return -1;
1736 }
1737
1738 okey = PyString_FromString(key);
1739 if (okey == NULL)
Guido van Rossumed6219b1998-05-29 02:59:33 +00001740 return -1;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001741 r = PyObject_SetItem(o, okey, value);
1742 Py_DECREF(okey);
1743 return r;
1744}
1745
1746int
Fred Drake79912472000-07-09 04:06:11 +00001747PyMapping_HasKeyString(PyObject *o, char *key)
Guido van Rossume15dee51995-07-18 14:12:02 +00001748{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001749 PyObject *v;
Guido van Rossume15dee51995-07-18 14:12:02 +00001750
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001751 v = PyMapping_GetItemString(o, key);
1752 if (v) {
1753 Py_DECREF(v);
1754 return 1;
1755 }
1756 PyErr_Clear();
1757 return 0;
Guido van Rossume15dee51995-07-18 14:12:02 +00001758}
1759
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001760int
Fred Drake79912472000-07-09 04:06:11 +00001761PyMapping_HasKey(PyObject *o, PyObject *key)
Guido van Rossume15dee51995-07-18 14:12:02 +00001762{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001763 PyObject *v;
Guido van Rossume15dee51995-07-18 14:12:02 +00001764
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001765 v = PyObject_GetItem(o, key);
1766 if (v) {
1767 Py_DECREF(v);
1768 return 1;
1769 }
1770 PyErr_Clear();
1771 return 0;
Guido van Rossume15dee51995-07-18 14:12:02 +00001772}
1773
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001774/* Operations on callable objects */
1775
1776/* XXX PyCallable_Check() is in object.c */
1777
Guido van Rossume15dee51995-07-18 14:12:02 +00001778PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001779PyObject_CallObject(PyObject *o, PyObject *a)
Guido van Rossume15dee51995-07-18 14:12:02 +00001780{
Guido van Rossum5560b742001-09-14 16:47:50 +00001781 return PyEval_CallObjectWithKeywords(o, a, NULL);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001782}
Guido van Rossume15dee51995-07-18 14:12:02 +00001783
1784PyObject *
Tim Peters6d6c1a32001-08-02 04:15:00 +00001785PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw)
1786{
1787 ternaryfunc call;
1788
1789 if ((call = func->ob_type->tp_call) != NULL) {
1790 PyObject *result = (*call)(func, arg, kw);
1791 if (result == NULL && !PyErr_Occurred())
1792 PyErr_SetString(
1793 PyExc_SystemError,
1794 "NULL result without error in PyObject_Call");
1795 return result;
1796 }
Fred Drake573395a2001-11-01 20:26:12 +00001797 PyErr_Format(PyExc_TypeError, "'%s' object is not callable",
1798 func->ob_type->tp_name);
Tim Peters6d6c1a32001-08-02 04:15:00 +00001799 return NULL;
1800}
1801
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001802static PyObject*
1803call_function_tail(PyObject *callable, PyObject *args)
1804{
1805 PyObject *retval;
1806
1807 if (args == NULL)
1808 return NULL;
1809
1810 if (!PyTuple_Check(args)) {
1811 PyObject *a;
1812
1813 a = PyTuple_New(1);
1814 if (a == NULL) {
1815 Py_DECREF(args);
1816 return NULL;
1817 }
1818 PyTuple_SET_ITEM(a, 0, args);
1819 args = a;
1820 }
1821 retval = PyObject_Call(callable, args, NULL);
1822
1823 Py_DECREF(args);
1824
1825 return retval;
1826}
1827
Tim Peters6d6c1a32001-08-02 04:15:00 +00001828PyObject *
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001829PyObject_CallFunction(PyObject *callable, char *format, ...)
Guido van Rossume15dee51995-07-18 14:12:02 +00001830{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001831 va_list va;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001832 PyObject *args;
Guido van Rossume15dee51995-07-18 14:12:02 +00001833
Fred Drakeb92cf062001-10-27 06:16:31 +00001834 if (callable == NULL)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001835 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001836
Fred Drakeb92cf062001-10-27 06:16:31 +00001837 if (format && *format) {
1838 va_start(va, format);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001839 args = Py_VaBuildValue(format, va);
Fred Drakeb92cf062001-10-27 06:16:31 +00001840 va_end(va);
1841 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001842 else
1843 args = PyTuple_New(0);
Guido van Rossume15dee51995-07-18 14:12:02 +00001844
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001845 return call_function_tail(callable, args);
1846}
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001847
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001848PyObject *
1849_PyObject_CallFunction_SizeT(PyObject *callable, char *format, ...)
1850{
1851 va_list va;
1852 PyObject *args;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001853
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001854 if (callable == NULL)
1855 return null_error();
1856
1857 if (format && *format) {
1858 va_start(va, format);
1859 args = _Py_VaBuildValue_SizeT(format, va);
1860 va_end(va);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001861 }
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001862 else
1863 args = PyTuple_New(0);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001864
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001865 return call_function_tail(callable, args);
Guido van Rossume15dee51995-07-18 14:12:02 +00001866}
1867
1868PyObject *
Guido van Rossume15dee51995-07-18 14:12:02 +00001869PyObject_CallMethod(PyObject *o, char *name, char *format, ...)
Guido van Rossume15dee51995-07-18 14:12:02 +00001870{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001871 va_list va;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001872 PyObject *args;
Michael W. Hudson0edc7a02005-07-12 10:21:19 +00001873 PyObject *func = NULL;
1874 PyObject *retval = NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +00001875
Fred Drakeb92cf062001-10-27 06:16:31 +00001876 if (o == NULL || name == NULL)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001877 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001878
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001879 func = PyObject_GetAttrString(o, name);
1880 if (func == NULL) {
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001881 PyErr_SetString(PyExc_AttributeError, name);
1882 return 0;
1883 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001884
Michael W. Hudson0edc7a02005-07-12 10:21:19 +00001885 if (!PyCallable_Check(func)) {
1886 type_error("call of non-callable attribute");
1887 goto exit;
1888 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001889
Fred Drakeb92cf062001-10-27 06:16:31 +00001890 if (format && *format) {
1891 va_start(va, format);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001892 args = Py_VaBuildValue(format, va);
Fred Drakeb92cf062001-10-27 06:16:31 +00001893 va_end(va);
1894 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001895 else
1896 args = PyTuple_New(0);
Guido van Rossume15dee51995-07-18 14:12:02 +00001897
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001898 retval = call_function_tail(func, args);
Guido van Rossume15dee51995-07-18 14:12:02 +00001899
Michael W. Hudson0edc7a02005-07-12 10:21:19 +00001900 exit:
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001901 /* args gets consumed in call_function_tail */
1902 Py_XDECREF(func);
1903
1904 return retval;
1905}
1906
1907PyObject *
1908_PyObject_CallMethod_SizeT(PyObject *o, char *name, char *format, ...)
1909{
1910 va_list va;
1911 PyObject *args;
1912 PyObject *func = NULL;
1913 PyObject *retval = NULL;
1914
1915 if (o == NULL || name == NULL)
1916 return null_error();
1917
1918 func = PyObject_GetAttrString(o, name);
1919 if (func == NULL) {
1920 PyErr_SetString(PyExc_AttributeError, name);
1921 return 0;
1922 }
1923
1924 if (!PyCallable_Check(func)) {
1925 type_error("call of non-callable attribute");
1926 goto exit;
1927 }
1928
1929 if (format && *format) {
1930 va_start(va, format);
1931 args = _Py_VaBuildValue_SizeT(format, va);
1932 va_end(va);
1933 }
1934 else
1935 args = PyTuple_New(0);
1936
1937 retval = call_function_tail(func, args);
1938
1939 exit:
1940 /* args gets consumed in call_function_tail */
Michael W. Hudson0edc7a02005-07-12 10:21:19 +00001941 Py_XDECREF(func);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001942
1943 return retval;
Guido van Rossume15dee51995-07-18 14:12:02 +00001944}
Guido van Rossum823649d2001-03-21 18:40:58 +00001945
1946
Fred Drakeb421b8c2001-10-26 16:21:32 +00001947static PyObject *
Fred Drakeb0c079e2001-10-28 02:39:03 +00001948objargs_mktuple(va_list va)
Fred Drakeb421b8c2001-10-26 16:21:32 +00001949{
1950 int i, n = 0;
1951 va_list countva;
1952 PyObject *result, *tmp;
1953
1954#ifdef VA_LIST_IS_ARRAY
1955 memcpy(countva, va, sizeof(va_list));
1956#else
Martin v. Löwis75d2d942002-07-28 10:23:27 +00001957#ifdef __va_copy
1958 __va_copy(countva, va);
1959#else
Fred Drakeb421b8c2001-10-26 16:21:32 +00001960 countva = va;
1961#endif
Martin v. Löwis75d2d942002-07-28 10:23:27 +00001962#endif
Fred Drakeb421b8c2001-10-26 16:21:32 +00001963
1964 while (((PyObject *)va_arg(countva, PyObject *)) != NULL)
1965 ++n;
1966 result = PyTuple_New(n);
1967 if (result != NULL && n > 0) {
1968 for (i = 0; i < n; ++i) {
1969 tmp = (PyObject *)va_arg(va, PyObject *);
1970 PyTuple_SET_ITEM(result, i, tmp);
1971 Py_INCREF(tmp);
1972 }
1973 }
1974 return result;
1975}
1976
1977PyObject *
Fred Drakeb0c079e2001-10-28 02:39:03 +00001978PyObject_CallMethodObjArgs(PyObject *callable, PyObject *name, ...)
Fred Drakeb421b8c2001-10-26 16:21:32 +00001979{
1980 PyObject *args, *tmp;
1981 va_list vargs;
1982
1983 if (callable == NULL || name == NULL)
1984 return null_error();
1985
1986 callable = PyObject_GetAttr(callable, name);
1987 if (callable == NULL)
1988 return NULL;
1989
1990 /* count the args */
1991 va_start(vargs, name);
Fred Drakeb0c079e2001-10-28 02:39:03 +00001992 args = objargs_mktuple(vargs);
Fred Drakeb421b8c2001-10-26 16:21:32 +00001993 va_end(vargs);
1994 if (args == NULL) {
1995 Py_DECREF(callable);
1996 return NULL;
1997 }
1998 tmp = PyObject_Call(callable, args, NULL);
1999 Py_DECREF(args);
2000 Py_DECREF(callable);
2001
2002 return tmp;
2003}
2004
2005PyObject *
Fred Drakeb0c079e2001-10-28 02:39:03 +00002006PyObject_CallFunctionObjArgs(PyObject *callable, ...)
Fred Drakeb421b8c2001-10-26 16:21:32 +00002007{
2008 PyObject *args, *tmp;
2009 va_list vargs;
2010
2011 if (callable == NULL)
2012 return null_error();
2013
2014 /* count the args */
2015 va_start(vargs, callable);
Fred Drakeb0c079e2001-10-28 02:39:03 +00002016 args = objargs_mktuple(vargs);
Fred Drakeb421b8c2001-10-26 16:21:32 +00002017 va_end(vargs);
2018 if (args == NULL)
2019 return NULL;
2020 tmp = PyObject_Call(callable, args, NULL);
2021 Py_DECREF(args);
2022
2023 return tmp;
2024}
2025
2026
Guido van Rossum823649d2001-03-21 18:40:58 +00002027/* isinstance(), issubclass() */
2028
Barry Warsawf16951c2002-04-23 22:45:44 +00002029/* abstract_get_bases() has logically 4 return states, with a sort of 0th
2030 * state that will almost never happen.
2031 *
2032 * 0. creating the __bases__ static string could get a MemoryError
2033 * 1. getattr(cls, '__bases__') could raise an AttributeError
2034 * 2. getattr(cls, '__bases__') could raise some other exception
2035 * 3. getattr(cls, '__bases__') could return a tuple
2036 * 4. getattr(cls, '__bases__') could return something other than a tuple
2037 *
2038 * Only state #3 is a non-error state and only it returns a non-NULL object
2039 * (it returns the retrieved tuple).
2040 *
2041 * Any raised AttributeErrors are masked by clearing the exception and
2042 * returning NULL. If an object other than a tuple comes out of __bases__,
2043 * then again, the return value is NULL. So yes, these two situations
2044 * produce exactly the same results: NULL is returned and no error is set.
2045 *
2046 * If some exception other than AttributeError is raised, then NULL is also
2047 * returned, but the exception is not cleared. That's because we want the
2048 * exception to be propagated along.
2049 *
2050 * Callers are expected to test for PyErr_Occurred() when the return value
2051 * is NULL to decide whether a valid exception should be propagated or not.
2052 * When there's no exception to propagate, it's customary for the caller to
2053 * set a TypeError.
2054 */
Neil Schemenauer6b471292001-10-18 03:18:43 +00002055static PyObject *
2056abstract_get_bases(PyObject *cls)
Guido van Rossum823649d2001-03-21 18:40:58 +00002057{
2058 static PyObject *__bases__ = NULL;
2059 PyObject *bases;
Guido van Rossum823649d2001-03-21 18:40:58 +00002060
2061 if (__bases__ == NULL) {
2062 __bases__ = PyString_FromString("__bases__");
2063 if (__bases__ == NULL)
Neil Schemenauer6b471292001-10-18 03:18:43 +00002064 return NULL;
Guido van Rossum823649d2001-03-21 18:40:58 +00002065 }
Neil Schemenauer6b471292001-10-18 03:18:43 +00002066 bases = PyObject_GetAttr(cls, __bases__);
Barry Warsawf16951c2002-04-23 22:45:44 +00002067 if (bases == NULL) {
2068 if (PyErr_ExceptionMatches(PyExc_AttributeError))
2069 PyErr_Clear();
Neil Schemenauer6b471292001-10-18 03:18:43 +00002070 return NULL;
Guido van Rossum823649d2001-03-21 18:40:58 +00002071 }
Barry Warsawf16951c2002-04-23 22:45:44 +00002072 if (!PyTuple_Check(bases)) {
2073 Py_DECREF(bases);
2074 return NULL;
2075 }
Neil Schemenauer6b471292001-10-18 03:18:43 +00002076 return bases;
2077}
2078
2079
2080static int
2081abstract_issubclass(PyObject *derived, PyObject *cls)
2082{
2083 PyObject *bases;
Martin v. Löwis18e16552006-02-15 17:27:45 +00002084 Py_ssize_t i, n;
Neil Schemenauer6b471292001-10-18 03:18:43 +00002085 int r = 0;
2086
2087
Guido van Rossum823649d2001-03-21 18:40:58 +00002088 if (derived == cls)
2089 return 1;
2090
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00002091 if (PyTuple_Check(cls)) {
2092 /* Not a general sequence -- that opens up the road to
2093 recursion and stack overflow. */
2094 n = PyTuple_GET_SIZE(cls);
2095 for (i = 0; i < n; i++) {
2096 if (derived == PyTuple_GET_ITEM(cls, i))
2097 return 1;
2098 }
2099 }
Neil Schemenauer6b471292001-10-18 03:18:43 +00002100 bases = abstract_get_bases(derived);
Barry Warsawf16951c2002-04-23 22:45:44 +00002101 if (bases == NULL) {
2102 if (PyErr_Occurred())
2103 return -1;
Neil Schemenauer6b471292001-10-18 03:18:43 +00002104 return 0;
Barry Warsawf16951c2002-04-23 22:45:44 +00002105 }
Guido van Rossum823649d2001-03-21 18:40:58 +00002106 n = PyTuple_GET_SIZE(bases);
2107 for (i = 0; i < n; i++) {
Neil Schemenauer6b471292001-10-18 03:18:43 +00002108 r = abstract_issubclass(PyTuple_GET_ITEM(bases, i), cls);
Guido van Rossum823649d2001-03-21 18:40:58 +00002109 if (r != 0)
2110 break;
2111 }
2112
2113 Py_DECREF(bases);
2114
2115 return r;
2116}
2117
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00002118static int
2119check_class(PyObject *cls, const char *error)
2120{
2121 PyObject *bases = abstract_get_bases(cls);
2122 if (bases == NULL) {
2123 /* Do not mask errors. */
2124 if (!PyErr_Occurred())
2125 PyErr_SetString(PyExc_TypeError, error);
2126 return 0;
2127 }
2128 Py_DECREF(bases);
2129 return -1;
2130}
2131
Brett Cannon4f653312004-03-20 22:52:14 +00002132static int
2133recursive_isinstance(PyObject *inst, PyObject *cls, int recursion_depth)
Guido van Rossum823649d2001-03-21 18:40:58 +00002134{
2135 PyObject *icls;
2136 static PyObject *__class__ = NULL;
2137 int retval = 0;
2138
Guido van Rossum03bc7d32003-02-12 03:32:58 +00002139 if (__class__ == NULL) {
2140 __class__ = PyString_FromString("__class__");
2141 if (__class__ == NULL)
2142 return -1;
2143 }
2144
Guido van Rossum45aecf42006-03-15 04:58:47 +00002145 if (PyType_Check(cls)) {
Tim Peters6d6c1a32001-08-02 04:15:00 +00002146 retval = PyObject_TypeCheck(inst, (PyTypeObject *)cls);
Guido van Rossum03bc7d32003-02-12 03:32:58 +00002147 if (retval == 0) {
2148 PyObject *c = PyObject_GetAttr(inst, __class__);
2149 if (c == NULL) {
2150 PyErr_Clear();
2151 }
2152 else {
Guido van Rossume5b130b2003-02-12 03:36:05 +00002153 if (c != (PyObject *)(inst->ob_type) &&
2154 PyType_Check(c))
Guido van Rossum03bc7d32003-02-12 03:32:58 +00002155 retval = PyType_IsSubtype(
2156 (PyTypeObject *)c,
2157 (PyTypeObject *)cls);
2158 Py_DECREF(c);
2159 }
2160 }
Guido van Rossum823649d2001-03-21 18:40:58 +00002161 }
Guido van Rossum03290ec2001-10-07 20:54:12 +00002162 else if (PyTuple_Check(cls)) {
Martin v. Löwis18e16552006-02-15 17:27:45 +00002163 Py_ssize_t i, n;
Guido van Rossum03290ec2001-10-07 20:54:12 +00002164
Brett Cannon4f653312004-03-20 22:52:14 +00002165 if (!recursion_depth) {
2166 PyErr_SetString(PyExc_RuntimeError,
2167 "nest level of tuple too deep");
Tim Peters5f112eb2004-03-21 16:59:09 +00002168 return -1;
Brett Cannon4f653312004-03-20 22:52:14 +00002169 }
2170
Guido van Rossum03290ec2001-10-07 20:54:12 +00002171 n = PyTuple_GET_SIZE(cls);
2172 for (i = 0; i < n; i++) {
Brett Cannon4f653312004-03-20 22:52:14 +00002173 retval = recursive_isinstance(
2174 inst,
2175 PyTuple_GET_ITEM(cls, i),
2176 recursion_depth-1);
Guido van Rossum03290ec2001-10-07 20:54:12 +00002177 if (retval != 0)
2178 break;
2179 }
Guido van Rossum03290ec2001-10-07 20:54:12 +00002180 }
Neil Schemenauer6b471292001-10-18 03:18:43 +00002181 else {
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00002182 if (!check_class(cls,
2183 "isinstance() arg 2 must be a class, type,"
2184 " or tuple of classes and types"))
Neil Schemenauer6b471292001-10-18 03:18:43 +00002185 return -1;
Guido van Rossum823649d2001-03-21 18:40:58 +00002186 icls = PyObject_GetAttr(inst, __class__);
Neil Schemenauer6b471292001-10-18 03:18:43 +00002187 if (icls == NULL) {
2188 PyErr_Clear();
2189 retval = 0;
Guido van Rossum823649d2001-03-21 18:40:58 +00002190 }
Neil Schemenauer6b471292001-10-18 03:18:43 +00002191 else {
2192 retval = abstract_issubclass(icls, cls);
2193 Py_DECREF(icls);
2194 }
Guido van Rossum823649d2001-03-21 18:40:58 +00002195 }
Guido van Rossum823649d2001-03-21 18:40:58 +00002196
Guido van Rossum823649d2001-03-21 18:40:58 +00002197 return retval;
2198}
2199
2200int
Brett Cannon4f653312004-03-20 22:52:14 +00002201PyObject_IsInstance(PyObject *inst, PyObject *cls)
2202{
2203 return recursive_isinstance(inst, cls, Py_GetRecursionLimit());
2204}
2205
2206static int
2207recursive_issubclass(PyObject *derived, PyObject *cls, int recursion_depth)
Guido van Rossum823649d2001-03-21 18:40:58 +00002208{
2209 int retval;
2210
Guido van Rossum45aecf42006-03-15 04:58:47 +00002211 {
Guido van Rossumf6c9ba82003-02-10 16:05:43 +00002212 if (!check_class(derived,
2213 "issubclass() arg 1 must be a class"))
Neil Schemenauer6b471292001-10-18 03:18:43 +00002214 return -1;
Neil Schemenauer6b471292001-10-18 03:18:43 +00002215
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00002216 if (PyTuple_Check(cls)) {
Martin v. Löwis18e16552006-02-15 17:27:45 +00002217 Py_ssize_t i;
2218 Py_ssize_t n = PyTuple_GET_SIZE(cls);
Brett Cannon4f653312004-03-20 22:52:14 +00002219
2220 if (!recursion_depth) {
2221 PyErr_SetString(PyExc_RuntimeError,
2222 "nest level of tuple too deep");
Tim Peters5f112eb2004-03-21 16:59:09 +00002223 return -1;
Brett Cannon4f653312004-03-20 22:52:14 +00002224 }
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00002225 for (i = 0; i < n; ++i) {
Brett Cannon4f653312004-03-20 22:52:14 +00002226 retval = recursive_issubclass(
2227 derived,
2228 PyTuple_GET_ITEM(cls, i),
2229 recursion_depth-1);
Guido van Rossumf6c9ba82003-02-10 16:05:43 +00002230 if (retval != 0) {
2231 /* either found it, or got an error */
Walter Dörwald7e5c6a02002-12-12 19:14:08 +00002232 return retval;
Guido van Rossumf6c9ba82003-02-10 16:05:43 +00002233 }
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00002234 }
Walter Dörwald7e5c6a02002-12-12 19:14:08 +00002235 return 0;
Neil Schemenauer6b471292001-10-18 03:18:43 +00002236 }
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00002237 else {
2238 if (!check_class(cls,
2239 "issubclass() arg 2 must be a class"
2240 " or tuple of classes"))
2241 return -1;
2242 }
Neil Schemenauer6b471292001-10-18 03:18:43 +00002243
2244 retval = abstract_issubclass(derived, cls);
Guido van Rossum823649d2001-03-21 18:40:58 +00002245 }
Guido van Rossum823649d2001-03-21 18:40:58 +00002246
2247 return retval;
2248}
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002249
Brett Cannon4f653312004-03-20 22:52:14 +00002250int
2251PyObject_IsSubclass(PyObject *derived, PyObject *cls)
2252{
2253 return recursive_issubclass(derived, cls, Py_GetRecursionLimit());
2254}
2255
2256
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002257PyObject *
2258PyObject_GetIter(PyObject *o)
2259{
2260 PyTypeObject *t = o->ob_type;
2261 getiterfunc f = NULL;
2262 if (PyType_HasFeature(t, Py_TPFLAGS_HAVE_ITER))
2263 f = t->tp_iter;
2264 if (f == NULL) {
2265 if (PySequence_Check(o))
Guido van Rossum213c7a62001-04-23 14:08:49 +00002266 return PySeqIter_New(o);
Guido van Rossum77660912002-04-16 16:32:50 +00002267 PyErr_SetString(PyExc_TypeError,
Jeremy Hylton89c3a222001-11-09 21:59:42 +00002268 "iteration over non-sequence");
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002269 return NULL;
2270 }
Guido van Rossum213c7a62001-04-23 14:08:49 +00002271 else {
2272 PyObject *res = (*f)(o);
2273 if (res != NULL && !PyIter_Check(res)) {
2274 PyErr_Format(PyExc_TypeError,
2275 "iter() returned non-iterator "
2276 "of type '%.100s'",
2277 res->ob_type->tp_name);
2278 Py_DECREF(res);
2279 res = NULL;
2280 }
2281 return res;
2282 }
2283}
2284
Tim Petersf4848da2001-05-05 00:14:56 +00002285/* Return next item.
2286 * If an error occurs, return NULL. PyErr_Occurred() will be true.
2287 * If the iteration terminates normally, return NULL and clear the
2288 * PyExc_StopIteration exception (if it was set). PyErr_Occurred()
2289 * will be false.
2290 * Else return the next object. PyErr_Occurred() will be false.
2291 */
Guido van Rossum213c7a62001-04-23 14:08:49 +00002292PyObject *
2293PyIter_Next(PyObject *iter)
2294{
Tim Petersf4848da2001-05-05 00:14:56 +00002295 PyObject *result;
Raymond Hettinger8049dde2003-03-01 01:44:32 +00002296 assert(PyIter_Check(iter));
Tim Petersf4848da2001-05-05 00:14:56 +00002297 result = (*iter->ob_type->tp_iternext)(iter);
2298 if (result == NULL &&
2299 PyErr_Occurred() &&
2300 PyErr_ExceptionMatches(PyExc_StopIteration))
2301 PyErr_Clear();
2302 return result;
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002303}