blob: 79dfe4041917a91479d498ffcddd2b3d21ea1558 [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
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00008
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00009/* Shorthands to return certain errors */
Guido van Rossume15dee51995-07-18 14:12:02 +000010
11static PyObject *
Thomas Wouters0e3f5912006-08-11 14:57:12 +000012type_error(const char *msg, PyObject *obj)
Guido van Rossume15dee51995-07-18 14:12:02 +000013{
Thomas Wouters0e3f5912006-08-11 14:57:12 +000014 PyErr_Format(PyExc_TypeError, msg, obj->ob_type->tp_name);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000015 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +000016}
17
Guido van Rossum052b7e11996-11-11 15:08:19 +000018static PyObject *
Fred Drake79912472000-07-09 04:06:11 +000019null_error(void)
Guido van Rossume15dee51995-07-18 14:12:02 +000020{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000021 if (!PyErr_Occurred())
22 PyErr_SetString(PyExc_SystemError,
23 "null argument to internal routine");
24 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +000025}
26
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000027/* Operations on any object */
28
29int
Fred Drake79912472000-07-09 04:06:11 +000030PyObject_Cmp(PyObject *o1, PyObject *o2, int *result)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000031{
32 int r;
33
34 if (o1 == NULL || o2 == NULL) {
35 null_error();
36 return -1;
37 }
38 r = PyObject_Compare(o1, o2);
39 if (PyErr_Occurred())
40 return -1;
41 *result = r;
Guido van Rossume15dee51995-07-18 14:12:02 +000042 return 0;
43}
Guido van Rossume15dee51995-07-18 14:12:02 +000044
45PyObject *
Fred Drake79912472000-07-09 04:06:11 +000046PyObject_Type(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +000047{
48 PyObject *v;
49
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000050 if (o == NULL)
51 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +000052 v = (PyObject *)o->ob_type;
53 Py_INCREF(v);
54 return v;
55}
56
Martin v. Löwis18e16552006-02-15 17:27:45 +000057Py_ssize_t
Jeremy Hylton6253f832000-07-12 12:56:19 +000058PyObject_Size(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +000059{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000060 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +000061
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000062 if (o == NULL) {
63 null_error();
64 return -1;
65 }
Guido van Rossume15dee51995-07-18 14:12:02 +000066
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000067 m = o->ob_type->tp_as_sequence;
68 if (m && m->sq_length)
69 return m->sq_length(o);
Guido van Rossume15dee51995-07-18 14:12:02 +000070
Jeremy Hylton6253f832000-07-12 12:56:19 +000071 return PyMapping_Size(o);
Guido van Rossume15dee51995-07-18 14:12:02 +000072}
73
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +000074#undef PyObject_Length
Martin v. Löwis18e16552006-02-15 17:27:45 +000075Py_ssize_t
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +000076PyObject_Length(PyObject *o)
77{
78 return PyObject_Size(o);
79}
80#define PyObject_Length PyObject_Size
81
Martin v. Löwis18e16552006-02-15 17:27:45 +000082Py_ssize_t
Armin Rigof5b3e362006-02-11 21:32:43 +000083_PyObject_LengthHint(PyObject *o)
Raymond Hettinger6b27cda2005-09-24 21:23:05 +000084{
Martin v. Löwis18e16552006-02-15 17:27:45 +000085 Py_ssize_t rv = PyObject_Size(o);
Raymond Hettinger6b27cda2005-09-24 21:23:05 +000086 if (rv != -1)
87 return rv;
88 if (PyErr_ExceptionMatches(PyExc_TypeError) ||
89 PyErr_ExceptionMatches(PyExc_AttributeError)) {
90 PyObject *err_type, *err_value, *err_tb, *ro;
91
92 PyErr_Fetch(&err_type, &err_value, &err_tb);
Armin Rigof5b3e362006-02-11 21:32:43 +000093 ro = PyObject_CallMethod(o, "__length_hint__", NULL);
Raymond Hettinger6b27cda2005-09-24 21:23:05 +000094 if (ro != NULL) {
Martin v. Löwis18e16552006-02-15 17:27:45 +000095 rv = PyInt_AsLong(ro);
Raymond Hettinger6b27cda2005-09-24 21:23:05 +000096 Py_DECREF(ro);
97 Py_XDECREF(err_type);
98 Py_XDECREF(err_value);
99 Py_XDECREF(err_tb);
100 return rv;
101 }
102 PyErr_Restore(err_type, err_value, err_tb);
103 }
104 return -1;
105}
106
Guido van Rossume15dee51995-07-18 14:12:02 +0000107PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000108PyObject_GetItem(PyObject *o, PyObject *key)
Guido van Rossume15dee51995-07-18 14:12:02 +0000109{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000110 PyMappingMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +0000111
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000112 if (o == NULL || key == NULL)
113 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +0000114
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000115 m = o->ob_type->tp_as_mapping;
116 if (m && m->mp_subscript)
117 return m->mp_subscript(o, key);
Guido van Rossume15dee51995-07-18 14:12:02 +0000118
Guido van Rossum21308241998-08-13 16:44:44 +0000119 if (o->ob_type->tp_as_sequence) {
Guido van Rossum38fff8c2006-03-07 18:50:55 +0000120 PyNumberMethods *nb = key->ob_type->tp_as_number;
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000121 if (nb != NULL && nb->nb_index != NULL) {
Guido van Rossum38fff8c2006-03-07 18:50:55 +0000122 Py_ssize_t key_value = nb->nb_index(key);
Andrew M. Kuchling0f223d22000-02-23 22:21:50 +0000123 if (key_value == -1 && PyErr_Occurred())
124 return NULL;
125 return PySequence_GetItem(o, key_value);
126 }
Guido van Rossum64585f62001-11-24 18:24:47 +0000127 else if (o->ob_type->tp_as_sequence->sq_item)
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000128 return type_error("sequence index must "
129 "be integer, not '%.200s'", key);
Guido van Rossum21308241998-08-13 16:44:44 +0000130 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000131
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000132 return type_error("'%.200s' object is unsubscriptable", o);
Guido van Rossume15dee51995-07-18 14:12:02 +0000133}
134
135int
Fred Drake79912472000-07-09 04:06:11 +0000136PyObject_SetItem(PyObject *o, PyObject *key, PyObject *value)
Guido van Rossume15dee51995-07-18 14:12:02 +0000137{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000138 PyMappingMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +0000139
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000140 if (o == NULL || key == NULL || value == NULL) {
141 null_error();
142 return -1;
143 }
144 m = o->ob_type->tp_as_mapping;
145 if (m && m->mp_ass_subscript)
146 return m->mp_ass_subscript(o, key, value);
Guido van Rossume15dee51995-07-18 14:12:02 +0000147
Guido van Rossum21308241998-08-13 16:44:44 +0000148 if (o->ob_type->tp_as_sequence) {
Guido van Rossum38fff8c2006-03-07 18:50:55 +0000149 PyNumberMethods *nb = key->ob_type->tp_as_number;
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000150 if (nb != NULL && nb->nb_index != NULL) {
Guido van Rossum38fff8c2006-03-07 18:50:55 +0000151 Py_ssize_t key_value = nb->nb_index(key);
Andrew M. Kuchling0f223d22000-02-23 22:21:50 +0000152 if (key_value == -1 && PyErr_Occurred())
153 return -1;
154 return PySequence_SetItem(o, key_value, value);
155 }
Guido van Rossum64585f62001-11-24 18:24:47 +0000156 else if (o->ob_type->tp_as_sequence->sq_ass_item) {
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000157 type_error("sequence index must be "
158 "integer, not '%.200s'", key);
Guido van Rossum64585f62001-11-24 18:24:47 +0000159 return -1;
160 }
Guido van Rossum21308241998-08-13 16:44:44 +0000161 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000162
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000163 type_error("'%.200s' object does not support item assignment", o);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000164 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +0000165}
166
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000167int
Fred Drake79912472000-07-09 04:06:11 +0000168PyObject_DelItem(PyObject *o, PyObject *key)
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000169{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000170 PyMappingMethods *m;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000171
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000172 if (o == NULL || key == NULL) {
173 null_error();
174 return -1;
175 }
176 m = o->ob_type->tp_as_mapping;
177 if (m && m->mp_ass_subscript)
178 return m->mp_ass_subscript(o, key, (PyObject*)NULL);
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000179
Guido van Rossum21308241998-08-13 16:44:44 +0000180 if (o->ob_type->tp_as_sequence) {
Guido van Rossum38fff8c2006-03-07 18:50:55 +0000181 PyNumberMethods *nb = key->ob_type->tp_as_number;
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000182 if (nb != NULL && nb->nb_index != NULL) {
Guido van Rossum38fff8c2006-03-07 18:50:55 +0000183 Py_ssize_t key_value = nb->nb_index(key);
Andrew M. Kuchling0f223d22000-02-23 22:21:50 +0000184 if (key_value == -1 && PyErr_Occurred())
185 return -1;
186 return PySequence_DelItem(o, key_value);
187 }
Guido van Rossum64585f62001-11-24 18:24:47 +0000188 else if (o->ob_type->tp_as_sequence->sq_ass_item) {
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000189 type_error("sequence index must be "
190 "integer, not '%.200s'", key);
Guido van Rossum64585f62001-11-24 18:24:47 +0000191 return -1;
192 }
Guido van Rossum21308241998-08-13 16:44:44 +0000193 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000194
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000195 type_error("'%.200s' object does not support item deletion", o);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000196 return -1;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000197}
198
Martin v. Löwisb0d71d02002-01-05 10:50:30 +0000199int
200PyObject_DelItemString(PyObject *o, char *key)
201{
202 PyObject *okey;
203 int ret;
204
205 if (o == NULL || key == NULL) {
206 null_error();
207 return -1;
208 }
209 okey = PyString_FromString(key);
210 if (okey == NULL)
211 return -1;
212 ret = PyObject_DelItem(o, okey);
213 Py_DECREF(okey);
214 return ret;
215}
216
Thomas Wouters73e5a5b2006-06-08 15:35:45 +0000217int
218PyObject_AsCharBuffer(PyObject *obj,
Guido van Rossum4c08d552000-03-10 22:55:18 +0000219 const char **buffer,
Martin v. Löwis18e16552006-02-15 17:27:45 +0000220 Py_ssize_t *buffer_len)
Guido van Rossum4c08d552000-03-10 22:55:18 +0000221{
222 PyBufferProcs *pb;
Martin v. Löwis15e62742006-02-27 16:46:16 +0000223 char *pp;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000224 Py_ssize_t len;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000225
226 if (obj == NULL || buffer == NULL || buffer_len == NULL) {
227 null_error();
228 return -1;
229 }
230 pb = obj->ob_type->tp_as_buffer;
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000231 if (pb == NULL ||
Guido van Rossum4c08d552000-03-10 22:55:18 +0000232 pb->bf_getcharbuffer == NULL ||
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000233 pb->bf_getsegcount == NULL) {
Guido van Rossum4c08d552000-03-10 22:55:18 +0000234 PyErr_SetString(PyExc_TypeError,
235 "expected a character buffer object");
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000236 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000237 }
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000238 if ((*pb->bf_getsegcount)(obj,NULL) != 1) {
Guido van Rossum4c08d552000-03-10 22:55:18 +0000239 PyErr_SetString(PyExc_TypeError,
240 "expected a single-segment buffer object");
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000241 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000242 }
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000243 len = (*pb->bf_getcharbuffer)(obj, 0, &pp);
Guido van Rossum4c08d552000-03-10 22:55:18 +0000244 if (len < 0)
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000245 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000246 *buffer = pp;
247 *buffer_len = len;
248 return 0;
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000249}
Guido van Rossum4c08d552000-03-10 22:55:18 +0000250
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000251int
252PyObject_CheckReadBuffer(PyObject *obj)
253{
254 PyBufferProcs *pb = obj->ob_type->tp_as_buffer;
255
256 if (pb == NULL ||
257 pb->bf_getreadbuffer == NULL ||
258 pb->bf_getsegcount == NULL ||
259 (*pb->bf_getsegcount)(obj, NULL) != 1)
260 return 0;
261 return 1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000262}
263
264int PyObject_AsReadBuffer(PyObject *obj,
265 const void **buffer,
Martin v. Löwis18e16552006-02-15 17:27:45 +0000266 Py_ssize_t *buffer_len)
Guido van Rossum4c08d552000-03-10 22:55:18 +0000267{
268 PyBufferProcs *pb;
269 void *pp;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000270 Py_ssize_t len;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000271
272 if (obj == NULL || buffer == NULL || buffer_len == NULL) {
273 null_error();
274 return -1;
275 }
276 pb = obj->ob_type->tp_as_buffer;
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000277 if (pb == NULL ||
Guido van Rossum4c08d552000-03-10 22:55:18 +0000278 pb->bf_getreadbuffer == NULL ||
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000279 pb->bf_getsegcount == NULL) {
Guido van Rossum4c08d552000-03-10 22:55:18 +0000280 PyErr_SetString(PyExc_TypeError,
281 "expected a readable buffer object");
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000282 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000283 }
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000284 if ((*pb->bf_getsegcount)(obj, NULL) != 1) {
Guido van Rossum4c08d552000-03-10 22:55:18 +0000285 PyErr_SetString(PyExc_TypeError,
286 "expected a single-segment buffer object");
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000287 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000288 }
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000289 len = (*pb->bf_getreadbuffer)(obj, 0, &pp);
Guido van Rossum4c08d552000-03-10 22:55:18 +0000290 if (len < 0)
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000291 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000292 *buffer = pp;
293 *buffer_len = len;
294 return 0;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000295}
296
297int PyObject_AsWriteBuffer(PyObject *obj,
298 void **buffer,
Martin v. Löwis18e16552006-02-15 17:27:45 +0000299 Py_ssize_t *buffer_len)
Guido van Rossum4c08d552000-03-10 22:55:18 +0000300{
301 PyBufferProcs *pb;
302 void*pp;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000303 Py_ssize_t len;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000304
305 if (obj == NULL || buffer == NULL || buffer_len == NULL) {
306 null_error();
307 return -1;
308 }
309 pb = obj->ob_type->tp_as_buffer;
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000310 if (pb == NULL ||
Guido van Rossum4c08d552000-03-10 22:55:18 +0000311 pb->bf_getwritebuffer == NULL ||
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000312 pb->bf_getsegcount == NULL) {
Guido van Rossum4c08d552000-03-10 22:55:18 +0000313 PyErr_SetString(PyExc_TypeError,
314 "expected a writeable buffer object");
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000315 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000316 }
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000317 if ((*pb->bf_getsegcount)(obj, NULL) != 1) {
Guido van Rossum4c08d552000-03-10 22:55:18 +0000318 PyErr_SetString(PyExc_TypeError,
319 "expected a single-segment buffer object");
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000320 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000321 }
322 len = (*pb->bf_getwritebuffer)(obj,0,&pp);
323 if (len < 0)
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000324 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000325 *buffer = pp;
326 *buffer_len = len;
327 return 0;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000328}
329
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000330/* Operations on numbers */
331
332int
Fred Drake79912472000-07-09 04:06:11 +0000333PyNumber_Check(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +0000334{
Guido van Rossum6921eca2003-02-18 16:36:28 +0000335 return o && o->ob_type->tp_as_number &&
336 (o->ob_type->tp_as_number->nb_int ||
337 o->ob_type->tp_as_number->nb_float);
Guido van Rossume15dee51995-07-18 14:12:02 +0000338}
339
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000340/* Binary operators */
Guido van Rossume15dee51995-07-18 14:12:02 +0000341
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000342#define NB_SLOT(x) offsetof(PyNumberMethods, x)
343#define NB_BINOP(nb_methods, slot) \
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000344 (*(binaryfunc*)(& ((char*)nb_methods)[slot]))
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000345#define NB_TERNOP(nb_methods, slot) \
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000346 (*(ternaryfunc*)(& ((char*)nb_methods)[slot]))
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000347
348/*
349 Calling scheme used for binary operations:
350
Neal Norwitz4886cc32006-08-21 17:06:07 +0000351 Order operations are tried until either a valid result or error:
352 w.op(v,w)[*], v.op(v,w), w.op(v,w)
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000353
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000354 [*] only when v->ob_type != w->ob_type && w->ob_type is a subclass of
355 v->ob_type
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000356 */
357
358static PyObject *
359binary_op1(PyObject *v, PyObject *w, const int op_slot)
Guido van Rossume15dee51995-07-18 14:12:02 +0000360{
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000361 PyObject *x;
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000362 binaryfunc slotv = NULL;
363 binaryfunc slotw = NULL;
364
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000365 if (v->ob_type->tp_as_number != NULL)
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000366 slotv = NB_BINOP(v->ob_type->tp_as_number, op_slot);
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000367 if (w->ob_type != v->ob_type &&
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000368 w->ob_type->tp_as_number != NULL) {
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000369 slotw = NB_BINOP(w->ob_type->tp_as_number, op_slot);
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000370 if (slotw == slotv)
371 slotw = NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +0000372 }
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000373 if (slotv) {
Guido van Rossum89c42642001-10-01 17:10:18 +0000374 if (slotw && PyType_IsSubtype(w->ob_type, v->ob_type)) {
375 x = slotw(v, w);
376 if (x != Py_NotImplemented)
377 return x;
378 Py_DECREF(x); /* can't do it */
379 slotw = NULL;
380 }
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000381 x = slotv(v, w);
382 if (x != Py_NotImplemented)
383 return x;
384 Py_DECREF(x); /* can't do it */
385 }
386 if (slotw) {
387 x = slotw(v, w);
388 if (x != Py_NotImplemented)
389 return x;
390 Py_DECREF(x); /* can't do it */
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000391 }
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000392 Py_INCREF(Py_NotImplemented);
393 return Py_NotImplemented;
394}
Guido van Rossum77660912002-04-16 16:32:50 +0000395
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000396static PyObject *
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000397binop_type_error(PyObject *v, PyObject *w, const char *op_name)
398{
399 PyErr_Format(PyExc_TypeError,
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000400 "unsupported operand type(s) for %.100s: "
401 "'%.100s' and '%.100s'",
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000402 op_name,
403 v->ob_type->tp_name,
404 w->ob_type->tp_name);
405 return NULL;
406}
407
408static PyObject *
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000409binary_op(PyObject *v, PyObject *w, const int op_slot, const char *op_name)
410{
411 PyObject *result = binary_op1(v, w, op_slot);
412 if (result == Py_NotImplemented) {
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000413 Py_DECREF(result);
414 return binop_type_error(v, w, op_name);
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000415 }
416 return result;
Guido van Rossume15dee51995-07-18 14:12:02 +0000417}
418
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000419
420/*
421 Calling scheme used for ternary operations:
422
Neal Norwitz4886cc32006-08-21 17:06:07 +0000423 Order operations are tried until either a valid result or error:
424 v.op(v,w,z), w.op(v,w,z), z.op(v,w,z)
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000425 */
426
427static PyObject *
428ternary_op(PyObject *v,
429 PyObject *w,
430 PyObject *z,
431 const int op_slot,
432 const char *op_name)
Guido van Rossume15dee51995-07-18 14:12:02 +0000433{
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000434 PyNumberMethods *mv, *mw, *mz;
Guido van Rossum84675ac2001-09-29 01:05:03 +0000435 PyObject *x = NULL;
436 ternaryfunc slotv = NULL;
437 ternaryfunc slotw = NULL;
438 ternaryfunc slotz = NULL;
Guido van Rossum77660912002-04-16 16:32:50 +0000439
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000440 mv = v->ob_type->tp_as_number;
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000441 mw = w->ob_type->tp_as_number;
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000442 if (mv != NULL)
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000443 slotv = NB_TERNOP(mv, op_slot);
Guido van Rossum84675ac2001-09-29 01:05:03 +0000444 if (w->ob_type != v->ob_type &&
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000445 mw != NULL) {
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000446 slotw = NB_TERNOP(mw, op_slot);
Guido van Rossum84675ac2001-09-29 01:05:03 +0000447 if (slotw == slotv)
448 slotw = NULL;
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000449 }
Guido van Rossum84675ac2001-09-29 01:05:03 +0000450 if (slotv) {
Guido van Rossum89c42642001-10-01 17:10:18 +0000451 if (slotw && PyType_IsSubtype(w->ob_type, v->ob_type)) {
452 x = slotw(v, w, z);
453 if (x != Py_NotImplemented)
454 return x;
455 Py_DECREF(x); /* can't do it */
456 slotw = NULL;
457 }
Guido van Rossum84675ac2001-09-29 01:05:03 +0000458 x = slotv(v, w, z);
459 if (x != Py_NotImplemented)
460 return x;
461 Py_DECREF(x); /* can't do it */
462 }
463 if (slotw) {
464 x = slotw(v, w, z);
465 if (x != Py_NotImplemented)
466 return x;
467 Py_DECREF(x); /* can't do it */
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000468 }
469 mz = z->ob_type->tp_as_number;
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000470 if (mz != NULL) {
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000471 slotz = NB_TERNOP(mz, op_slot);
Guido van Rossum84675ac2001-09-29 01:05:03 +0000472 if (slotz == slotv || slotz == slotw)
473 slotz = NULL;
474 if (slotz) {
475 x = slotz(v, w, z);
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000476 if (x != Py_NotImplemented)
477 return x;
Guido van Rossum84675ac2001-09-29 01:05:03 +0000478 Py_DECREF(x); /* can't do it */
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000479 }
480 }
481
Guido van Rossum5c66a262001-10-22 04:12:44 +0000482 if (z == Py_None)
483 PyErr_Format(
484 PyExc_TypeError,
485 "unsupported operand type(s) for ** or pow(): "
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000486 "'%.100s' and '%.100s'",
Guido van Rossum5c66a262001-10-22 04:12:44 +0000487 v->ob_type->tp_name,
488 w->ob_type->tp_name);
489 else
490 PyErr_Format(
491 PyExc_TypeError,
492 "unsupported operand type(s) for pow(): "
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000493 "'%.100s', '%.100s', '%.100s'",
Guido van Rossum5c66a262001-10-22 04:12:44 +0000494 v->ob_type->tp_name,
495 w->ob_type->tp_name,
496 z->ob_type->tp_name);
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000497 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +0000498}
499
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000500#define BINARY_FUNC(func, op, op_name) \
501 PyObject * \
502 func(PyObject *v, PyObject *w) { \
503 return binary_op(v, w, NB_SLOT(op), op_name); \
504 }
Guido van Rossume15dee51995-07-18 14:12:02 +0000505
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000506BINARY_FUNC(PyNumber_Or, nb_or, "|")
507BINARY_FUNC(PyNumber_Xor, nb_xor, "^")
508BINARY_FUNC(PyNumber_And, nb_and, "&")
509BINARY_FUNC(PyNumber_Lshift, nb_lshift, "<<")
510BINARY_FUNC(PyNumber_Rshift, nb_rshift, ">>")
511BINARY_FUNC(PyNumber_Subtract, nb_subtract, "-")
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000512BINARY_FUNC(PyNumber_Divmod, nb_divmod, "divmod()")
Guido van Rossume15dee51995-07-18 14:12:02 +0000513
514PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000515PyNumber_Add(PyObject *v, PyObject *w)
Guido van Rossume15dee51995-07-18 14:12:02 +0000516{
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000517 PyObject *result = binary_op1(v, w, NB_SLOT(nb_add));
518 if (result == Py_NotImplemented) {
519 PySequenceMethods *m = v->ob_type->tp_as_sequence;
Armin Rigofd163f92005-12-29 15:59:19 +0000520 Py_DECREF(result);
Jeremy Hylton0522d982002-03-08 21:28:54 +0000521 if (m && m->sq_concat) {
Armin Rigofd163f92005-12-29 15:59:19 +0000522 return (*m->sq_concat)(v, w);
Jeremy Hylton0522d982002-03-08 21:28:54 +0000523 }
Armin Rigofd163f92005-12-29 15:59:19 +0000524 result = binop_type_error(v, w, "+");
Guido van Rossume15dee51995-07-18 14:12:02 +0000525 }
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000526 return result;
Guido van Rossume15dee51995-07-18 14:12:02 +0000527}
528
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000529static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000530sequence_repeat(ssizeargfunc repeatfunc, PyObject *seq, PyObject *n)
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000531{
Guido van Rossum38fff8c2006-03-07 18:50:55 +0000532 Py_ssize_t count;
533 PyNumberMethods *nb = n->ob_type->tp_as_number;
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000534 if (nb != NULL && nb->nb_index != NULL) {
Guido van Rossum38fff8c2006-03-07 18:50:55 +0000535 count = nb->nb_index(n);
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000536 if (count == -1 && PyErr_Occurred())
537 return NULL;
538 }
539 else {
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000540 return type_error("can't multiply sequence by "
541 "non-int of type '%.200s'", n);
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000542 }
Guido van Rossum38fff8c2006-03-07 18:50:55 +0000543 return (*repeatfunc)(seq, count);
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000544}
545
546PyObject *
547PyNumber_Multiply(PyObject *v, PyObject *w)
548{
549 PyObject *result = binary_op1(v, w, NB_SLOT(nb_multiply));
550 if (result == Py_NotImplemented) {
551 PySequenceMethods *mv = v->ob_type->tp_as_sequence;
552 PySequenceMethods *mw = w->ob_type->tp_as_sequence;
Guido van Rossuma3a243e2002-12-31 19:50:03 +0000553 Py_DECREF(result);
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000554 if (mv && mv->sq_repeat) {
555 return sequence_repeat(mv->sq_repeat, v, w);
556 }
557 else if (mw && mw->sq_repeat) {
558 return sequence_repeat(mw->sq_repeat, w, v);
559 }
560 result = binop_type_error(v, w, "*");
561 }
562 return result;
563}
564
Guido van Rossume15dee51995-07-18 14:12:02 +0000565PyObject *
Guido van Rossum4668b002001-08-08 05:00:18 +0000566PyNumber_FloorDivide(PyObject *v, PyObject *w)
567{
568 /* XXX tp_flags test */
569 return binary_op(v, w, NB_SLOT(nb_floor_divide), "//");
570}
571
572PyObject *
573PyNumber_TrueDivide(PyObject *v, PyObject *w)
574{
575 /* XXX tp_flags test */
576 return binary_op(v, w, NB_SLOT(nb_true_divide), "/");
577}
578
579PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000580PyNumber_Remainder(PyObject *v, PyObject *w)
Guido van Rossume15dee51995-07-18 14:12:02 +0000581{
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000582 return binary_op(v, w, NB_SLOT(nb_remainder), "%");
Guido van Rossume15dee51995-07-18 14:12:02 +0000583}
584
585PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000586PyNumber_Power(PyObject *v, PyObject *w, PyObject *z)
Guido van Rossume15dee51995-07-18 14:12:02 +0000587{
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000588 return ternary_op(v, w, z, NB_SLOT(nb_power), "** or pow()");
Guido van Rossume15dee51995-07-18 14:12:02 +0000589}
590
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000591/* Binary in-place operators */
592
593/* The in-place operators are defined to fall back to the 'normal',
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000594 non in-place operations, if the in-place methods are not in place.
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000595
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000596 - If the left hand object has the appropriate struct members, and
597 they are filled, call the appropriate function and return the
598 result. No coercion is done on the arguments; the left-hand object
599 is the one the operation is performed on, and it's up to the
600 function to deal with the right-hand object.
Guido van Rossum77660912002-04-16 16:32:50 +0000601
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000602 - Otherwise, in-place modification is not supported. Handle it exactly as
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000603 a non in-place operation of the same kind.
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000604
605 */
606
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000607static PyObject *
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000608binary_iop1(PyObject *v, PyObject *w, const int iop_slot, const int op_slot)
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000609{
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000610 PyNumberMethods *mv = v->ob_type->tp_as_number;
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000611 if (mv != NULL) {
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000612 binaryfunc slot = NB_BINOP(mv, iop_slot);
613 if (slot) {
614 PyObject *x = (slot)(v, w);
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000615 if (x != Py_NotImplemented) {
616 return x;
617 }
618 Py_DECREF(x);
619 }
Thomas Woutersf2b332d2000-09-02 08:34:40 +0000620 }
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000621 return binary_op1(v, w, op_slot);
622}
623
624static PyObject *
625binary_iop(PyObject *v, PyObject *w, const int iop_slot, const int op_slot,
626 const char *op_name)
627{
628 PyObject *result = binary_iop1(v, w, iop_slot, op_slot);
629 if (result == Py_NotImplemented) {
630 Py_DECREF(result);
631 return binop_type_error(v, w, op_name);
632 }
633 return result;
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000634}
635
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000636#define INPLACE_BINOP(func, iop, op, op_name) \
637 PyObject * \
638 func(PyObject *v, PyObject *w) { \
639 return binary_iop(v, w, NB_SLOT(iop), NB_SLOT(op), op_name); \
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000640 }
641
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000642INPLACE_BINOP(PyNumber_InPlaceOr, nb_inplace_or, nb_or, "|=")
643INPLACE_BINOP(PyNumber_InPlaceXor, nb_inplace_xor, nb_xor, "^=")
644INPLACE_BINOP(PyNumber_InPlaceAnd, nb_inplace_and, nb_and, "&=")
645INPLACE_BINOP(PyNumber_InPlaceLshift, nb_inplace_lshift, nb_lshift, "<<=")
646INPLACE_BINOP(PyNumber_InPlaceRshift, nb_inplace_rshift, nb_rshift, ">>=")
647INPLACE_BINOP(PyNumber_InPlaceSubtract, nb_inplace_subtract, nb_subtract, "-=")
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000648
649PyObject *
Guido van Rossum4668b002001-08-08 05:00:18 +0000650PyNumber_InPlaceFloorDivide(PyObject *v, PyObject *w)
651{
652 /* XXX tp_flags test */
653 return binary_iop(v, w, NB_SLOT(nb_inplace_floor_divide),
654 NB_SLOT(nb_floor_divide), "//=");
655}
656
657PyObject *
658PyNumber_InPlaceTrueDivide(PyObject *v, PyObject *w)
659{
660 /* XXX tp_flags test */
661 return binary_iop(v, w, NB_SLOT(nb_inplace_true_divide),
662 NB_SLOT(nb_true_divide), "/=");
663}
664
665PyObject *
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000666PyNumber_InPlaceAdd(PyObject *v, PyObject *w)
667{
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000668 PyObject *result = binary_iop1(v, w, NB_SLOT(nb_inplace_add),
669 NB_SLOT(nb_add));
670 if (result == Py_NotImplemented) {
671 PySequenceMethods *m = v->ob_type->tp_as_sequence;
672 Py_DECREF(result);
673 if (m != NULL) {
674 binaryfunc f = NULL;
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000675 f = m->sq_inplace_concat;
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000676 if (f == NULL)
677 f = m->sq_concat;
678 if (f != NULL)
679 return (*f)(v, w);
680 }
681 result = binop_type_error(v, w, "+=");
Guido van Rossumbb8be932000-09-01 23:27:32 +0000682 }
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000683 return result;
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000684}
685
686PyObject *
687PyNumber_InPlaceMultiply(PyObject *v, PyObject *w)
688{
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000689 PyObject *result = binary_iop1(v, w, NB_SLOT(nb_inplace_multiply),
690 NB_SLOT(nb_multiply));
691 if (result == Py_NotImplemented) {
Martin v. Löwis18e16552006-02-15 17:27:45 +0000692 ssizeargfunc f = NULL;
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000693 PySequenceMethods *mv = v->ob_type->tp_as_sequence;
694 PySequenceMethods *mw = w->ob_type->tp_as_sequence;
695 Py_DECREF(result);
696 if (mv != NULL) {
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000697 f = mv->sq_inplace_repeat;
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000698 if (f == NULL)
699 f = mv->sq_repeat;
700 if (f != NULL)
701 return sequence_repeat(f, v, w);
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000702 }
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000703 else if (mw != NULL) {
704 /* Note that the right hand operand should not be
705 * mutated in this case so sq_inplace_repeat is not
706 * used. */
707 if (mw->sq_repeat)
708 return sequence_repeat(mw->sq_repeat, w, v);
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000709 }
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000710 result = binop_type_error(v, w, "*=");
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000711 }
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000712 return result;
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000713}
714
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000715PyObject *
716PyNumber_InPlaceRemainder(PyObject *v, PyObject *w)
717{
Neil Schemenauerd46fbc32002-11-24 01:07:42 +0000718 return binary_iop(v, w, NB_SLOT(nb_inplace_remainder),
719 NB_SLOT(nb_remainder), "%=");
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000720}
721
722PyObject *
723PyNumber_InPlacePower(PyObject *v, PyObject *w, PyObject *z)
724{
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000725 if (v->ob_type->tp_as_number &&
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000726 v->ob_type->tp_as_number->nb_inplace_power != NULL) {
727 return ternary_op(v, w, z, NB_SLOT(nb_inplace_power), "**=");
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000728 }
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000729 else {
730 return ternary_op(v, w, z, NB_SLOT(nb_power), "**=");
731 }
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000732}
733
734
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000735/* Unary operators and functions */
Guido van Rossume15dee51995-07-18 14:12:02 +0000736
737PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000738PyNumber_Negative(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +0000739{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000740 PyNumberMethods *m;
741
742 if (o == NULL)
743 return null_error();
744 m = o->ob_type->tp_as_number;
745 if (m && m->nb_negative)
746 return (*m->nb_negative)(o);
747
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000748 return type_error("bad operand type for unary -: '%.200s'", o);
Guido van Rossume15dee51995-07-18 14:12:02 +0000749}
750
751PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000752PyNumber_Positive(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +0000753{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000754 PyNumberMethods *m;
755
756 if (o == NULL)
757 return null_error();
758 m = o->ob_type->tp_as_number;
759 if (m && m->nb_positive)
760 return (*m->nb_positive)(o);
761
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000762 return type_error("bad operand type for unary +: '%.200s'", o);
Guido van Rossume15dee51995-07-18 14:12:02 +0000763}
764
765PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000766PyNumber_Invert(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +0000767{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000768 PyNumberMethods *m;
769
770 if (o == NULL)
771 return null_error();
772 m = o->ob_type->tp_as_number;
773 if (m && m->nb_invert)
774 return (*m->nb_invert)(o);
775
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000776 return type_error("bad operand type for unary ~: '%.200s'", o);
Guido van Rossume15dee51995-07-18 14:12:02 +0000777}
778
779PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000780PyNumber_Absolute(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +0000781{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000782 PyNumberMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +0000783
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000784 if (o == NULL)
785 return null_error();
786 m = o->ob_type->tp_as_number;
787 if (m && m->nb_absolute)
788 return m->nb_absolute(o);
Guido van Rossume15dee51995-07-18 14:12:02 +0000789
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000790 return type_error("bad operand type for abs(): '%.200s'", o);
Guido van Rossume15dee51995-07-18 14:12:02 +0000791}
792
Guido van Rossum9e896b32000-04-05 20:11:21 +0000793/* Add a check for embedded NULL-bytes in the argument. */
794static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000795int_from_string(const char *s, Py_ssize_t len)
Guido van Rossum9e896b32000-04-05 20:11:21 +0000796{
797 char *end;
798 PyObject *x;
799
800 x = PyInt_FromString((char*)s, &end, 10);
801 if (x == NULL)
802 return NULL;
803 if (end != s + len) {
804 PyErr_SetString(PyExc_ValueError,
805 "null byte in argument for int()");
806 Py_DECREF(x);
807 return NULL;
808 }
809 return x;
810}
811
Guido van Rossum38fff8c2006-03-07 18:50:55 +0000812/* Return a Py_ssize_t integer from the object item */
813Py_ssize_t
814PyNumber_Index(PyObject *item)
815{
816 Py_ssize_t value = -1;
817 PyNumberMethods *nb = item->ob_type->tp_as_number;
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000818 if (nb != NULL && nb->nb_index != NULL) {
Guido van Rossum38fff8c2006-03-07 18:50:55 +0000819 value = nb->nb_index(item);
820 }
821 else {
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000822 PyErr_Format(PyExc_TypeError,
823 "'%.200s' object cannot be interpreted "
824 "as an index", item->ob_type->tp_name);
Guido van Rossum38fff8c2006-03-07 18:50:55 +0000825 }
826 return value;
827}
828
Guido van Rossume15dee51995-07-18 14:12:02 +0000829PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000830PyNumber_Int(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +0000831{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000832 PyNumberMethods *m;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000833 const char *buffer;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000834 Py_ssize_t buffer_len;
Guido van Rossume15dee51995-07-18 14:12:02 +0000835
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000836 if (o == NULL)
837 return null_error();
Tim Peters64b5ce32001-09-10 20:52:51 +0000838 if (PyInt_CheckExact(o)) {
Guido van Rossum9e896b32000-04-05 20:11:21 +0000839 Py_INCREF(o);
840 return o;
841 }
Brett Cannonc3647ac2005-04-26 03:45:26 +0000842 m = o->ob_type->tp_as_number;
843 if (m && m->nb_int) { /* This should include subclasses of int */
844 PyObject *res = m->nb_int(o);
845 if (res && (!PyInt_Check(res) && !PyLong_Check(res))) {
846 PyErr_Format(PyExc_TypeError,
847 "__int__ returned non-int (type %.200s)",
848 res->ob_type->tp_name);
849 Py_DECREF(res);
850 return NULL;
851 }
852 return res;
853 }
854 if (PyInt_Check(o)) { /* A int subclass without nb_int */
Tim Peters64b5ce32001-09-10 20:52:51 +0000855 PyIntObject *io = (PyIntObject*)o;
856 return PyInt_FromLong(io->ob_ival);
857 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000858 if (PyString_Check(o))
Guido van Rossum77660912002-04-16 16:32:50 +0000859 return int_from_string(PyString_AS_STRING(o),
Guido van Rossum9e896b32000-04-05 20:11:21 +0000860 PyString_GET_SIZE(o));
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000861#ifdef Py_USING_UNICODE
Guido van Rossum9e896b32000-04-05 20:11:21 +0000862 if (PyUnicode_Check(o))
863 return PyInt_FromUnicode(PyUnicode_AS_UNICODE(o),
864 PyUnicode_GET_SIZE(o),
865 10);
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000866#endif
Guido van Rossum4c08d552000-03-10 22:55:18 +0000867 if (!PyObject_AsCharBuffer(o, &buffer, &buffer_len))
Guido van Rossum9e896b32000-04-05 20:11:21 +0000868 return int_from_string((char*)buffer, buffer_len);
Guido van Rossume15dee51995-07-18 14:12:02 +0000869
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000870 return type_error("int() argument must be a string or a "
871 "number, not '%.200s'", o);
Guido van Rossume15dee51995-07-18 14:12:02 +0000872}
873
Guido van Rossum9e896b32000-04-05 20:11:21 +0000874/* Add a check for embedded NULL-bytes in the argument. */
Barry Warsaw226ae6c1999-10-12 19:54:53 +0000875static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000876long_from_string(const char *s, Py_ssize_t len)
Barry Warsaw226ae6c1999-10-12 19:54:53 +0000877{
Guido van Rossum4c08d552000-03-10 22:55:18 +0000878 char *end;
Barry Warsaw226ae6c1999-10-12 19:54:53 +0000879 PyObject *x;
Barry Warsaw226ae6c1999-10-12 19:54:53 +0000880
Guido van Rossum4c08d552000-03-10 22:55:18 +0000881 x = PyLong_FromString((char*)s, &end, 10);
Guido van Rossum9e896b32000-04-05 20:11:21 +0000882 if (x == NULL)
Barry Warsaw226ae6c1999-10-12 19:54:53 +0000883 return NULL;
Guido van Rossum9e896b32000-04-05 20:11:21 +0000884 if (end != s + len) {
Barry Warsaw226ae6c1999-10-12 19:54:53 +0000885 PyErr_SetString(PyExc_ValueError,
886 "null byte in argument for long()");
Guido van Rossum9e896b32000-04-05 20:11:21 +0000887 Py_DECREF(x);
Barry Warsaw226ae6c1999-10-12 19:54:53 +0000888 return NULL;
889 }
890 return x;
891}
892
Guido van Rossume15dee51995-07-18 14:12:02 +0000893PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000894PyNumber_Long(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +0000895{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000896 PyNumberMethods *m;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000897 const char *buffer;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000898 Py_ssize_t buffer_len;
Guido van Rossume15dee51995-07-18 14:12:02 +0000899
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000900 if (o == NULL)
901 return null_error();
Brett Cannonc3647ac2005-04-26 03:45:26 +0000902 m = o->ob_type->tp_as_number;
903 if (m && m->nb_long) { /* This should include subclasses of long */
904 PyObject *res = m->nb_long(o);
905 if (res && (!PyInt_Check(res) && !PyLong_Check(res))) {
906 PyErr_Format(PyExc_TypeError,
907 "__long__ returned non-long (type %.200s)",
908 res->ob_type->tp_name);
909 Py_DECREF(res);
910 return NULL;
911 }
912 return res;
Guido van Rossum9e896b32000-04-05 20:11:21 +0000913 }
Brett Cannonc3647ac2005-04-26 03:45:26 +0000914 if (PyLong_Check(o)) /* A long subclass without nb_long */
Tim Petersdb30ac42002-03-02 04:14:21 +0000915 return _PyLong_Copy((PyLongObject *)o);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000916 if (PyString_Check(o))
Guido van Rossum77660912002-04-16 16:32:50 +0000917 /* need to do extra error checking that PyLong_FromString()
Barry Warsaw226ae6c1999-10-12 19:54:53 +0000918 * doesn't do. In particular long('9.5') must raise an
919 * exception, not truncate the float.
920 */
Guido van Rossum4c08d552000-03-10 22:55:18 +0000921 return long_from_string(PyString_AS_STRING(o),
922 PyString_GET_SIZE(o));
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000923#ifdef Py_USING_UNICODE
Guido van Rossum9e896b32000-04-05 20:11:21 +0000924 if (PyUnicode_Check(o))
925 /* The above check is done in PyLong_FromUnicode(). */
926 return PyLong_FromUnicode(PyUnicode_AS_UNICODE(o),
927 PyUnicode_GET_SIZE(o),
928 10);
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000929#endif
Guido van Rossum4c08d552000-03-10 22:55:18 +0000930 if (!PyObject_AsCharBuffer(o, &buffer, &buffer_len))
931 return long_from_string(buffer, buffer_len);
Guido van Rossume15dee51995-07-18 14:12:02 +0000932
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000933 return type_error("long() argument must be a string or a "
934 "number, not '%.200s'", o);
Guido van Rossume15dee51995-07-18 14:12:02 +0000935}
936
937PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000938PyNumber_Float(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +0000939{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000940 PyNumberMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +0000941
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000942 if (o == NULL)
943 return null_error();
Brett Cannonc3647ac2005-04-26 03:45:26 +0000944 m = o->ob_type->tp_as_number;
945 if (m && m->nb_float) { /* This should include subclasses of float */
946 PyObject *res = m->nb_float(o);
947 if (res && !PyFloat_Check(res)) {
948 PyErr_Format(PyExc_TypeError,
949 "__float__ returned non-float (type %.200s)",
950 res->ob_type->tp_name);
951 Py_DECREF(res);
952 return NULL;
953 }
954 return res;
Guido van Rossum9e896b32000-04-05 20:11:21 +0000955 }
Brett Cannonc3647ac2005-04-26 03:45:26 +0000956 if (PyFloat_Check(o)) { /* A float subclass with nb_float == NULL */
Tim Peters7a50f252001-09-10 21:28:20 +0000957 PyFloatObject *po = (PyFloatObject *)o;
958 return PyFloat_FromDouble(po->ob_fval);
959 }
Guido van Rossum4c08d552000-03-10 22:55:18 +0000960 return PyFloat_FromString(o, NULL);
Guido van Rossume15dee51995-07-18 14:12:02 +0000961}
962
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000963/* Operations on sequences */
Guido van Rossume15dee51995-07-18 14:12:02 +0000964
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000965int
Fred Drake79912472000-07-09 04:06:11 +0000966PySequence_Check(PyObject *s)
Guido van Rossume15dee51995-07-18 14:12:02 +0000967{
Guido van Rossum8700b422001-09-07 20:20:11 +0000968 return s != NULL && s->ob_type->tp_as_sequence &&
969 s->ob_type->tp_as_sequence->sq_item != NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +0000970}
971
Martin v. Löwis18e16552006-02-15 17:27:45 +0000972Py_ssize_t
Jeremy Hylton6253f832000-07-12 12:56:19 +0000973PySequence_Size(PyObject *s)
Guido van Rossume15dee51995-07-18 14:12:02 +0000974{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000975 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +0000976
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000977 if (s == NULL) {
978 null_error();
979 return -1;
980 }
Guido van Rossume15dee51995-07-18 14:12:02 +0000981
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000982 m = s->ob_type->tp_as_sequence;
983 if (m && m->sq_length)
984 return m->sq_length(s);
Guido van Rossume15dee51995-07-18 14:12:02 +0000985
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000986 type_error("object of type '%.200s' has no len()", s);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000987 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +0000988}
989
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +0000990#undef PySequence_Length
Martin v. Löwis18e16552006-02-15 17:27:45 +0000991Py_ssize_t
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +0000992PySequence_Length(PyObject *s)
993{
994 return PySequence_Size(s);
995}
996#define PySequence_Length PySequence_Size
997
Guido van Rossume15dee51995-07-18 14:12:02 +0000998PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000999PySequence_Concat(PyObject *s, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001000{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001001 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001002
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001003 if (s == NULL || o == NULL)
1004 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001005
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001006 m = s->ob_type->tp_as_sequence;
1007 if (m && m->sq_concat)
1008 return m->sq_concat(s, o);
1009
Armin Rigofd163f92005-12-29 15:59:19 +00001010 /* Instances of user classes defining an __add__() method only
1011 have an nb_add slot, not an sq_concat slot. So we fall back
1012 to nb_add if both arguments appear to be sequences. */
1013 if (PySequence_Check(s) && PySequence_Check(o)) {
1014 PyObject *result = binary_op1(s, o, NB_SLOT(nb_add));
1015 if (result != Py_NotImplemented)
1016 return result;
1017 Py_DECREF(result);
1018 }
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001019 return type_error("'%.200s' object can't be concatenated", s);
Guido van Rossume15dee51995-07-18 14:12:02 +00001020}
1021
1022PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +00001023PySequence_Repeat(PyObject *o, Py_ssize_t count)
Guido van Rossume15dee51995-07-18 14:12:02 +00001024{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001025 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001026
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001027 if (o == NULL)
1028 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001029
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001030 m = o->ob_type->tp_as_sequence;
1031 if (m && m->sq_repeat)
1032 return m->sq_repeat(o, count);
1033
Armin Rigofd163f92005-12-29 15:59:19 +00001034 /* Instances of user classes defining a __mul__() method only
1035 have an nb_multiply slot, not an sq_repeat slot. so we fall back
1036 to nb_multiply if o appears to be a sequence. */
1037 if (PySequence_Check(o)) {
1038 PyObject *n, *result;
Martin v. Löwiseb079f12006-02-16 14:32:27 +00001039 n = PyInt_FromSsize_t(count);
Armin Rigofd163f92005-12-29 15:59:19 +00001040 if (n == NULL)
1041 return NULL;
1042 result = binary_op1(o, n, NB_SLOT(nb_multiply));
1043 Py_DECREF(n);
1044 if (result != Py_NotImplemented)
1045 return result;
1046 Py_DECREF(result);
1047 }
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001048 return type_error("'%.200s' object can't be repeated", o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001049}
1050
1051PyObject *
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001052PySequence_InPlaceConcat(PyObject *s, PyObject *o)
1053{
1054 PySequenceMethods *m;
1055
1056 if (s == NULL || o == NULL)
1057 return null_error();
1058
1059 m = s->ob_type->tp_as_sequence;
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +00001060 if (m && m->sq_inplace_concat)
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001061 return m->sq_inplace_concat(s, o);
1062 if (m && m->sq_concat)
1063 return m->sq_concat(s, o);
1064
Armin Rigofd163f92005-12-29 15:59:19 +00001065 if (PySequence_Check(s) && PySequence_Check(o)) {
1066 PyObject *result = binary_iop1(s, o, NB_SLOT(nb_inplace_add),
1067 NB_SLOT(nb_add));
1068 if (result != Py_NotImplemented)
1069 return result;
1070 Py_DECREF(result);
1071 }
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001072 return type_error("'%.200s' object can't be concatenated", s);
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001073}
1074
1075PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +00001076PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count)
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001077{
1078 PySequenceMethods *m;
1079
1080 if (o == NULL)
1081 return null_error();
1082
1083 m = o->ob_type->tp_as_sequence;
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +00001084 if (m && m->sq_inplace_repeat)
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001085 return m->sq_inplace_repeat(o, count);
1086 if (m && m->sq_repeat)
1087 return m->sq_repeat(o, count);
1088
Armin Rigofd163f92005-12-29 15:59:19 +00001089 if (PySequence_Check(o)) {
1090 PyObject *n, *result;
Martin v. Löwiseb079f12006-02-16 14:32:27 +00001091 n = PyInt_FromSsize_t(count);
Armin Rigofd163f92005-12-29 15:59:19 +00001092 if (n == NULL)
1093 return NULL;
1094 result = binary_iop1(o, n, NB_SLOT(nb_inplace_multiply),
1095 NB_SLOT(nb_multiply));
1096 Py_DECREF(n);
1097 if (result != Py_NotImplemented)
1098 return result;
1099 Py_DECREF(result);
1100 }
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001101 return type_error("'%.200s' object can't be repeated", o);
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001102}
1103
1104PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +00001105PySequence_GetItem(PyObject *s, Py_ssize_t i)
Guido van Rossume15dee51995-07-18 14:12:02 +00001106{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001107 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001108
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001109 if (s == NULL)
1110 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001111
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001112 m = s->ob_type->tp_as_sequence;
1113 if (m && m->sq_item) {
1114 if (i < 0) {
1115 if (m->sq_length) {
Martin v. Löwis18e16552006-02-15 17:27:45 +00001116 Py_ssize_t l = (*m->sq_length)(s);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001117 if (l < 0)
1118 return NULL;
1119 i += l;
1120 }
1121 }
1122 return m->sq_item(s, i);
1123 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001124
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001125 return type_error("'%.200s' object is unindexable", s);
Guido van Rossume15dee51995-07-18 14:12:02 +00001126}
1127
1128PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +00001129PySequence_GetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2)
Guido van Rossume15dee51995-07-18 14:12:02 +00001130{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001131 PySequenceMethods *m;
Thomas Wouters1d75a792000-08-17 22:37:32 +00001132 PyMappingMethods *mp;
Guido van Rossume15dee51995-07-18 14:12:02 +00001133
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001134 if (!s) return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001135
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001136 m = s->ob_type->tp_as_sequence;
1137 if (m && m->sq_slice) {
1138 if (i1 < 0 || i2 < 0) {
1139 if (m->sq_length) {
Martin v. Löwis18e16552006-02-15 17:27:45 +00001140 Py_ssize_t l = (*m->sq_length)(s);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001141 if (l < 0)
1142 return NULL;
1143 if (i1 < 0)
1144 i1 += l;
1145 if (i2 < 0)
1146 i2 += l;
1147 }
1148 }
1149 return m->sq_slice(s, i1, i2);
Thomas Wouters1d75a792000-08-17 22:37:32 +00001150 } else if ((mp = s->ob_type->tp_as_mapping) && mp->mp_subscript) {
1151 PyObject *res;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001152 PyObject *slice = _PySlice_FromIndices(i1, i2);
Thomas Wouters1d75a792000-08-17 22:37:32 +00001153 if (!slice)
1154 return NULL;
1155 res = mp->mp_subscript(s, slice);
1156 Py_DECREF(slice);
1157 return res;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001158 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001159
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001160 return type_error("'%.200s' object is unsliceable", s);
Guido van Rossume15dee51995-07-18 14:12:02 +00001161}
1162
1163int
Martin v. Löwis18e16552006-02-15 17:27:45 +00001164PySequence_SetItem(PyObject *s, Py_ssize_t i, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001165{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001166 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001167
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001168 if (s == NULL) {
1169 null_error();
1170 return -1;
1171 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001172
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001173 m = s->ob_type->tp_as_sequence;
1174 if (m && m->sq_ass_item) {
1175 if (i < 0) {
1176 if (m->sq_length) {
Martin v. Löwis18e16552006-02-15 17:27:45 +00001177 Py_ssize_t l = (*m->sq_length)(s);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001178 if (l < 0)
Guido van Rossumed6219b1998-05-29 02:59:33 +00001179 return -1;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001180 i += l;
1181 }
1182 }
1183 return m->sq_ass_item(s, i, o);
1184 }
1185
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001186 type_error("'%.200s' object does not support item assignment", s);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001187 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +00001188}
1189
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001190int
Martin v. Löwis18e16552006-02-15 17:27:45 +00001191PySequence_DelItem(PyObject *s, Py_ssize_t i)
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001192{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001193 PySequenceMethods *m;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001194
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001195 if (s == NULL) {
1196 null_error();
1197 return -1;
1198 }
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001199
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001200 m = s->ob_type->tp_as_sequence;
1201 if (m && m->sq_ass_item) {
1202 if (i < 0) {
1203 if (m->sq_length) {
Martin v. Löwis18e16552006-02-15 17:27:45 +00001204 Py_ssize_t l = (*m->sq_length)(s);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001205 if (l < 0)
Guido van Rossumed6219b1998-05-29 02:59:33 +00001206 return -1;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001207 i += l;
1208 }
1209 }
1210 return m->sq_ass_item(s, i, (PyObject *)NULL);
1211 }
1212
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001213 type_error("'%.200s' object doesn't support item deletion", s);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001214 return -1;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001215}
1216
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001217int
Martin v. Löwis18e16552006-02-15 17:27:45 +00001218PySequence_SetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001219{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001220 PySequenceMethods *m;
Thomas Wouters1d75a792000-08-17 22:37:32 +00001221 PyMappingMethods *mp;
Guido van Rossume15dee51995-07-18 14:12:02 +00001222
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001223 if (s == NULL) {
1224 null_error();
1225 return -1;
1226 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001227
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001228 m = s->ob_type->tp_as_sequence;
1229 if (m && m->sq_ass_slice) {
1230 if (i1 < 0 || i2 < 0) {
1231 if (m->sq_length) {
Martin v. Löwis18e16552006-02-15 17:27:45 +00001232 Py_ssize_t l = (*m->sq_length)(s);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001233 if (l < 0)
Guido van Rossumed6219b1998-05-29 02:59:33 +00001234 return -1;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001235 if (i1 < 0)
1236 i1 += l;
1237 if (i2 < 0)
1238 i2 += l;
1239 }
1240 }
1241 return m->sq_ass_slice(s, i1, i2, o);
Thomas Wouters1d75a792000-08-17 22:37:32 +00001242 } else if ((mp = s->ob_type->tp_as_mapping) && mp->mp_ass_subscript) {
1243 int res;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001244 PyObject *slice = _PySlice_FromIndices(i1, i2);
Thomas Wouters1d75a792000-08-17 22:37:32 +00001245 if (!slice)
1246 return -1;
1247 res = mp->mp_ass_subscript(s, slice, o);
1248 Py_DECREF(slice);
1249 return res;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001250 }
Thomas Wouters1d75a792000-08-17 22:37:32 +00001251
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001252 type_error("'%.200s' object doesn't support slice assignment", s);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001253 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +00001254}
1255
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001256int
Martin v. Löwis18e16552006-02-15 17:27:45 +00001257PySequence_DelSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2)
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001258{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001259 PySequenceMethods *m;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001260
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001261 if (s == NULL) {
1262 null_error();
1263 return -1;
1264 }
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001265
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001266 m = s->ob_type->tp_as_sequence;
1267 if (m && m->sq_ass_slice) {
1268 if (i1 < 0 || i2 < 0) {
1269 if (m->sq_length) {
Martin v. Löwis18e16552006-02-15 17:27:45 +00001270 Py_ssize_t l = (*m->sq_length)(s);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001271 if (l < 0)
Guido van Rossumed6219b1998-05-29 02:59:33 +00001272 return -1;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001273 if (i1 < 0)
1274 i1 += l;
1275 if (i2 < 0)
1276 i2 += l;
1277 }
1278 }
1279 return m->sq_ass_slice(s, i1, i2, (PyObject *)NULL);
1280 }
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001281 type_error("'%.200s' object doesn't support slice deletion", s);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001282 return -1;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001283}
1284
Guido van Rossume15dee51995-07-18 14:12:02 +00001285PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001286PySequence_Tuple(PyObject *v)
Guido van Rossume15dee51995-07-18 14:12:02 +00001287{
Tim Peters6912d4d2001-05-05 03:56:37 +00001288 PyObject *it; /* iter(v) */
Martin v. Löwis18e16552006-02-15 17:27:45 +00001289 Py_ssize_t n; /* guess for result tuple size */
Tim Peters6912d4d2001-05-05 03:56:37 +00001290 PyObject *result;
Martin v. Löwis18e16552006-02-15 17:27:45 +00001291 Py_ssize_t j;
Guido van Rossume15dee51995-07-18 14:12:02 +00001292
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001293 if (v == NULL)
1294 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001295
Tim Peters6912d4d2001-05-05 03:56:37 +00001296 /* Special-case the common tuple and list cases, for efficiency. */
Tim Peters4c3a0a32001-09-10 23:37:46 +00001297 if (PyTuple_CheckExact(v)) {
1298 /* Note that we can't know whether it's safe to return
1299 a tuple *subclass* instance as-is, hence the restriction
Tim Peters8ff70a92001-09-10 23:53:53 +00001300 to exact tuples here. In contrast, lists always make
1301 a copy, so there's no need for exactness below. */
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001302 Py_INCREF(v);
1303 return v;
Guido van Rossume15dee51995-07-18 14:12:02 +00001304 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001305 if (PyList_Check(v))
1306 return PyList_AsTuple(v);
1307
Tim Peters6912d4d2001-05-05 03:56:37 +00001308 /* Get iterator. */
1309 it = PyObject_GetIter(v);
1310 if (it == NULL)
Tim Peters1fc240e2001-10-26 05:06:50 +00001311 return NULL;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001312
Tim Peters6912d4d2001-05-05 03:56:37 +00001313 /* Guess result size and allocate space. */
Armin Rigof5b3e362006-02-11 21:32:43 +00001314 n = _PyObject_LengthHint(v);
Tim Peters6912d4d2001-05-05 03:56:37 +00001315 if (n < 0) {
Raymond Hettingera710b332005-08-21 11:03:59 +00001316 if (!PyErr_ExceptionMatches(PyExc_TypeError) &&
1317 !PyErr_ExceptionMatches(PyExc_AttributeError)) {
1318 Py_DECREF(it);
1319 return NULL;
1320 }
Tim Peters6912d4d2001-05-05 03:56:37 +00001321 PyErr_Clear();
1322 n = 10; /* arbitrary */
1323 }
1324 result = PyTuple_New(n);
1325 if (result == NULL)
1326 goto Fail;
1327
1328 /* Fill the tuple. */
1329 for (j = 0; ; ++j) {
1330 PyObject *item = PyIter_Next(it);
1331 if (item == NULL) {
1332 if (PyErr_Occurred())
1333 goto Fail;
1334 break;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001335 }
Tim Peters6912d4d2001-05-05 03:56:37 +00001336 if (j >= n) {
Martin v. Löwis18e16552006-02-15 17:27:45 +00001337 Py_ssize_t oldn = n;
Raymond Hettinger4d012592004-12-16 10:38:38 +00001338 /* The over-allocation strategy can grow a bit faster
1339 than for lists because unlike lists the
1340 over-allocation isn't permanent -- we reclaim
1341 the excess before the end of this routine.
1342 So, grow by ten and then add 25%.
1343 */
1344 n += 10;
1345 n += n >> 2;
1346 if (n < oldn) {
1347 /* Check for overflow */
1348 PyErr_NoMemory();
Raymond Hettingere6bdb372004-12-16 15:10:21 +00001349 Py_DECREF(item);
Raymond Hettinger4d012592004-12-16 10:38:38 +00001350 goto Fail;
1351 }
Tim Peters4324aa32001-05-28 22:30:08 +00001352 if (_PyTuple_Resize(&result, n) != 0) {
Tim Peters12d0a6c2001-05-05 04:10:25 +00001353 Py_DECREF(item);
Tim Peters6912d4d2001-05-05 03:56:37 +00001354 goto Fail;
Tim Peters12d0a6c2001-05-05 04:10:25 +00001355 }
Tim Peters6912d4d2001-05-05 03:56:37 +00001356 }
1357 PyTuple_SET_ITEM(result, j, item);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001358 }
1359
Tim Peters6912d4d2001-05-05 03:56:37 +00001360 /* Cut tuple back if guess was too large. */
1361 if (j < n &&
Tim Peters4324aa32001-05-28 22:30:08 +00001362 _PyTuple_Resize(&result, j) != 0)
Tim Peters6912d4d2001-05-05 03:56:37 +00001363 goto Fail;
1364
1365 Py_DECREF(it);
1366 return result;
1367
1368Fail:
1369 Py_XDECREF(result);
1370 Py_DECREF(it);
1371 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +00001372}
1373
Guido van Rossum3c5936a1996-12-05 21:51:24 +00001374PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001375PySequence_List(PyObject *v)
Guido van Rossum3c5936a1996-12-05 21:51:24 +00001376{
Tim Petersf553f892001-05-01 20:45:31 +00001377 PyObject *result; /* result list */
Raymond Hettinger8ca92ae2004-03-11 09:13:12 +00001378 PyObject *rv; /* return value from PyList_Extend */
Guido van Rossum4669fb41997-04-02 05:31:09 +00001379
Guido van Rossum5dba9e81998-07-10 18:03:50 +00001380 if (v == NULL)
1381 return null_error();
1382
Raymond Hettinger8ca92ae2004-03-11 09:13:12 +00001383 result = PyList_New(0);
1384 if (result == NULL)
Tim Petersf553f892001-05-01 20:45:31 +00001385 return NULL;
1386
Raymond Hettinger8ca92ae2004-03-11 09:13:12 +00001387 rv = _PyList_Extend((PyListObject *)result, v);
1388 if (rv == NULL) {
1389 Py_DECREF(result);
Tim Petersf553f892001-05-01 20:45:31 +00001390 return NULL;
1391 }
Raymond Hettinger969d8c02004-03-17 05:24:23 +00001392 Py_DECREF(rv);
Tim Petersf553f892001-05-01 20:45:31 +00001393 return result;
Guido van Rossum3c5936a1996-12-05 21:51:24 +00001394}
1395
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001396PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001397PySequence_Fast(PyObject *v, const char *m)
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001398{
Raymond Hettinger2fb70292004-01-11 23:26:51 +00001399 PyObject *it;
1400
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001401 if (v == NULL)
1402 return null_error();
1403
Michael W. Hudson2801fe12002-11-05 18:05:49 +00001404 if (PyList_CheckExact(v) || PyTuple_CheckExact(v)) {
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001405 Py_INCREF(v);
1406 return v;
1407 }
1408
Raymond Hettinger2fb70292004-01-11 23:26:51 +00001409 it = PyObject_GetIter(v);
1410 if (it == NULL) {
1411 if (PyErr_ExceptionMatches(PyExc_TypeError))
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001412 PyErr_SetString(PyExc_TypeError, m);
Raymond Hettinger2fb70292004-01-11 23:26:51 +00001413 return NULL;
1414 }
1415
Raymond Hettinger193814c2004-12-18 19:00:59 +00001416 v = PySequence_List(it);
Raymond Hettinger2fb70292004-01-11 23:26:51 +00001417 Py_DECREF(it);
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001418
1419 return v;
1420}
1421
Tim Peters16a77ad2001-09-08 04:00:12 +00001422/* Iterate over seq. Result depends on the operation:
1423 PY_ITERSEARCH_COUNT: -1 if error, else # of times obj appears in seq.
1424 PY_ITERSEARCH_INDEX: 0-based index of first occurence of obj in seq;
1425 set ValueError and return -1 if none found; also return -1 on error.
1426 Py_ITERSEARCH_CONTAINS: return 1 if obj in seq, else 0; -1 on error.
1427*/
Neal Norwitz1fc4b772006-03-04 18:49:58 +00001428Py_ssize_t
Tim Peters16a77ad2001-09-08 04:00:12 +00001429_PySequence_IterSearch(PyObject *seq, PyObject *obj, int operation)
Guido van Rossume15dee51995-07-18 14:12:02 +00001430{
Neal Norwitz1fc4b772006-03-04 18:49:58 +00001431 Py_ssize_t n;
Tim Peters16a77ad2001-09-08 04:00:12 +00001432 int wrapped; /* for PY_ITERSEARCH_INDEX, true iff n wrapped around */
1433 PyObject *it; /* iter(seq) */
Guido van Rossume15dee51995-07-18 14:12:02 +00001434
Tim Peters16a77ad2001-09-08 04:00:12 +00001435 if (seq == NULL || obj == NULL) {
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001436 null_error();
1437 return -1;
1438 }
Tim Peters75f8e352001-05-05 11:33:43 +00001439
Tim Peters16a77ad2001-09-08 04:00:12 +00001440 it = PyObject_GetIter(seq);
Tim Peters75f8e352001-05-05 11:33:43 +00001441 if (it == NULL) {
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001442 type_error("argument of type '%.200s' is not iterable", seq);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001443 return -1;
Tim Peters75f8e352001-05-05 11:33:43 +00001444 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001445
Tim Peters16a77ad2001-09-08 04:00:12 +00001446 n = wrapped = 0;
Tim Peters75f8e352001-05-05 11:33:43 +00001447 for (;;) {
1448 int cmp;
1449 PyObject *item = PyIter_Next(it);
1450 if (item == NULL) {
1451 if (PyErr_Occurred())
1452 goto Fail;
1453 break;
1454 }
Tim Peters16a77ad2001-09-08 04:00:12 +00001455
1456 cmp = PyObject_RichCompareBool(obj, item, Py_EQ);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001457 Py_DECREF(item);
Tim Peters75f8e352001-05-05 11:33:43 +00001458 if (cmp < 0)
1459 goto Fail;
1460 if (cmp > 0) {
Tim Peters16a77ad2001-09-08 04:00:12 +00001461 switch (operation) {
1462 case PY_ITERSEARCH_COUNT:
1463 ++n;
1464 if (n <= 0) {
Neal Norwitz1fc4b772006-03-04 18:49:58 +00001465 /* XXX(nnorwitz): int means ssize_t */
Tim Peters16a77ad2001-09-08 04:00:12 +00001466 PyErr_SetString(PyExc_OverflowError,
Tim Peters75f8e352001-05-05 11:33:43 +00001467 "count exceeds C int size");
Tim Peters16a77ad2001-09-08 04:00:12 +00001468 goto Fail;
1469 }
1470 break;
1471
1472 case PY_ITERSEARCH_INDEX:
1473 if (wrapped) {
Neal Norwitz1fc4b772006-03-04 18:49:58 +00001474 /* XXX(nnorwitz): int means ssize_t */
Tim Peters16a77ad2001-09-08 04:00:12 +00001475 PyErr_SetString(PyExc_OverflowError,
1476 "index exceeds C int size");
1477 goto Fail;
1478 }
1479 goto Done;
1480
1481 case PY_ITERSEARCH_CONTAINS:
1482 n = 1;
1483 goto Done;
1484
1485 default:
1486 assert(!"unknown operation");
Tim Peters75f8e352001-05-05 11:33:43 +00001487 }
Tim Peters16a77ad2001-09-08 04:00:12 +00001488 }
1489
1490 if (operation == PY_ITERSEARCH_INDEX) {
1491 ++n;
1492 if (n <= 0)
1493 wrapped = 1;
Tim Peters75f8e352001-05-05 11:33:43 +00001494 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001495 }
Tim Peters16a77ad2001-09-08 04:00:12 +00001496
1497 if (operation != PY_ITERSEARCH_INDEX)
1498 goto Done;
1499
1500 PyErr_SetString(PyExc_ValueError,
1501 "sequence.index(x): x not in sequence");
1502 /* fall into failure code */
1503Fail:
1504 n = -1;
1505 /* fall through */
1506Done:
Tim Peters75f8e352001-05-05 11:33:43 +00001507 Py_DECREF(it);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001508 return n;
Tim Peters75f8e352001-05-05 11:33:43 +00001509
Guido van Rossume15dee51995-07-18 14:12:02 +00001510}
1511
Tim Peters16a77ad2001-09-08 04:00:12 +00001512/* Return # of times o appears in s. */
Neal Norwitz1fc4b772006-03-04 18:49:58 +00001513Py_ssize_t
Tim Peters16a77ad2001-09-08 04:00:12 +00001514PySequence_Count(PyObject *s, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001515{
Tim Peters16a77ad2001-09-08 04:00:12 +00001516 return _PySequence_IterSearch(s, o, PY_ITERSEARCH_COUNT);
Guido van Rossume15dee51995-07-18 14:12:02 +00001517}
1518
Tim Peterscb8d3682001-05-05 21:05:01 +00001519/* Return -1 if error; 1 if ob in seq; 0 if ob not in seq.
Tim Peters16a77ad2001-09-08 04:00:12 +00001520 * Use sq_contains if possible, else defer to _PySequence_IterSearch().
Tim Peterscb8d3682001-05-05 21:05:01 +00001521 */
1522int
1523PySequence_Contains(PyObject *seq, PyObject *ob)
1524{
Neal Norwitz1fc4b772006-03-04 18:49:58 +00001525 Py_ssize_t result;
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +00001526 PySequenceMethods *sqm = seq->ob_type->tp_as_sequence;
1527 if (sqm != NULL && sqm->sq_contains != NULL)
1528 return (*sqm->sq_contains)(seq, ob);
Neal Norwitz1fc4b772006-03-04 18:49:58 +00001529 result = _PySequence_IterSearch(seq, ob, PY_ITERSEARCH_CONTAINS);
1530 return Py_SAFE_DOWNCAST(result, Py_ssize_t, int);
Tim Peterscb8d3682001-05-05 21:05:01 +00001531}
1532
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001533/* Backwards compatibility */
1534#undef PySequence_In
1535int
Fred Drake79912472000-07-09 04:06:11 +00001536PySequence_In(PyObject *w, PyObject *v)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001537{
1538 return PySequence_Contains(w, v);
1539}
1540
Neal Norwitz1fc4b772006-03-04 18:49:58 +00001541Py_ssize_t
Fred Drake79912472000-07-09 04:06:11 +00001542PySequence_Index(PyObject *s, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001543{
Tim Peters16a77ad2001-09-08 04:00:12 +00001544 return _PySequence_IterSearch(s, o, PY_ITERSEARCH_INDEX);
Guido van Rossume15dee51995-07-18 14:12:02 +00001545}
1546
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001547/* Operations on mappings */
1548
1549int
Fred Drake79912472000-07-09 04:06:11 +00001550PyMapping_Check(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001551{
Raymond Hettingere2eda602004-04-04 08:51:41 +00001552 return o && o->ob_type->tp_as_mapping &&
1553 o->ob_type->tp_as_mapping->mp_subscript &&
Raymond Hettingered9192e2004-04-05 08:14:48 +00001554 !(o->ob_type->tp_as_sequence &&
1555 o->ob_type->tp_as_sequence->sq_slice);
Guido van Rossume15dee51995-07-18 14:12:02 +00001556}
1557
Martin v. Löwis18e16552006-02-15 17:27:45 +00001558Py_ssize_t
Jeremy Hylton6253f832000-07-12 12:56:19 +00001559PyMapping_Size(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001560{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001561 PyMappingMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001562
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001563 if (o == NULL) {
1564 null_error();
1565 return -1;
1566 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001567
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001568 m = o->ob_type->tp_as_mapping;
1569 if (m && m->mp_length)
1570 return m->mp_length(o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001571
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001572 type_error("object of type '%.200s' has no len()", o);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001573 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +00001574}
1575
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +00001576#undef PyMapping_Length
Martin v. Löwis18e16552006-02-15 17:27:45 +00001577Py_ssize_t
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +00001578PyMapping_Length(PyObject *o)
1579{
1580 return PyMapping_Size(o);
1581}
1582#define PyMapping_Length PyMapping_Size
1583
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001584PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001585PyMapping_GetItemString(PyObject *o, char *key)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001586{
1587 PyObject *okey, *r;
1588
1589 if (key == NULL)
1590 return null_error();
1591
1592 okey = PyString_FromString(key);
1593 if (okey == NULL)
1594 return NULL;
1595 r = PyObject_GetItem(o, okey);
1596 Py_DECREF(okey);
1597 return r;
1598}
1599
1600int
Fred Drake79912472000-07-09 04:06:11 +00001601PyMapping_SetItemString(PyObject *o, char *key, PyObject *value)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001602{
1603 PyObject *okey;
1604 int r;
1605
1606 if (key == NULL) {
1607 null_error();
1608 return -1;
1609 }
1610
1611 okey = PyString_FromString(key);
1612 if (okey == NULL)
Guido van Rossumed6219b1998-05-29 02:59:33 +00001613 return -1;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001614 r = PyObject_SetItem(o, okey, value);
1615 Py_DECREF(okey);
1616 return r;
1617}
1618
1619int
Fred Drake79912472000-07-09 04:06:11 +00001620PyMapping_HasKeyString(PyObject *o, char *key)
Guido van Rossume15dee51995-07-18 14:12:02 +00001621{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001622 PyObject *v;
Guido van Rossume15dee51995-07-18 14:12:02 +00001623
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001624 v = PyMapping_GetItemString(o, key);
1625 if (v) {
1626 Py_DECREF(v);
1627 return 1;
1628 }
1629 PyErr_Clear();
1630 return 0;
Guido van Rossume15dee51995-07-18 14:12:02 +00001631}
1632
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001633int
Fred Drake79912472000-07-09 04:06:11 +00001634PyMapping_HasKey(PyObject *o, PyObject *key)
Guido van Rossume15dee51995-07-18 14:12:02 +00001635{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001636 PyObject *v;
Guido van Rossume15dee51995-07-18 14:12:02 +00001637
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001638 v = PyObject_GetItem(o, key);
1639 if (v) {
1640 Py_DECREF(v);
1641 return 1;
1642 }
1643 PyErr_Clear();
1644 return 0;
Guido van Rossume15dee51995-07-18 14:12:02 +00001645}
1646
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001647/* Operations on callable objects */
1648
1649/* XXX PyCallable_Check() is in object.c */
1650
Guido van Rossume15dee51995-07-18 14:12:02 +00001651PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001652PyObject_CallObject(PyObject *o, PyObject *a)
Guido van Rossume15dee51995-07-18 14:12:02 +00001653{
Guido van Rossum5560b742001-09-14 16:47:50 +00001654 return PyEval_CallObjectWithKeywords(o, a, NULL);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001655}
Guido van Rossume15dee51995-07-18 14:12:02 +00001656
1657PyObject *
Tim Peters6d6c1a32001-08-02 04:15:00 +00001658PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw)
1659{
1660 ternaryfunc call;
1661
1662 if ((call = func->ob_type->tp_call) != NULL) {
1663 PyObject *result = (*call)(func, arg, kw);
1664 if (result == NULL && !PyErr_Occurred())
1665 PyErr_SetString(
1666 PyExc_SystemError,
1667 "NULL result without error in PyObject_Call");
1668 return result;
1669 }
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001670 PyErr_Format(PyExc_TypeError, "'%.200s' object is not callable",
Fred Drake573395a2001-11-01 20:26:12 +00001671 func->ob_type->tp_name);
Tim Peters6d6c1a32001-08-02 04:15:00 +00001672 return NULL;
1673}
1674
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001675static PyObject*
1676call_function_tail(PyObject *callable, PyObject *args)
1677{
1678 PyObject *retval;
1679
1680 if (args == NULL)
1681 return NULL;
1682
1683 if (!PyTuple_Check(args)) {
1684 PyObject *a;
1685
1686 a = PyTuple_New(1);
1687 if (a == NULL) {
1688 Py_DECREF(args);
1689 return NULL;
1690 }
1691 PyTuple_SET_ITEM(a, 0, args);
1692 args = a;
1693 }
1694 retval = PyObject_Call(callable, args, NULL);
1695
1696 Py_DECREF(args);
1697
1698 return retval;
1699}
1700
Tim Peters6d6c1a32001-08-02 04:15:00 +00001701PyObject *
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001702PyObject_CallFunction(PyObject *callable, char *format, ...)
Guido van Rossume15dee51995-07-18 14:12:02 +00001703{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001704 va_list va;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001705 PyObject *args;
Guido van Rossume15dee51995-07-18 14:12:02 +00001706
Fred Drakeb92cf062001-10-27 06:16:31 +00001707 if (callable == NULL)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001708 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001709
Fred Drakeb92cf062001-10-27 06:16:31 +00001710 if (format && *format) {
1711 va_start(va, format);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001712 args = Py_VaBuildValue(format, va);
Fred Drakeb92cf062001-10-27 06:16:31 +00001713 va_end(va);
1714 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001715 else
1716 args = PyTuple_New(0);
Guido van Rossume15dee51995-07-18 14:12:02 +00001717
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001718 return call_function_tail(callable, args);
1719}
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001720
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001721PyObject *
1722_PyObject_CallFunction_SizeT(PyObject *callable, char *format, ...)
1723{
1724 va_list va;
1725 PyObject *args;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001726
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001727 if (callable == NULL)
1728 return null_error();
1729
1730 if (format && *format) {
1731 va_start(va, format);
1732 args = _Py_VaBuildValue_SizeT(format, va);
1733 va_end(va);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001734 }
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001735 else
1736 args = PyTuple_New(0);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001737
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001738 return call_function_tail(callable, args);
Guido van Rossume15dee51995-07-18 14:12:02 +00001739}
1740
1741PyObject *
Guido van Rossume15dee51995-07-18 14:12:02 +00001742PyObject_CallMethod(PyObject *o, char *name, char *format, ...)
Guido van Rossume15dee51995-07-18 14:12:02 +00001743{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001744 va_list va;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001745 PyObject *args;
Michael W. Hudson0edc7a02005-07-12 10:21:19 +00001746 PyObject *func = NULL;
1747 PyObject *retval = NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +00001748
Fred Drakeb92cf062001-10-27 06:16:31 +00001749 if (o == NULL || name == NULL)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001750 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001751
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001752 func = PyObject_GetAttrString(o, name);
1753 if (func == NULL) {
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001754 PyErr_SetString(PyExc_AttributeError, name);
1755 return 0;
1756 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001757
Michael W. Hudson0edc7a02005-07-12 10:21:19 +00001758 if (!PyCallable_Check(func)) {
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001759 type_error("attribute of type '%.200s' is not callable", func);
Michael W. Hudson0edc7a02005-07-12 10:21:19 +00001760 goto exit;
1761 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001762
Fred Drakeb92cf062001-10-27 06:16:31 +00001763 if (format && *format) {
1764 va_start(va, format);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001765 args = Py_VaBuildValue(format, va);
Fred Drakeb92cf062001-10-27 06:16:31 +00001766 va_end(va);
1767 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001768 else
1769 args = PyTuple_New(0);
Guido van Rossume15dee51995-07-18 14:12:02 +00001770
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001771 retval = call_function_tail(func, args);
Guido van Rossume15dee51995-07-18 14:12:02 +00001772
Michael W. Hudson0edc7a02005-07-12 10:21:19 +00001773 exit:
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001774 /* args gets consumed in call_function_tail */
1775 Py_XDECREF(func);
1776
1777 return retval;
1778}
1779
1780PyObject *
1781_PyObject_CallMethod_SizeT(PyObject *o, char *name, char *format, ...)
1782{
1783 va_list va;
1784 PyObject *args;
1785 PyObject *func = NULL;
1786 PyObject *retval = NULL;
1787
1788 if (o == NULL || name == NULL)
1789 return null_error();
1790
1791 func = PyObject_GetAttrString(o, name);
1792 if (func == NULL) {
1793 PyErr_SetString(PyExc_AttributeError, name);
1794 return 0;
1795 }
1796
1797 if (!PyCallable_Check(func)) {
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001798 type_error("attribute of type '%.200s' is not callable", func);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001799 goto exit;
1800 }
1801
1802 if (format && *format) {
1803 va_start(va, format);
1804 args = _Py_VaBuildValue_SizeT(format, va);
1805 va_end(va);
1806 }
1807 else
1808 args = PyTuple_New(0);
1809
1810 retval = call_function_tail(func, args);
1811
1812 exit:
1813 /* args gets consumed in call_function_tail */
Michael W. Hudson0edc7a02005-07-12 10:21:19 +00001814 Py_XDECREF(func);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001815
1816 return retval;
Guido van Rossume15dee51995-07-18 14:12:02 +00001817}
Guido van Rossum823649d2001-03-21 18:40:58 +00001818
1819
Fred Drakeb421b8c2001-10-26 16:21:32 +00001820static PyObject *
Fred Drakeb0c079e2001-10-28 02:39:03 +00001821objargs_mktuple(va_list va)
Fred Drakeb421b8c2001-10-26 16:21:32 +00001822{
1823 int i, n = 0;
1824 va_list countva;
1825 PyObject *result, *tmp;
1826
1827#ifdef VA_LIST_IS_ARRAY
1828 memcpy(countva, va, sizeof(va_list));
1829#else
Martin v. Löwis75d2d942002-07-28 10:23:27 +00001830#ifdef __va_copy
1831 __va_copy(countva, va);
1832#else
Fred Drakeb421b8c2001-10-26 16:21:32 +00001833 countva = va;
1834#endif
Martin v. Löwis75d2d942002-07-28 10:23:27 +00001835#endif
Fred Drakeb421b8c2001-10-26 16:21:32 +00001836
1837 while (((PyObject *)va_arg(countva, PyObject *)) != NULL)
1838 ++n;
1839 result = PyTuple_New(n);
1840 if (result != NULL && n > 0) {
1841 for (i = 0; i < n; ++i) {
1842 tmp = (PyObject *)va_arg(va, PyObject *);
1843 PyTuple_SET_ITEM(result, i, tmp);
1844 Py_INCREF(tmp);
1845 }
1846 }
1847 return result;
1848}
1849
1850PyObject *
Fred Drakeb0c079e2001-10-28 02:39:03 +00001851PyObject_CallMethodObjArgs(PyObject *callable, PyObject *name, ...)
Fred Drakeb421b8c2001-10-26 16:21:32 +00001852{
1853 PyObject *args, *tmp;
1854 va_list vargs;
1855
1856 if (callable == NULL || name == NULL)
1857 return null_error();
1858
1859 callable = PyObject_GetAttr(callable, name);
1860 if (callable == NULL)
1861 return NULL;
1862
1863 /* count the args */
1864 va_start(vargs, name);
Fred Drakeb0c079e2001-10-28 02:39:03 +00001865 args = objargs_mktuple(vargs);
Fred Drakeb421b8c2001-10-26 16:21:32 +00001866 va_end(vargs);
1867 if (args == NULL) {
1868 Py_DECREF(callable);
1869 return NULL;
1870 }
1871 tmp = PyObject_Call(callable, args, NULL);
1872 Py_DECREF(args);
1873 Py_DECREF(callable);
1874
1875 return tmp;
1876}
1877
1878PyObject *
Fred Drakeb0c079e2001-10-28 02:39:03 +00001879PyObject_CallFunctionObjArgs(PyObject *callable, ...)
Fred Drakeb421b8c2001-10-26 16:21:32 +00001880{
1881 PyObject *args, *tmp;
1882 va_list vargs;
1883
1884 if (callable == NULL)
1885 return null_error();
1886
1887 /* count the args */
1888 va_start(vargs, callable);
Fred Drakeb0c079e2001-10-28 02:39:03 +00001889 args = objargs_mktuple(vargs);
Fred Drakeb421b8c2001-10-26 16:21:32 +00001890 va_end(vargs);
1891 if (args == NULL)
1892 return NULL;
1893 tmp = PyObject_Call(callable, args, NULL);
1894 Py_DECREF(args);
1895
1896 return tmp;
1897}
1898
1899
Guido van Rossum823649d2001-03-21 18:40:58 +00001900/* isinstance(), issubclass() */
1901
Barry Warsawf16951c2002-04-23 22:45:44 +00001902/* abstract_get_bases() has logically 4 return states, with a sort of 0th
1903 * state that will almost never happen.
1904 *
1905 * 0. creating the __bases__ static string could get a MemoryError
1906 * 1. getattr(cls, '__bases__') could raise an AttributeError
1907 * 2. getattr(cls, '__bases__') could raise some other exception
1908 * 3. getattr(cls, '__bases__') could return a tuple
1909 * 4. getattr(cls, '__bases__') could return something other than a tuple
1910 *
1911 * Only state #3 is a non-error state and only it returns a non-NULL object
1912 * (it returns the retrieved tuple).
1913 *
1914 * Any raised AttributeErrors are masked by clearing the exception and
1915 * returning NULL. If an object other than a tuple comes out of __bases__,
1916 * then again, the return value is NULL. So yes, these two situations
1917 * produce exactly the same results: NULL is returned and no error is set.
1918 *
1919 * If some exception other than AttributeError is raised, then NULL is also
1920 * returned, but the exception is not cleared. That's because we want the
1921 * exception to be propagated along.
1922 *
1923 * Callers are expected to test for PyErr_Occurred() when the return value
1924 * is NULL to decide whether a valid exception should be propagated or not.
1925 * When there's no exception to propagate, it's customary for the caller to
1926 * set a TypeError.
1927 */
Neil Schemenauer6b471292001-10-18 03:18:43 +00001928static PyObject *
1929abstract_get_bases(PyObject *cls)
Guido van Rossum823649d2001-03-21 18:40:58 +00001930{
1931 static PyObject *__bases__ = NULL;
1932 PyObject *bases;
Guido van Rossum823649d2001-03-21 18:40:58 +00001933
1934 if (__bases__ == NULL) {
1935 __bases__ = PyString_FromString("__bases__");
1936 if (__bases__ == NULL)
Neil Schemenauer6b471292001-10-18 03:18:43 +00001937 return NULL;
Guido van Rossum823649d2001-03-21 18:40:58 +00001938 }
Neil Schemenauer6b471292001-10-18 03:18:43 +00001939 bases = PyObject_GetAttr(cls, __bases__);
Barry Warsawf16951c2002-04-23 22:45:44 +00001940 if (bases == NULL) {
1941 if (PyErr_ExceptionMatches(PyExc_AttributeError))
1942 PyErr_Clear();
Neil Schemenauer6b471292001-10-18 03:18:43 +00001943 return NULL;
Guido van Rossum823649d2001-03-21 18:40:58 +00001944 }
Barry Warsawf16951c2002-04-23 22:45:44 +00001945 if (!PyTuple_Check(bases)) {
1946 Py_DECREF(bases);
1947 return NULL;
1948 }
Neil Schemenauer6b471292001-10-18 03:18:43 +00001949 return bases;
1950}
1951
1952
1953static int
1954abstract_issubclass(PyObject *derived, PyObject *cls)
1955{
1956 PyObject *bases;
Martin v. Löwis18e16552006-02-15 17:27:45 +00001957 Py_ssize_t i, n;
Neil Schemenauer6b471292001-10-18 03:18:43 +00001958 int r = 0;
1959
1960
Guido van Rossum823649d2001-03-21 18:40:58 +00001961 if (derived == cls)
1962 return 1;
1963
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00001964 if (PyTuple_Check(cls)) {
1965 /* Not a general sequence -- that opens up the road to
1966 recursion and stack overflow. */
1967 n = PyTuple_GET_SIZE(cls);
1968 for (i = 0; i < n; i++) {
1969 if (derived == PyTuple_GET_ITEM(cls, i))
1970 return 1;
1971 }
1972 }
Neil Schemenauer6b471292001-10-18 03:18:43 +00001973 bases = abstract_get_bases(derived);
Barry Warsawf16951c2002-04-23 22:45:44 +00001974 if (bases == NULL) {
1975 if (PyErr_Occurred())
1976 return -1;
Neil Schemenauer6b471292001-10-18 03:18:43 +00001977 return 0;
Barry Warsawf16951c2002-04-23 22:45:44 +00001978 }
Guido van Rossum823649d2001-03-21 18:40:58 +00001979 n = PyTuple_GET_SIZE(bases);
1980 for (i = 0; i < n; i++) {
Neil Schemenauer6b471292001-10-18 03:18:43 +00001981 r = abstract_issubclass(PyTuple_GET_ITEM(bases, i), cls);
Guido van Rossum823649d2001-03-21 18:40:58 +00001982 if (r != 0)
1983 break;
1984 }
1985
1986 Py_DECREF(bases);
1987
1988 return r;
1989}
1990
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00001991static int
1992check_class(PyObject *cls, const char *error)
1993{
1994 PyObject *bases = abstract_get_bases(cls);
1995 if (bases == NULL) {
1996 /* Do not mask errors. */
1997 if (!PyErr_Occurred())
1998 PyErr_SetString(PyExc_TypeError, error);
1999 return 0;
2000 }
2001 Py_DECREF(bases);
2002 return -1;
2003}
2004
Brett Cannon4f653312004-03-20 22:52:14 +00002005static int
2006recursive_isinstance(PyObject *inst, PyObject *cls, int recursion_depth)
Guido van Rossum823649d2001-03-21 18:40:58 +00002007{
2008 PyObject *icls;
2009 static PyObject *__class__ = NULL;
2010 int retval = 0;
2011
Guido van Rossum03bc7d32003-02-12 03:32:58 +00002012 if (__class__ == NULL) {
2013 __class__ = PyString_FromString("__class__");
2014 if (__class__ == NULL)
2015 return -1;
2016 }
2017
Guido van Rossum45aecf42006-03-15 04:58:47 +00002018 if (PyType_Check(cls)) {
Tim Peters6d6c1a32001-08-02 04:15:00 +00002019 retval = PyObject_TypeCheck(inst, (PyTypeObject *)cls);
Guido van Rossum03bc7d32003-02-12 03:32:58 +00002020 if (retval == 0) {
2021 PyObject *c = PyObject_GetAttr(inst, __class__);
2022 if (c == NULL) {
2023 PyErr_Clear();
2024 }
2025 else {
Guido van Rossume5b130b2003-02-12 03:36:05 +00002026 if (c != (PyObject *)(inst->ob_type) &&
2027 PyType_Check(c))
Guido van Rossum03bc7d32003-02-12 03:32:58 +00002028 retval = PyType_IsSubtype(
2029 (PyTypeObject *)c,
2030 (PyTypeObject *)cls);
2031 Py_DECREF(c);
2032 }
2033 }
Guido van Rossum823649d2001-03-21 18:40:58 +00002034 }
Guido van Rossum03290ec2001-10-07 20:54:12 +00002035 else if (PyTuple_Check(cls)) {
Martin v. Löwis18e16552006-02-15 17:27:45 +00002036 Py_ssize_t i, n;
Guido van Rossum03290ec2001-10-07 20:54:12 +00002037
Brett Cannon4f653312004-03-20 22:52:14 +00002038 if (!recursion_depth) {
2039 PyErr_SetString(PyExc_RuntimeError,
2040 "nest level of tuple too deep");
Tim Peters5f112eb2004-03-21 16:59:09 +00002041 return -1;
Brett Cannon4f653312004-03-20 22:52:14 +00002042 }
2043
Guido van Rossum03290ec2001-10-07 20:54:12 +00002044 n = PyTuple_GET_SIZE(cls);
2045 for (i = 0; i < n; i++) {
Brett Cannon4f653312004-03-20 22:52:14 +00002046 retval = recursive_isinstance(
2047 inst,
2048 PyTuple_GET_ITEM(cls, i),
2049 recursion_depth-1);
Guido van Rossum03290ec2001-10-07 20:54:12 +00002050 if (retval != 0)
2051 break;
2052 }
Guido van Rossum03290ec2001-10-07 20:54:12 +00002053 }
Neil Schemenauer6b471292001-10-18 03:18:43 +00002054 else {
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00002055 if (!check_class(cls,
2056 "isinstance() arg 2 must be a class, type,"
2057 " or tuple of classes and types"))
Neil Schemenauer6b471292001-10-18 03:18:43 +00002058 return -1;
Guido van Rossum823649d2001-03-21 18:40:58 +00002059 icls = PyObject_GetAttr(inst, __class__);
Neil Schemenauer6b471292001-10-18 03:18:43 +00002060 if (icls == NULL) {
2061 PyErr_Clear();
2062 retval = 0;
Guido van Rossum823649d2001-03-21 18:40:58 +00002063 }
Neil Schemenauer6b471292001-10-18 03:18:43 +00002064 else {
2065 retval = abstract_issubclass(icls, cls);
2066 Py_DECREF(icls);
2067 }
Guido van Rossum823649d2001-03-21 18:40:58 +00002068 }
Guido van Rossum823649d2001-03-21 18:40:58 +00002069
Guido van Rossum823649d2001-03-21 18:40:58 +00002070 return retval;
2071}
2072
2073int
Brett Cannon4f653312004-03-20 22:52:14 +00002074PyObject_IsInstance(PyObject *inst, PyObject *cls)
2075{
2076 return recursive_isinstance(inst, cls, Py_GetRecursionLimit());
2077}
2078
2079static int
2080recursive_issubclass(PyObject *derived, PyObject *cls, int recursion_depth)
Guido van Rossum823649d2001-03-21 18:40:58 +00002081{
2082 int retval;
2083
Guido van Rossum45aecf42006-03-15 04:58:47 +00002084 {
Guido van Rossumf6c9ba82003-02-10 16:05:43 +00002085 if (!check_class(derived,
2086 "issubclass() arg 1 must be a class"))
Neil Schemenauer6b471292001-10-18 03:18:43 +00002087 return -1;
Neil Schemenauer6b471292001-10-18 03:18:43 +00002088
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00002089 if (PyTuple_Check(cls)) {
Martin v. Löwis18e16552006-02-15 17:27:45 +00002090 Py_ssize_t i;
2091 Py_ssize_t n = PyTuple_GET_SIZE(cls);
Brett Cannon4f653312004-03-20 22:52:14 +00002092
2093 if (!recursion_depth) {
2094 PyErr_SetString(PyExc_RuntimeError,
2095 "nest level of tuple too deep");
Tim Peters5f112eb2004-03-21 16:59:09 +00002096 return -1;
Brett Cannon4f653312004-03-20 22:52:14 +00002097 }
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00002098 for (i = 0; i < n; ++i) {
Brett Cannon4f653312004-03-20 22:52:14 +00002099 retval = recursive_issubclass(
2100 derived,
2101 PyTuple_GET_ITEM(cls, i),
2102 recursion_depth-1);
Guido van Rossumf6c9ba82003-02-10 16:05:43 +00002103 if (retval != 0) {
2104 /* either found it, or got an error */
Walter Dörwald7e5c6a02002-12-12 19:14:08 +00002105 return retval;
Guido van Rossumf6c9ba82003-02-10 16:05:43 +00002106 }
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00002107 }
Walter Dörwald7e5c6a02002-12-12 19:14:08 +00002108 return 0;
Neil Schemenauer6b471292001-10-18 03:18:43 +00002109 }
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00002110 else {
2111 if (!check_class(cls,
2112 "issubclass() arg 2 must be a class"
2113 " or tuple of classes"))
2114 return -1;
2115 }
Neil Schemenauer6b471292001-10-18 03:18:43 +00002116
2117 retval = abstract_issubclass(derived, cls);
Guido van Rossum823649d2001-03-21 18:40:58 +00002118 }
Guido van Rossum823649d2001-03-21 18:40:58 +00002119
2120 return retval;
2121}
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002122
Brett Cannon4f653312004-03-20 22:52:14 +00002123int
2124PyObject_IsSubclass(PyObject *derived, PyObject *cls)
2125{
2126 return recursive_issubclass(derived, cls, Py_GetRecursionLimit());
2127}
2128
2129
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002130PyObject *
2131PyObject_GetIter(PyObject *o)
2132{
2133 PyTypeObject *t = o->ob_type;
2134 getiterfunc f = NULL;
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +00002135 f = t->tp_iter;
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002136 if (f == NULL) {
2137 if (PySequence_Check(o))
Guido van Rossum213c7a62001-04-23 14:08:49 +00002138 return PySeqIter_New(o);
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002139 return type_error("'%.200s' object is not iterable", o);
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002140 }
Guido van Rossum213c7a62001-04-23 14:08:49 +00002141 else {
2142 PyObject *res = (*f)(o);
2143 if (res != NULL && !PyIter_Check(res)) {
2144 PyErr_Format(PyExc_TypeError,
2145 "iter() returned non-iterator "
2146 "of type '%.100s'",
2147 res->ob_type->tp_name);
2148 Py_DECREF(res);
2149 res = NULL;
2150 }
2151 return res;
2152 }
2153}
2154
Tim Petersf4848da2001-05-05 00:14:56 +00002155/* Return next item.
2156 * If an error occurs, return NULL. PyErr_Occurred() will be true.
2157 * If the iteration terminates normally, return NULL and clear the
2158 * PyExc_StopIteration exception (if it was set). PyErr_Occurred()
2159 * will be false.
2160 * Else return the next object. PyErr_Occurred() will be false.
2161 */
Guido van Rossum213c7a62001-04-23 14:08:49 +00002162PyObject *
2163PyIter_Next(PyObject *iter)
2164{
Tim Petersf4848da2001-05-05 00:14:56 +00002165 PyObject *result;
Raymond Hettinger8049dde2003-03-01 01:44:32 +00002166 assert(PyIter_Check(iter));
Tim Petersf4848da2001-05-05 00:14:56 +00002167 result = (*iter->ob_type->tp_iternext)(iter);
2168 if (result == NULL &&
2169 PyErr_Occurred() &&
2170 PyErr_ExceptionMatches(PyExc_StopIteration))
2171 PyErr_Clear();
2172 return result;
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002173}