blob: 1f8feb52e721d17214c4c4836c6bbd7a03a94938 [file] [log] [blame]
Guido van Rossume15dee51995-07-18 14:12:02 +00001/* Abstract Object Interface (many thanks to Jim Fulton) */
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002
Guido van Rossume15dee51995-07-18 14:12:02 +00003#include "Python.h"
Guido van Rossumfa0b6ab1998-05-22 15:23:36 +00004#include <ctype.h>
Neil Schemenauer5a1f0152001-01-04 01:39:06 +00005#include "structmember.h" /* we need the offsetof() macro from there */
Tim Peters64b5ce32001-09-10 20:52:51 +00006#include "longintrepr.h"
Neil Schemenauer5a1f0152001-01-04 01:39:06 +00007
8#define NEW_STYLE_NUMBER(o) PyType_HasFeature((o)->ob_type, \
Guido van Rossumc3189692001-01-17 15:29:42 +00009 Py_TPFLAGS_CHECKTYPES)
Guido van Rossume15dee51995-07-18 14:12:02 +000010
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000011/* Shorthands to return certain errors */
Guido van Rossume15dee51995-07-18 14:12:02 +000012
13static PyObject *
Fred Drake4201b9e2000-07-09 04:34:13 +000014type_error(const char *msg)
Guido van Rossume15dee51995-07-18 14:12:02 +000015{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000016 PyErr_SetString(PyExc_TypeError, msg);
17 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +000018}
19
Guido van Rossum052b7e11996-11-11 15:08:19 +000020static PyObject *
Fred Drake79912472000-07-09 04:06:11 +000021null_error(void)
Guido van Rossume15dee51995-07-18 14:12:02 +000022{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000023 if (!PyErr_Occurred())
24 PyErr_SetString(PyExc_SystemError,
25 "null argument to internal routine");
26 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +000027}
28
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000029/* Operations on any object */
30
31int
Fred Drake79912472000-07-09 04:06:11 +000032PyObject_Cmp(PyObject *o1, PyObject *o2, int *result)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000033{
34 int r;
35
36 if (o1 == NULL || o2 == NULL) {
37 null_error();
38 return -1;
39 }
40 r = PyObject_Compare(o1, o2);
41 if (PyErr_Occurred())
42 return -1;
43 *result = r;
Guido van Rossume15dee51995-07-18 14:12:02 +000044 return 0;
45}
Guido van Rossume15dee51995-07-18 14:12:02 +000046
47PyObject *
Fred Drake79912472000-07-09 04:06:11 +000048PyObject_Type(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +000049{
50 PyObject *v;
51
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000052 if (o == NULL)
53 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +000054 v = (PyObject *)o->ob_type;
55 Py_INCREF(v);
56 return v;
57}
58
59int
Jeremy Hylton6253f832000-07-12 12:56:19 +000060PyObject_Size(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +000061{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000062 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +000063
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000064 if (o == NULL) {
65 null_error();
66 return -1;
67 }
Guido van Rossume15dee51995-07-18 14:12:02 +000068
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000069 m = o->ob_type->tp_as_sequence;
70 if (m && m->sq_length)
71 return m->sq_length(o);
Guido van Rossume15dee51995-07-18 14:12:02 +000072
Jeremy Hylton6253f832000-07-12 12:56:19 +000073 return PyMapping_Size(o);
Guido van Rossume15dee51995-07-18 14:12:02 +000074}
75
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +000076#undef PyObject_Length
77int
78PyObject_Length(PyObject *o)
79{
80 return PyObject_Size(o);
81}
82#define PyObject_Length PyObject_Size
83
Raymond Hettinger6b27cda2005-09-24 21:23:05 +000084int
85_PyObject_LengthCue(PyObject *o)
86{
87 int rv = PyObject_Size(o);
88 if (rv != -1)
89 return rv;
90 if (PyErr_ExceptionMatches(PyExc_TypeError) ||
91 PyErr_ExceptionMatches(PyExc_AttributeError)) {
92 PyObject *err_type, *err_value, *err_tb, *ro;
93
94 PyErr_Fetch(&err_type, &err_value, &err_tb);
95 ro = PyObject_CallMethod(o, "_length_cue", NULL);
96 if (ro != NULL) {
97 rv = (int)PyInt_AsLong(ro);
98 Py_DECREF(ro);
99 Py_XDECREF(err_type);
100 Py_XDECREF(err_value);
101 Py_XDECREF(err_tb);
102 return rv;
103 }
104 PyErr_Restore(err_type, err_value, err_tb);
105 }
106 return -1;
107}
108
Guido van Rossume15dee51995-07-18 14:12:02 +0000109PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000110PyObject_GetItem(PyObject *o, PyObject *key)
Guido van Rossume15dee51995-07-18 14:12:02 +0000111{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000112 PyMappingMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +0000113
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000114 if (o == NULL || key == NULL)
115 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +0000116
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000117 m = o->ob_type->tp_as_mapping;
118 if (m && m->mp_subscript)
119 return m->mp_subscript(o, key);
Guido van Rossume15dee51995-07-18 14:12:02 +0000120
Guido van Rossum21308241998-08-13 16:44:44 +0000121 if (o->ob_type->tp_as_sequence) {
122 if (PyInt_Check(key))
123 return PySequence_GetItem(o, PyInt_AsLong(key));
Andrew M. Kuchling0f223d22000-02-23 22:21:50 +0000124 else if (PyLong_Check(key)) {
125 long key_value = PyLong_AsLong(key);
126 if (key_value == -1 && PyErr_Occurred())
127 return NULL;
128 return PySequence_GetItem(o, key_value);
129 }
Guido van Rossum64585f62001-11-24 18:24:47 +0000130 else if (o->ob_type->tp_as_sequence->sq_item)
131 return type_error("sequence index must be integer");
Guido van Rossum21308241998-08-13 16:44:44 +0000132 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000133
134 return type_error("unsubscriptable object");
Guido van Rossume15dee51995-07-18 14:12:02 +0000135}
136
137int
Fred Drake79912472000-07-09 04:06:11 +0000138PyObject_SetItem(PyObject *o, PyObject *key, PyObject *value)
Guido van Rossume15dee51995-07-18 14:12:02 +0000139{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000140 PyMappingMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +0000141
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000142 if (o == NULL || key == NULL || value == NULL) {
143 null_error();
144 return -1;
145 }
146 m = o->ob_type->tp_as_mapping;
147 if (m && m->mp_ass_subscript)
148 return m->mp_ass_subscript(o, key, value);
Guido van Rossume15dee51995-07-18 14:12:02 +0000149
Guido van Rossum21308241998-08-13 16:44:44 +0000150 if (o->ob_type->tp_as_sequence) {
151 if (PyInt_Check(key))
152 return PySequence_SetItem(o, PyInt_AsLong(key), value);
Andrew M. Kuchling0f223d22000-02-23 22:21:50 +0000153 else if (PyLong_Check(key)) {
154 long key_value = PyLong_AsLong(key);
155 if (key_value == -1 && PyErr_Occurred())
156 return -1;
157 return PySequence_SetItem(o, key_value, value);
158 }
Guido van Rossum64585f62001-11-24 18:24:47 +0000159 else if (o->ob_type->tp_as_sequence->sq_ass_item) {
160 type_error("sequence index must be integer");
161 return -1;
162 }
Guido van Rossum21308241998-08-13 16:44:44 +0000163 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000164
165 type_error("object does not support item assignment");
166 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +0000167}
168
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000169int
Fred Drake79912472000-07-09 04:06:11 +0000170PyObject_DelItem(PyObject *o, PyObject *key)
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000171{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000172 PyMappingMethods *m;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000173
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000174 if (o == NULL || key == NULL) {
175 null_error();
176 return -1;
177 }
178 m = o->ob_type->tp_as_mapping;
179 if (m && m->mp_ass_subscript)
180 return m->mp_ass_subscript(o, key, (PyObject*)NULL);
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000181
Guido van Rossum21308241998-08-13 16:44:44 +0000182 if (o->ob_type->tp_as_sequence) {
183 if (PyInt_Check(key))
184 return PySequence_DelItem(o, PyInt_AsLong(key));
Andrew M. Kuchling0f223d22000-02-23 22:21:50 +0000185 else if (PyLong_Check(key)) {
186 long key_value = PyLong_AsLong(key);
187 if (key_value == -1 && PyErr_Occurred())
188 return -1;
189 return PySequence_DelItem(o, key_value);
190 }
Guido van Rossum64585f62001-11-24 18:24:47 +0000191 else if (o->ob_type->tp_as_sequence->sq_ass_item) {
192 type_error("sequence index must be integer");
193 return -1;
194 }
Guido van Rossum21308241998-08-13 16:44:44 +0000195 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000196
197 type_error("object does not support item deletion");
198 return -1;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000199}
200
Martin v. Löwisb0d71d02002-01-05 10:50:30 +0000201int
202PyObject_DelItemString(PyObject *o, char *key)
203{
204 PyObject *okey;
205 int ret;
206
207 if (o == NULL || key == NULL) {
208 null_error();
209 return -1;
210 }
211 okey = PyString_FromString(key);
212 if (okey == NULL)
213 return -1;
214 ret = PyObject_DelItem(o, okey);
215 Py_DECREF(okey);
216 return ret;
217}
218
Guido van Rossum4c08d552000-03-10 22:55:18 +0000219int PyObject_AsCharBuffer(PyObject *obj,
220 const char **buffer,
221 int *buffer_len)
222{
223 PyBufferProcs *pb;
224 const char *pp;
225 int len;
226
227 if (obj == NULL || buffer == NULL || buffer_len == NULL) {
228 null_error();
229 return -1;
230 }
231 pb = obj->ob_type->tp_as_buffer;
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000232 if (pb == NULL ||
Guido van Rossum4c08d552000-03-10 22:55:18 +0000233 pb->bf_getcharbuffer == NULL ||
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000234 pb->bf_getsegcount == NULL) {
Guido van Rossum4c08d552000-03-10 22:55:18 +0000235 PyErr_SetString(PyExc_TypeError,
236 "expected a character buffer object");
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000237 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000238 }
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000239 if ((*pb->bf_getsegcount)(obj,NULL) != 1) {
Guido van Rossum4c08d552000-03-10 22:55:18 +0000240 PyErr_SetString(PyExc_TypeError,
241 "expected a single-segment buffer object");
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000242 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000243 }
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000244 len = (*pb->bf_getcharbuffer)(obj, 0, &pp);
Guido van Rossum4c08d552000-03-10 22:55:18 +0000245 if (len < 0)
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000246 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000247 *buffer = pp;
248 *buffer_len = len;
249 return 0;
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000250}
Guido van Rossum4c08d552000-03-10 22:55:18 +0000251
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000252int
253PyObject_CheckReadBuffer(PyObject *obj)
254{
255 PyBufferProcs *pb = obj->ob_type->tp_as_buffer;
256
257 if (pb == NULL ||
258 pb->bf_getreadbuffer == NULL ||
259 pb->bf_getsegcount == NULL ||
260 (*pb->bf_getsegcount)(obj, NULL) != 1)
261 return 0;
262 return 1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000263}
264
265int PyObject_AsReadBuffer(PyObject *obj,
266 const void **buffer,
267 int *buffer_len)
268{
269 PyBufferProcs *pb;
270 void *pp;
271 int len;
272
273 if (obj == NULL || buffer == NULL || buffer_len == NULL) {
274 null_error();
275 return -1;
276 }
277 pb = obj->ob_type->tp_as_buffer;
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000278 if (pb == NULL ||
Guido van Rossum4c08d552000-03-10 22:55:18 +0000279 pb->bf_getreadbuffer == NULL ||
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000280 pb->bf_getsegcount == NULL) {
Guido van Rossum4c08d552000-03-10 22:55:18 +0000281 PyErr_SetString(PyExc_TypeError,
282 "expected a readable buffer object");
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000283 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000284 }
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000285 if ((*pb->bf_getsegcount)(obj, NULL) != 1) {
Guido van Rossum4c08d552000-03-10 22:55:18 +0000286 PyErr_SetString(PyExc_TypeError,
287 "expected a single-segment buffer object");
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000288 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000289 }
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000290 len = (*pb->bf_getreadbuffer)(obj, 0, &pp);
Guido van Rossum4c08d552000-03-10 22:55:18 +0000291 if (len < 0)
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000292 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000293 *buffer = pp;
294 *buffer_len = len;
295 return 0;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000296}
297
298int PyObject_AsWriteBuffer(PyObject *obj,
299 void **buffer,
300 int *buffer_len)
301{
302 PyBufferProcs *pb;
303 void*pp;
304 int len;
305
306 if (obj == NULL || buffer == NULL || buffer_len == NULL) {
307 null_error();
308 return -1;
309 }
310 pb = obj->ob_type->tp_as_buffer;
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000311 if (pb == NULL ||
Guido van Rossum4c08d552000-03-10 22:55:18 +0000312 pb->bf_getwritebuffer == NULL ||
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000313 pb->bf_getsegcount == NULL) {
Guido van Rossum4c08d552000-03-10 22:55:18 +0000314 PyErr_SetString(PyExc_TypeError,
315 "expected a writeable buffer object");
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000316 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000317 }
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000318 if ((*pb->bf_getsegcount)(obj, NULL) != 1) {
Guido van Rossum4c08d552000-03-10 22:55:18 +0000319 PyErr_SetString(PyExc_TypeError,
320 "expected a single-segment buffer object");
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000321 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000322 }
323 len = (*pb->bf_getwritebuffer)(obj,0,&pp);
324 if (len < 0)
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000325 return -1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000326 *buffer = pp;
327 *buffer_len = len;
328 return 0;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000329}
330
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000331/* Operations on numbers */
332
333int
Fred Drake79912472000-07-09 04:06:11 +0000334PyNumber_Check(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +0000335{
Guido van Rossum6921eca2003-02-18 16:36:28 +0000336 return o && o->ob_type->tp_as_number &&
337 (o->ob_type->tp_as_number->nb_int ||
338 o->ob_type->tp_as_number->nb_float);
Guido van Rossume15dee51995-07-18 14:12:02 +0000339}
340
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000341/* Binary operators */
Guido van Rossume15dee51995-07-18 14:12:02 +0000342
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000343/* New style number protocol support */
Guido van Rossume15dee51995-07-18 14:12:02 +0000344
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000345#define NB_SLOT(x) offsetof(PyNumberMethods, x)
346#define NB_BINOP(nb_methods, slot) \
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000347 (*(binaryfunc*)(& ((char*)nb_methods)[slot]))
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000348#define NB_TERNOP(nb_methods, slot) \
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000349 (*(ternaryfunc*)(& ((char*)nb_methods)[slot]))
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000350
351/*
352 Calling scheme used for binary operations:
353
354 v w Action
355 -------------------------------------------------------------------
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000356 new new w.op(v,w)[*], v.op(v,w), w.op(v,w)
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000357 new old v.op(v,w), coerce(v,w), v.op(v,w)
358 old new w.op(v,w), coerce(v,w), v.op(v,w)
359 old old coerce(v,w), v.op(v,w)
360
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000361 [*] only when v->ob_type != w->ob_type && w->ob_type is a subclass of
362 v->ob_type
363
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000364 Legend:
365 -------
366 * new == new style number
367 * old == old style number
368 * Action indicates the order in which operations are tried until either
369 a valid result is produced or an error occurs.
370
371 */
372
373static PyObject *
374binary_op1(PyObject *v, PyObject *w, const int op_slot)
Guido van Rossume15dee51995-07-18 14:12:02 +0000375{
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000376 PyObject *x;
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000377 binaryfunc slotv = NULL;
378 binaryfunc slotw = NULL;
379
380 if (v->ob_type->tp_as_number != NULL && NEW_STYLE_NUMBER(v))
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000381 slotv = NB_BINOP(v->ob_type->tp_as_number, op_slot);
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000382 if (w->ob_type != v->ob_type &&
383 w->ob_type->tp_as_number != NULL && NEW_STYLE_NUMBER(w)) {
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000384 slotw = NB_BINOP(w->ob_type->tp_as_number, op_slot);
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000385 if (slotw == slotv)
386 slotw = NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +0000387 }
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000388 if (slotv) {
Guido van Rossum89c42642001-10-01 17:10:18 +0000389 if (slotw && PyType_IsSubtype(w->ob_type, v->ob_type)) {
390 x = slotw(v, w);
391 if (x != Py_NotImplemented)
392 return x;
393 Py_DECREF(x); /* can't do it */
394 slotw = NULL;
395 }
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000396 x = slotv(v, w);
397 if (x != Py_NotImplemented)
398 return x;
399 Py_DECREF(x); /* can't do it */
400 }
401 if (slotw) {
402 x = slotw(v, w);
403 if (x != Py_NotImplemented)
404 return x;
405 Py_DECREF(x); /* can't do it */
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000406 }
407 if (!NEW_STYLE_NUMBER(v) || !NEW_STYLE_NUMBER(w)) {
408 int err = PyNumber_CoerceEx(&v, &w);
409 if (err < 0) {
410 return NULL;
411 }
412 if (err == 0) {
413 PyNumberMethods *mv = v->ob_type->tp_as_number;
414 if (mv) {
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000415 binaryfunc slot;
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000416 slot = NB_BINOP(mv, op_slot);
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000417 if (slot) {
418 PyObject *x = slot(v, w);
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000419 Py_DECREF(v);
420 Py_DECREF(w);
421 return x;
422 }
423 }
424 /* CoerceEx incremented the reference counts */
425 Py_DECREF(v);
426 Py_DECREF(w);
427 }
428 }
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000429 Py_INCREF(Py_NotImplemented);
430 return Py_NotImplemented;
431}
Guido van Rossum77660912002-04-16 16:32:50 +0000432
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000433static PyObject *
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000434binop_type_error(PyObject *v, PyObject *w, const char *op_name)
435{
436 PyErr_Format(PyExc_TypeError,
437 "unsupported operand type(s) for %s: '%s' and '%s'",
438 op_name,
439 v->ob_type->tp_name,
440 w->ob_type->tp_name);
441 return NULL;
442}
443
444static PyObject *
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000445binary_op(PyObject *v, PyObject *w, const int op_slot, const char *op_name)
446{
447 PyObject *result = binary_op1(v, w, op_slot);
448 if (result == Py_NotImplemented) {
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000449 Py_DECREF(result);
450 return binop_type_error(v, w, op_name);
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000451 }
452 return result;
Guido van Rossume15dee51995-07-18 14:12:02 +0000453}
454
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000455
456/*
457 Calling scheme used for ternary operations:
458
Guido van Rossum84675ac2001-09-29 01:05:03 +0000459 *** In some cases, w.op is called before v.op; see binary_op1. ***
460
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000461 v w z Action
462 -------------------------------------------------------------------
463 new new new v.op(v,w,z), w.op(v,w,z), z.op(v,w,z)
464 new old new v.op(v,w,z), z.op(v,w,z), coerce(v,w,z), v.op(v,w,z)
465 old new new w.op(v,w,z), z.op(v,w,z), coerce(v,w,z), v.op(v,w,z)
466 old old new z.op(v,w,z), coerce(v,w,z), v.op(v,w,z)
467 new new old v.op(v,w,z), w.op(v,w,z), coerce(v,w,z), v.op(v,w,z)
468 new old old v.op(v,w,z), coerce(v,w,z), v.op(v,w,z)
469 old new old w.op(v,w,z), coerce(v,w,z), v.op(v,w,z)
470 old old old coerce(v,w,z), v.op(v,w,z)
471
472 Legend:
473 -------
474 * new == new style number
475 * old == old style number
476 * Action indicates the order in which operations are tried until either
477 a valid result is produced or an error occurs.
478 * coerce(v,w,z) actually does: coerce(v,w), coerce(v,z), coerce(w,z) and
479 only if z != Py_None; if z == Py_None, then it is treated as absent
480 variable and only coerce(v,w) is tried.
481
482 */
483
484static PyObject *
485ternary_op(PyObject *v,
486 PyObject *w,
487 PyObject *z,
488 const int op_slot,
489 const char *op_name)
Guido van Rossume15dee51995-07-18 14:12:02 +0000490{
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000491 PyNumberMethods *mv, *mw, *mz;
Guido van Rossum84675ac2001-09-29 01:05:03 +0000492 PyObject *x = NULL;
493 ternaryfunc slotv = NULL;
494 ternaryfunc slotw = NULL;
495 ternaryfunc slotz = NULL;
Guido van Rossum77660912002-04-16 16:32:50 +0000496
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000497 mv = v->ob_type->tp_as_number;
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000498 mw = w->ob_type->tp_as_number;
Guido van Rossum84675ac2001-09-29 01:05:03 +0000499 if (mv != NULL && NEW_STYLE_NUMBER(v))
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000500 slotv = NB_TERNOP(mv, op_slot);
Guido van Rossum84675ac2001-09-29 01:05:03 +0000501 if (w->ob_type != v->ob_type &&
Raymond Hettingerc2e095f2002-12-07 10:05:27 +0000502 mw != NULL && NEW_STYLE_NUMBER(w)) {
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000503 slotw = NB_TERNOP(mw, op_slot);
Guido van Rossum84675ac2001-09-29 01:05:03 +0000504 if (slotw == slotv)
505 slotw = NULL;
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000506 }
Guido van Rossum84675ac2001-09-29 01:05:03 +0000507 if (slotv) {
Guido van Rossum89c42642001-10-01 17:10:18 +0000508 if (slotw && PyType_IsSubtype(w->ob_type, v->ob_type)) {
509 x = slotw(v, w, z);
510 if (x != Py_NotImplemented)
511 return x;
512 Py_DECREF(x); /* can't do it */
513 slotw = NULL;
514 }
Guido van Rossum84675ac2001-09-29 01:05:03 +0000515 x = slotv(v, w, z);
516 if (x != Py_NotImplemented)
517 return x;
518 Py_DECREF(x); /* can't do it */
519 }
520 if (slotw) {
521 x = slotw(v, w, z);
522 if (x != Py_NotImplemented)
523 return x;
524 Py_DECREF(x); /* can't do it */
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000525 }
526 mz = z->ob_type->tp_as_number;
527 if (mz != NULL && NEW_STYLE_NUMBER(z)) {
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000528 slotz = NB_TERNOP(mz, op_slot);
Guido van Rossum84675ac2001-09-29 01:05:03 +0000529 if (slotz == slotv || slotz == slotw)
530 slotz = NULL;
531 if (slotz) {
532 x = slotz(v, w, z);
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000533 if (x != Py_NotImplemented)
534 return x;
Guido van Rossum84675ac2001-09-29 01:05:03 +0000535 Py_DECREF(x); /* can't do it */
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000536 }
537 }
538
539 if (!NEW_STYLE_NUMBER(v) || !NEW_STYLE_NUMBER(w) ||
540 (z != Py_None && !NEW_STYLE_NUMBER(z))) {
541 /* we have an old style operand, coerce */
542 PyObject *v1, *z1, *w2, *z2;
543 int c;
Guido van Rossum77660912002-04-16 16:32:50 +0000544
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000545 c = PyNumber_Coerce(&v, &w);
546 if (c != 0)
547 goto error3;
548
549 /* Special case: if the third argument is None, it is
550 treated as absent argument and not coerced. */
551 if (z == Py_None) {
552 if (v->ob_type->tp_as_number) {
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000553 slotz = NB_TERNOP(v->ob_type->tp_as_number,
554 op_slot);
Guido van Rossum84675ac2001-09-29 01:05:03 +0000555 if (slotz)
556 x = slotz(v, w, z);
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000557 else
558 c = -1;
559 }
560 else
561 c = -1;
562 goto error2;
563 }
564 v1 = v;
565 z1 = z;
566 c = PyNumber_Coerce(&v1, &z1);
567 if (c != 0)
568 goto error2;
569 w2 = w;
570 z2 = z1;
571 c = PyNumber_Coerce(&w2, &z2);
572 if (c != 0)
573 goto error1;
574
575 if (v1->ob_type->tp_as_number != NULL) {
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000576 slotv = NB_TERNOP(v1->ob_type->tp_as_number,
577 op_slot);
Guido van Rossum84675ac2001-09-29 01:05:03 +0000578 if (slotv)
579 x = slotv(v1, w2, z2);
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000580 else
581 c = -1;
582 }
583 else
584 c = -1;
585
586 Py_DECREF(w2);
587 Py_DECREF(z2);
588 error1:
589 Py_DECREF(v1);
590 Py_DECREF(z1);
591 error2:
Guido van Rossume15dee51995-07-18 14:12:02 +0000592 Py_DECREF(v);
593 Py_DECREF(w);
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000594 error3:
595 if (c >= 0)
Guido van Rossume15dee51995-07-18 14:12:02 +0000596 return x;
597 }
Guido van Rossum5c66a262001-10-22 04:12:44 +0000598
599 if (z == Py_None)
600 PyErr_Format(
601 PyExc_TypeError,
602 "unsupported operand type(s) for ** or pow(): "
603 "'%s' and '%s'",
604 v->ob_type->tp_name,
605 w->ob_type->tp_name);
606 else
607 PyErr_Format(
608 PyExc_TypeError,
609 "unsupported operand type(s) for pow(): "
610 "'%s', '%s', '%s'",
611 v->ob_type->tp_name,
612 w->ob_type->tp_name,
613 z->ob_type->tp_name);
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000614 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +0000615}
616
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000617#define BINARY_FUNC(func, op, op_name) \
618 PyObject * \
619 func(PyObject *v, PyObject *w) { \
620 return binary_op(v, w, NB_SLOT(op), op_name); \
621 }
Guido van Rossume15dee51995-07-18 14:12:02 +0000622
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000623BINARY_FUNC(PyNumber_Or, nb_or, "|")
624BINARY_FUNC(PyNumber_Xor, nb_xor, "^")
625BINARY_FUNC(PyNumber_And, nb_and, "&")
626BINARY_FUNC(PyNumber_Lshift, nb_lshift, "<<")
627BINARY_FUNC(PyNumber_Rshift, nb_rshift, ">>")
628BINARY_FUNC(PyNumber_Subtract, nb_subtract, "-")
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000629BINARY_FUNC(PyNumber_Divide, nb_divide, "/")
630BINARY_FUNC(PyNumber_Divmod, nb_divmod, "divmod()")
Guido van Rossume15dee51995-07-18 14:12:02 +0000631
632PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000633PyNumber_Add(PyObject *v, PyObject *w)
Guido van Rossume15dee51995-07-18 14:12:02 +0000634{
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000635 PyObject *result = binary_op1(v, w, NB_SLOT(nb_add));
636 if (result == Py_NotImplemented) {
637 PySequenceMethods *m = v->ob_type->tp_as_sequence;
Jeremy Hylton0522d982002-03-08 21:28:54 +0000638 if (m && m->sq_concat) {
639 Py_DECREF(result);
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000640 result = (*m->sq_concat)(v, w);
Jeremy Hylton0522d982002-03-08 21:28:54 +0000641 }
Jeremy Hylton6ae6a432002-03-08 21:11:37 +0000642 if (result == Py_NotImplemented) {
Jeremy Hylton0522d982002-03-08 21:28:54 +0000643 Py_DECREF(result);
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000644 return binop_type_error(v, w, "+");
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000645 }
Guido van Rossume15dee51995-07-18 14:12:02 +0000646 }
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000647 return result;
Guido van Rossume15dee51995-07-18 14:12:02 +0000648}
649
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000650static PyObject *
651sequence_repeat(intargfunc repeatfunc, PyObject *seq, PyObject *n)
652{
653 long count;
654 if (PyInt_Check(n)) {
655 count = PyInt_AsLong(n);
656 }
657 else if (PyLong_Check(n)) {
658 count = PyLong_AsLong(n);
659 if (count == -1 && PyErr_Occurred())
660 return NULL;
661 }
662 else {
663 return type_error(
Raymond Hettinger10c66062004-05-12 21:35:06 +0000664 "can't multiply sequence by non-int");
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000665 }
666#if LONG_MAX != INT_MAX
667 if (count > INT_MAX) {
668 PyErr_SetString(PyExc_ValueError,
669 "sequence repeat count too large");
670 return NULL;
671 }
672 else if (count < INT_MIN)
673 count = INT_MIN;
674 /* XXX Why don't I either
675
676 - set count to -1 whenever it's negative (after all,
677 sequence repeat usually treats negative numbers
678 as zero(); or
679
680 - raise an exception when it's less than INT_MIN?
681
682 I'm thinking about a hypothetical use case where some
683 sequence type might use a negative value as a flag of
684 some kind. In those cases I don't want to break the
685 code by mapping all negative values to -1. But I also
686 don't want to break e.g. []*(-sys.maxint), which is
687 perfectly safe, returning []. As a compromise, I do
688 map out-of-range negative values.
689 */
690#endif
691 return (*repeatfunc)(seq, (int)count);
692}
693
694PyObject *
695PyNumber_Multiply(PyObject *v, PyObject *w)
696{
697 PyObject *result = binary_op1(v, w, NB_SLOT(nb_multiply));
698 if (result == Py_NotImplemented) {
699 PySequenceMethods *mv = v->ob_type->tp_as_sequence;
700 PySequenceMethods *mw = w->ob_type->tp_as_sequence;
Guido van Rossuma3a243e2002-12-31 19:50:03 +0000701 Py_DECREF(result);
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000702 if (mv && mv->sq_repeat) {
703 return sequence_repeat(mv->sq_repeat, v, w);
704 }
705 else if (mw && mw->sq_repeat) {
706 return sequence_repeat(mw->sq_repeat, w, v);
707 }
708 result = binop_type_error(v, w, "*");
709 }
710 return result;
711}
712
Guido van Rossume15dee51995-07-18 14:12:02 +0000713PyObject *
Guido van Rossum4668b002001-08-08 05:00:18 +0000714PyNumber_FloorDivide(PyObject *v, PyObject *w)
715{
716 /* XXX tp_flags test */
717 return binary_op(v, w, NB_SLOT(nb_floor_divide), "//");
718}
719
720PyObject *
721PyNumber_TrueDivide(PyObject *v, PyObject *w)
722{
723 /* XXX tp_flags test */
724 return binary_op(v, w, NB_SLOT(nb_true_divide), "/");
725}
726
727PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000728PyNumber_Remainder(PyObject *v, PyObject *w)
Guido van Rossume15dee51995-07-18 14:12:02 +0000729{
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000730 return binary_op(v, w, NB_SLOT(nb_remainder), "%");
Guido van Rossume15dee51995-07-18 14:12:02 +0000731}
732
733PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000734PyNumber_Power(PyObject *v, PyObject *w, PyObject *z)
Guido van Rossume15dee51995-07-18 14:12:02 +0000735{
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000736 return ternary_op(v, w, z, NB_SLOT(nb_power), "** or pow()");
Guido van Rossume15dee51995-07-18 14:12:02 +0000737}
738
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000739/* Binary in-place operators */
740
741/* The in-place operators are defined to fall back to the 'normal',
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000742 non in-place operations, if the in-place methods are not in place.
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000743
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000744 - If the left hand object has the appropriate struct members, and
745 they are filled, call the appropriate function and return the
746 result. No coercion is done on the arguments; the left-hand object
747 is the one the operation is performed on, and it's up to the
748 function to deal with the right-hand object.
Guido van Rossum77660912002-04-16 16:32:50 +0000749
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000750 - Otherwise, in-place modification is not supported. Handle it exactly as
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000751 a non in-place operation of the same kind.
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000752
753 */
754
Guido van Rossum77660912002-04-16 16:32:50 +0000755#define HASINPLACE(t) \
756 PyType_HasFeature((t)->ob_type, Py_TPFLAGS_HAVE_INPLACEOPS)
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000757
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000758static PyObject *
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000759binary_iop1(PyObject *v, PyObject *w, const int iop_slot, const int op_slot)
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000760{
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000761 PyNumberMethods *mv = v->ob_type->tp_as_number;
762 if (mv != NULL && HASINPLACE(v)) {
Neil Schemenauerb808c5c2002-11-24 01:34:49 +0000763 binaryfunc slot = NB_BINOP(mv, iop_slot);
764 if (slot) {
765 PyObject *x = (slot)(v, w);
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000766 if (x != Py_NotImplemented) {
767 return x;
768 }
769 Py_DECREF(x);
770 }
Thomas Woutersf2b332d2000-09-02 08:34:40 +0000771 }
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000772 return binary_op1(v, w, op_slot);
773}
774
775static PyObject *
776binary_iop(PyObject *v, PyObject *w, const int iop_slot, const int op_slot,
777 const char *op_name)
778{
779 PyObject *result = binary_iop1(v, w, iop_slot, op_slot);
780 if (result == Py_NotImplemented) {
781 Py_DECREF(result);
782 return binop_type_error(v, w, op_name);
783 }
784 return result;
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000785}
786
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000787#define INPLACE_BINOP(func, iop, op, op_name) \
788 PyObject * \
789 func(PyObject *v, PyObject *w) { \
790 return binary_iop(v, w, NB_SLOT(iop), NB_SLOT(op), op_name); \
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000791 }
792
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000793INPLACE_BINOP(PyNumber_InPlaceOr, nb_inplace_or, nb_or, "|=")
794INPLACE_BINOP(PyNumber_InPlaceXor, nb_inplace_xor, nb_xor, "^=")
795INPLACE_BINOP(PyNumber_InPlaceAnd, nb_inplace_and, nb_and, "&=")
796INPLACE_BINOP(PyNumber_InPlaceLshift, nb_inplace_lshift, nb_lshift, "<<=")
797INPLACE_BINOP(PyNumber_InPlaceRshift, nb_inplace_rshift, nb_rshift, ">>=")
798INPLACE_BINOP(PyNumber_InPlaceSubtract, nb_inplace_subtract, nb_subtract, "-=")
799INPLACE_BINOP(PyNumber_InPlaceDivide, nb_inplace_divide, nb_divide, "/=")
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000800
801PyObject *
Guido van Rossum4668b002001-08-08 05:00:18 +0000802PyNumber_InPlaceFloorDivide(PyObject *v, PyObject *w)
803{
804 /* XXX tp_flags test */
805 return binary_iop(v, w, NB_SLOT(nb_inplace_floor_divide),
806 NB_SLOT(nb_floor_divide), "//=");
807}
808
809PyObject *
810PyNumber_InPlaceTrueDivide(PyObject *v, PyObject *w)
811{
812 /* XXX tp_flags test */
813 return binary_iop(v, w, NB_SLOT(nb_inplace_true_divide),
814 NB_SLOT(nb_true_divide), "/=");
815}
816
817PyObject *
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000818PyNumber_InPlaceAdd(PyObject *v, PyObject *w)
819{
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000820 PyObject *result = binary_iop1(v, w, NB_SLOT(nb_inplace_add),
821 NB_SLOT(nb_add));
822 if (result == Py_NotImplemented) {
823 PySequenceMethods *m = v->ob_type->tp_as_sequence;
824 Py_DECREF(result);
825 if (m != NULL) {
826 binaryfunc f = NULL;
827 if (HASINPLACE(v))
828 f = m->sq_inplace_concat;
829 if (f == NULL)
830 f = m->sq_concat;
831 if (f != NULL)
832 return (*f)(v, w);
833 }
834 result = binop_type_error(v, w, "+=");
Guido van Rossumbb8be932000-09-01 23:27:32 +0000835 }
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000836 return result;
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000837}
838
839PyObject *
840PyNumber_InPlaceMultiply(PyObject *v, PyObject *w)
841{
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000842 PyObject *result = binary_iop1(v, w, NB_SLOT(nb_inplace_multiply),
843 NB_SLOT(nb_multiply));
844 if (result == Py_NotImplemented) {
845 intargfunc f = NULL;
846 PySequenceMethods *mv = v->ob_type->tp_as_sequence;
847 PySequenceMethods *mw = w->ob_type->tp_as_sequence;
848 Py_DECREF(result);
849 if (mv != NULL) {
850 if (HASINPLACE(v))
851 f = mv->sq_inplace_repeat;
852 if (f == NULL)
853 f = mv->sq_repeat;
854 if (f != NULL)
855 return sequence_repeat(f, v, w);
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000856 }
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000857 else if (mw != NULL) {
858 /* Note that the right hand operand should not be
859 * mutated in this case so sq_inplace_repeat is not
860 * used. */
861 if (mw->sq_repeat)
862 return sequence_repeat(mw->sq_repeat, w, v);
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000863 }
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000864 result = binop_type_error(v, w, "*=");
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000865 }
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000866 return result;
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000867}
868
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000869PyObject *
870PyNumber_InPlaceRemainder(PyObject *v, PyObject *w)
871{
Neil Schemenauerd46fbc32002-11-24 01:07:42 +0000872 return binary_iop(v, w, NB_SLOT(nb_inplace_remainder),
873 NB_SLOT(nb_remainder), "%=");
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000874}
875
876PyObject *
877PyNumber_InPlacePower(PyObject *v, PyObject *w, PyObject *z)
878{
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000879 if (HASINPLACE(v) && v->ob_type->tp_as_number &&
880 v->ob_type->tp_as_number->nb_inplace_power != NULL) {
881 return ternary_op(v, w, z, NB_SLOT(nb_inplace_power), "**=");
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000882 }
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000883 else {
884 return ternary_op(v, w, z, NB_SLOT(nb_power), "**=");
885 }
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000886}
887
888
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000889/* Unary operators and functions */
Guido van Rossume15dee51995-07-18 14:12:02 +0000890
891PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000892PyNumber_Negative(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +0000893{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000894 PyNumberMethods *m;
895
896 if (o == NULL)
897 return null_error();
898 m = o->ob_type->tp_as_number;
899 if (m && m->nb_negative)
900 return (*m->nb_negative)(o);
901
902 return type_error("bad operand type for unary -");
Guido van Rossume15dee51995-07-18 14:12:02 +0000903}
904
905PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000906PyNumber_Positive(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +0000907{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000908 PyNumberMethods *m;
909
910 if (o == NULL)
911 return null_error();
912 m = o->ob_type->tp_as_number;
913 if (m && m->nb_positive)
914 return (*m->nb_positive)(o);
915
916 return type_error("bad operand type for unary +");
Guido van Rossume15dee51995-07-18 14:12:02 +0000917}
918
919PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000920PyNumber_Invert(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +0000921{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000922 PyNumberMethods *m;
923
924 if (o == NULL)
925 return null_error();
926 m = o->ob_type->tp_as_number;
927 if (m && m->nb_invert)
928 return (*m->nb_invert)(o);
929
930 return type_error("bad operand type for unary ~");
Guido van Rossume15dee51995-07-18 14:12:02 +0000931}
932
933PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000934PyNumber_Absolute(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +0000935{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000936 PyNumberMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +0000937
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000938 if (o == NULL)
939 return null_error();
940 m = o->ob_type->tp_as_number;
941 if (m && m->nb_absolute)
942 return m->nb_absolute(o);
Guido van Rossume15dee51995-07-18 14:12:02 +0000943
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000944 return type_error("bad operand type for abs()");
Guido van Rossume15dee51995-07-18 14:12:02 +0000945}
946
Guido van Rossum9e896b32000-04-05 20:11:21 +0000947/* Add a check for embedded NULL-bytes in the argument. */
948static PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000949int_from_string(const char *s, int len)
Guido van Rossum9e896b32000-04-05 20:11:21 +0000950{
951 char *end;
952 PyObject *x;
953
954 x = PyInt_FromString((char*)s, &end, 10);
955 if (x == NULL)
956 return NULL;
957 if (end != s + len) {
958 PyErr_SetString(PyExc_ValueError,
959 "null byte in argument for int()");
960 Py_DECREF(x);
961 return NULL;
962 }
963 return x;
964}
965
Guido van Rossume15dee51995-07-18 14:12:02 +0000966PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000967PyNumber_Int(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +0000968{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000969 PyNumberMethods *m;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000970 const char *buffer;
971 int buffer_len;
Guido van Rossume15dee51995-07-18 14:12:02 +0000972
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000973 if (o == NULL)
974 return null_error();
Tim Peters64b5ce32001-09-10 20:52:51 +0000975 if (PyInt_CheckExact(o)) {
Guido van Rossum9e896b32000-04-05 20:11:21 +0000976 Py_INCREF(o);
977 return o;
978 }
Brett Cannonc3647ac2005-04-26 03:45:26 +0000979 m = o->ob_type->tp_as_number;
980 if (m && m->nb_int) { /* This should include subclasses of int */
981 PyObject *res = m->nb_int(o);
982 if (res && (!PyInt_Check(res) && !PyLong_Check(res))) {
983 PyErr_Format(PyExc_TypeError,
984 "__int__ returned non-int (type %.200s)",
985 res->ob_type->tp_name);
986 Py_DECREF(res);
987 return NULL;
988 }
989 return res;
990 }
991 if (PyInt_Check(o)) { /* A int subclass without nb_int */
Tim Peters64b5ce32001-09-10 20:52:51 +0000992 PyIntObject *io = (PyIntObject*)o;
993 return PyInt_FromLong(io->ob_ival);
994 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000995 if (PyString_Check(o))
Guido van Rossum77660912002-04-16 16:32:50 +0000996 return int_from_string(PyString_AS_STRING(o),
Guido van Rossum9e896b32000-04-05 20:11:21 +0000997 PyString_GET_SIZE(o));
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000998#ifdef Py_USING_UNICODE
Guido van Rossum9e896b32000-04-05 20:11:21 +0000999 if (PyUnicode_Check(o))
1000 return PyInt_FromUnicode(PyUnicode_AS_UNICODE(o),
1001 PyUnicode_GET_SIZE(o),
1002 10);
Martin v. Löwis339d0f72001-08-17 18:39:25 +00001003#endif
Guido van Rossum4c08d552000-03-10 22:55:18 +00001004 if (!PyObject_AsCharBuffer(o, &buffer, &buffer_len))
Guido van Rossum9e896b32000-04-05 20:11:21 +00001005 return int_from_string((char*)buffer, buffer_len);
Guido van Rossume15dee51995-07-18 14:12:02 +00001006
Raymond Hettinger478d47a2002-06-06 15:45:38 +00001007 return type_error("int() argument must be a string or a number");
Guido van Rossume15dee51995-07-18 14:12:02 +00001008}
1009
Guido van Rossum9e896b32000-04-05 20:11:21 +00001010/* Add a check for embedded NULL-bytes in the argument. */
Barry Warsaw226ae6c1999-10-12 19:54:53 +00001011static PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001012long_from_string(const char *s, int len)
Barry Warsaw226ae6c1999-10-12 19:54:53 +00001013{
Guido van Rossum4c08d552000-03-10 22:55:18 +00001014 char *end;
Barry Warsaw226ae6c1999-10-12 19:54:53 +00001015 PyObject *x;
Barry Warsaw226ae6c1999-10-12 19:54:53 +00001016
Guido van Rossum4c08d552000-03-10 22:55:18 +00001017 x = PyLong_FromString((char*)s, &end, 10);
Guido van Rossum9e896b32000-04-05 20:11:21 +00001018 if (x == NULL)
Barry Warsaw226ae6c1999-10-12 19:54:53 +00001019 return NULL;
Guido van Rossum9e896b32000-04-05 20:11:21 +00001020 if (end != s + len) {
Barry Warsaw226ae6c1999-10-12 19:54:53 +00001021 PyErr_SetString(PyExc_ValueError,
1022 "null byte in argument for long()");
Guido van Rossum9e896b32000-04-05 20:11:21 +00001023 Py_DECREF(x);
Barry Warsaw226ae6c1999-10-12 19:54:53 +00001024 return NULL;
1025 }
1026 return x;
1027}
1028
Guido van Rossume15dee51995-07-18 14:12:02 +00001029PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001030PyNumber_Long(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001031{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001032 PyNumberMethods *m;
Guido van Rossum4c08d552000-03-10 22:55:18 +00001033 const char *buffer;
1034 int buffer_len;
Guido van Rossume15dee51995-07-18 14:12:02 +00001035
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001036 if (o == NULL)
1037 return null_error();
Brett Cannonc3647ac2005-04-26 03:45:26 +00001038 m = o->ob_type->tp_as_number;
1039 if (m && m->nb_long) { /* This should include subclasses of long */
1040 PyObject *res = m->nb_long(o);
1041 if (res && (!PyInt_Check(res) && !PyLong_Check(res))) {
1042 PyErr_Format(PyExc_TypeError,
1043 "__long__ returned non-long (type %.200s)",
1044 res->ob_type->tp_name);
1045 Py_DECREF(res);
1046 return NULL;
1047 }
1048 return res;
Guido van Rossum9e896b32000-04-05 20:11:21 +00001049 }
Brett Cannonc3647ac2005-04-26 03:45:26 +00001050 if (PyLong_Check(o)) /* A long subclass without nb_long */
Tim Petersdb30ac42002-03-02 04:14:21 +00001051 return _PyLong_Copy((PyLongObject *)o);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001052 if (PyString_Check(o))
Guido van Rossum77660912002-04-16 16:32:50 +00001053 /* need to do extra error checking that PyLong_FromString()
Barry Warsaw226ae6c1999-10-12 19:54:53 +00001054 * doesn't do. In particular long('9.5') must raise an
1055 * exception, not truncate the float.
1056 */
Guido van Rossum4c08d552000-03-10 22:55:18 +00001057 return long_from_string(PyString_AS_STRING(o),
1058 PyString_GET_SIZE(o));
Martin v. Löwis339d0f72001-08-17 18:39:25 +00001059#ifdef Py_USING_UNICODE
Guido van Rossum9e896b32000-04-05 20:11:21 +00001060 if (PyUnicode_Check(o))
1061 /* The above check is done in PyLong_FromUnicode(). */
1062 return PyLong_FromUnicode(PyUnicode_AS_UNICODE(o),
1063 PyUnicode_GET_SIZE(o),
1064 10);
Martin v. Löwis339d0f72001-08-17 18:39:25 +00001065#endif
Guido van Rossum4c08d552000-03-10 22:55:18 +00001066 if (!PyObject_AsCharBuffer(o, &buffer, &buffer_len))
1067 return long_from_string(buffer, buffer_len);
Guido van Rossume15dee51995-07-18 14:12:02 +00001068
Raymond Hettinger478d47a2002-06-06 15:45:38 +00001069 return type_error("long() argument must be a string or a number");
Guido van Rossume15dee51995-07-18 14:12:02 +00001070}
1071
1072PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001073PyNumber_Float(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001074{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001075 PyNumberMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001076
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001077 if (o == NULL)
1078 return null_error();
Brett Cannonc3647ac2005-04-26 03:45:26 +00001079 m = o->ob_type->tp_as_number;
1080 if (m && m->nb_float) { /* This should include subclasses of float */
1081 PyObject *res = m->nb_float(o);
1082 if (res && !PyFloat_Check(res)) {
1083 PyErr_Format(PyExc_TypeError,
1084 "__float__ returned non-float (type %.200s)",
1085 res->ob_type->tp_name);
1086 Py_DECREF(res);
1087 return NULL;
1088 }
1089 return res;
Guido van Rossum9e896b32000-04-05 20:11:21 +00001090 }
Brett Cannonc3647ac2005-04-26 03:45:26 +00001091 if (PyFloat_Check(o)) { /* A float subclass with nb_float == NULL */
Tim Peters7a50f252001-09-10 21:28:20 +00001092 PyFloatObject *po = (PyFloatObject *)o;
1093 return PyFloat_FromDouble(po->ob_fval);
1094 }
Guido van Rossum4c08d552000-03-10 22:55:18 +00001095 return PyFloat_FromString(o, NULL);
Guido van Rossume15dee51995-07-18 14:12:02 +00001096}
1097
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001098/* Operations on sequences */
Guido van Rossume15dee51995-07-18 14:12:02 +00001099
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001100int
Fred Drake79912472000-07-09 04:06:11 +00001101PySequence_Check(PyObject *s)
Guido van Rossume15dee51995-07-18 14:12:02 +00001102{
Raymond Hettinger1be1a792004-09-19 06:00:15 +00001103 if (s && PyInstance_Check(s))
Raymond Hettingere2eda602004-04-04 08:51:41 +00001104 return PyObject_HasAttrString(s, "__getitem__");
Guido van Rossum8700b422001-09-07 20:20:11 +00001105 return s != NULL && s->ob_type->tp_as_sequence &&
1106 s->ob_type->tp_as_sequence->sq_item != NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +00001107}
1108
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001109int
Jeremy Hylton6253f832000-07-12 12:56:19 +00001110PySequence_Size(PyObject *s)
Guido van Rossume15dee51995-07-18 14:12:02 +00001111{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001112 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001113
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001114 if (s == NULL) {
1115 null_error();
1116 return -1;
1117 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001118
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001119 m = s->ob_type->tp_as_sequence;
1120 if (m && m->sq_length)
1121 return m->sq_length(s);
Guido van Rossume15dee51995-07-18 14:12:02 +00001122
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001123 type_error("len() of unsized object");
1124 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +00001125}
1126
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +00001127#undef PySequence_Length
1128int
1129PySequence_Length(PyObject *s)
1130{
1131 return PySequence_Size(s);
1132}
1133#define PySequence_Length PySequence_Size
1134
Guido van Rossume15dee51995-07-18 14:12:02 +00001135PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001136PySequence_Concat(PyObject *s, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001137{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001138 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001139
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001140 if (s == NULL || o == NULL)
1141 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001142
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001143 m = s->ob_type->tp_as_sequence;
1144 if (m && m->sq_concat)
1145 return m->sq_concat(s, o);
1146
1147 return type_error("object can't be concatenated");
Guido van Rossume15dee51995-07-18 14:12:02 +00001148}
1149
1150PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001151PySequence_Repeat(PyObject *o, int count)
Guido van Rossume15dee51995-07-18 14:12:02 +00001152{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001153 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001154
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001155 if (o == NULL)
1156 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001157
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001158 m = o->ob_type->tp_as_sequence;
1159 if (m && m->sq_repeat)
1160 return m->sq_repeat(o, count);
1161
1162 return type_error("object can't be repeated");
Guido van Rossume15dee51995-07-18 14:12:02 +00001163}
1164
1165PyObject *
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001166PySequence_InPlaceConcat(PyObject *s, PyObject *o)
1167{
1168 PySequenceMethods *m;
1169
1170 if (s == NULL || o == NULL)
1171 return null_error();
1172
1173 m = s->ob_type->tp_as_sequence;
1174 if (m && HASINPLACE(s) && m->sq_inplace_concat)
1175 return m->sq_inplace_concat(s, o);
1176 if (m && m->sq_concat)
1177 return m->sq_concat(s, o);
1178
1179 return type_error("object can't be concatenated");
1180}
1181
1182PyObject *
1183PySequence_InPlaceRepeat(PyObject *o, int count)
1184{
1185 PySequenceMethods *m;
1186
1187 if (o == NULL)
1188 return null_error();
1189
1190 m = o->ob_type->tp_as_sequence;
1191 if (m && HASINPLACE(o) && m->sq_inplace_repeat)
1192 return m->sq_inplace_repeat(o, count);
1193 if (m && m->sq_repeat)
1194 return m->sq_repeat(o, count);
1195
1196 return type_error("object can't be repeated");
1197}
1198
1199PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001200PySequence_GetItem(PyObject *s, int i)
Guido van Rossume15dee51995-07-18 14:12:02 +00001201{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001202 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001203
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001204 if (s == NULL)
1205 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001206
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001207 m = s->ob_type->tp_as_sequence;
1208 if (m && m->sq_item) {
1209 if (i < 0) {
1210 if (m->sq_length) {
1211 int l = (*m->sq_length)(s);
1212 if (l < 0)
1213 return NULL;
1214 i += l;
1215 }
1216 }
1217 return m->sq_item(s, i);
1218 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001219
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001220 return type_error("unindexable object");
Guido van Rossume15dee51995-07-18 14:12:02 +00001221}
1222
Thomas Wouters1d75a792000-08-17 22:37:32 +00001223static PyObject *
1224sliceobj_from_intint(int i, int j)
1225{
1226 PyObject *start, *end, *slice;
1227 start = PyInt_FromLong((long)i);
1228 if (!start)
1229 return NULL;
1230 end = PyInt_FromLong((long)j);
1231 if (!end) {
1232 Py_DECREF(start);
1233 return NULL;
1234 }
1235 slice = PySlice_New(start, end, NULL);
1236 Py_DECREF(start);
1237 Py_DECREF(end);
1238 return slice;
1239}
1240
Guido van Rossume15dee51995-07-18 14:12:02 +00001241PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001242PySequence_GetSlice(PyObject *s, int i1, int i2)
Guido van Rossume15dee51995-07-18 14:12:02 +00001243{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001244 PySequenceMethods *m;
Thomas Wouters1d75a792000-08-17 22:37:32 +00001245 PyMappingMethods *mp;
Guido van Rossume15dee51995-07-18 14:12:02 +00001246
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001247 if (!s) return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001248
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001249 m = s->ob_type->tp_as_sequence;
1250 if (m && m->sq_slice) {
1251 if (i1 < 0 || i2 < 0) {
1252 if (m->sq_length) {
1253 int l = (*m->sq_length)(s);
1254 if (l < 0)
1255 return NULL;
1256 if (i1 < 0)
1257 i1 += l;
1258 if (i2 < 0)
1259 i2 += l;
1260 }
1261 }
1262 return m->sq_slice(s, i1, i2);
Thomas Wouters1d75a792000-08-17 22:37:32 +00001263 } else if ((mp = s->ob_type->tp_as_mapping) && mp->mp_subscript) {
1264 PyObject *res;
1265 PyObject *slice = sliceobj_from_intint(i1, i2);
1266 if (!slice)
1267 return NULL;
1268 res = mp->mp_subscript(s, slice);
1269 Py_DECREF(slice);
1270 return res;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001271 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001272
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001273 return type_error("unsliceable object");
Guido van Rossume15dee51995-07-18 14:12:02 +00001274}
1275
1276int
Fred Drake79912472000-07-09 04:06:11 +00001277PySequence_SetItem(PyObject *s, int i, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001278{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001279 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001280
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001281 if (s == NULL) {
1282 null_error();
1283 return -1;
1284 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001285
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001286 m = s->ob_type->tp_as_sequence;
1287 if (m && m->sq_ass_item) {
1288 if (i < 0) {
1289 if (m->sq_length) {
1290 int l = (*m->sq_length)(s);
1291 if (l < 0)
Guido van Rossumed6219b1998-05-29 02:59:33 +00001292 return -1;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001293 i += l;
1294 }
1295 }
1296 return m->sq_ass_item(s, i, o);
1297 }
1298
Raymond Hettinger98779e02003-10-27 09:22:16 +00001299 type_error("object does not support item assignment");
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001300 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +00001301}
1302
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001303int
Fred Drake79912472000-07-09 04:06:11 +00001304PySequence_DelItem(PyObject *s, int i)
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001305{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001306 PySequenceMethods *m;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001307
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001308 if (s == NULL) {
1309 null_error();
1310 return -1;
1311 }
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001312
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001313 m = s->ob_type->tp_as_sequence;
1314 if (m && m->sq_ass_item) {
1315 if (i < 0) {
1316 if (m->sq_length) {
1317 int l = (*m->sq_length)(s);
1318 if (l < 0)
Guido van Rossumed6219b1998-05-29 02:59:33 +00001319 return -1;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001320 i += l;
1321 }
1322 }
1323 return m->sq_ass_item(s, i, (PyObject *)NULL);
1324 }
1325
1326 type_error("object doesn't support item deletion");
1327 return -1;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001328}
1329
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001330int
Fred Drake79912472000-07-09 04:06:11 +00001331PySequence_SetSlice(PyObject *s, int i1, int i2, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001332{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001333 PySequenceMethods *m;
Thomas Wouters1d75a792000-08-17 22:37:32 +00001334 PyMappingMethods *mp;
Guido van Rossume15dee51995-07-18 14:12:02 +00001335
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001336 if (s == NULL) {
1337 null_error();
1338 return -1;
1339 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001340
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001341 m = s->ob_type->tp_as_sequence;
1342 if (m && m->sq_ass_slice) {
1343 if (i1 < 0 || i2 < 0) {
1344 if (m->sq_length) {
1345 int l = (*m->sq_length)(s);
1346 if (l < 0)
Guido van Rossumed6219b1998-05-29 02:59:33 +00001347 return -1;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001348 if (i1 < 0)
1349 i1 += l;
1350 if (i2 < 0)
1351 i2 += l;
1352 }
1353 }
1354 return m->sq_ass_slice(s, i1, i2, o);
Thomas Wouters1d75a792000-08-17 22:37:32 +00001355 } else if ((mp = s->ob_type->tp_as_mapping) && mp->mp_ass_subscript) {
1356 int res;
1357 PyObject *slice = sliceobj_from_intint(i1, i2);
1358 if (!slice)
1359 return -1;
1360 res = mp->mp_ass_subscript(s, slice, o);
1361 Py_DECREF(slice);
1362 return res;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001363 }
Thomas Wouters1d75a792000-08-17 22:37:32 +00001364
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001365 type_error("object doesn't support slice assignment");
1366 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +00001367}
1368
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001369int
Fred Drake79912472000-07-09 04:06:11 +00001370PySequence_DelSlice(PyObject *s, int i1, int i2)
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001371{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001372 PySequenceMethods *m;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001373
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001374 if (s == NULL) {
1375 null_error();
1376 return -1;
1377 }
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001378
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001379 m = s->ob_type->tp_as_sequence;
1380 if (m && m->sq_ass_slice) {
1381 if (i1 < 0 || i2 < 0) {
1382 if (m->sq_length) {
1383 int l = (*m->sq_length)(s);
1384 if (l < 0)
Guido van Rossumed6219b1998-05-29 02:59:33 +00001385 return -1;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001386 if (i1 < 0)
1387 i1 += l;
1388 if (i2 < 0)
1389 i2 += l;
1390 }
1391 }
1392 return m->sq_ass_slice(s, i1, i2, (PyObject *)NULL);
1393 }
1394 type_error("object doesn't support slice deletion");
1395 return -1;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001396}
1397
Guido van Rossume15dee51995-07-18 14:12:02 +00001398PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001399PySequence_Tuple(PyObject *v)
Guido van Rossume15dee51995-07-18 14:12:02 +00001400{
Tim Peters6912d4d2001-05-05 03:56:37 +00001401 PyObject *it; /* iter(v) */
1402 int n; /* guess for result tuple size */
1403 PyObject *result;
1404 int j;
Guido van Rossume15dee51995-07-18 14:12:02 +00001405
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001406 if (v == NULL)
1407 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001408
Tim Peters6912d4d2001-05-05 03:56:37 +00001409 /* Special-case the common tuple and list cases, for efficiency. */
Tim Peters4c3a0a32001-09-10 23:37:46 +00001410 if (PyTuple_CheckExact(v)) {
1411 /* Note that we can't know whether it's safe to return
1412 a tuple *subclass* instance as-is, hence the restriction
Tim Peters8ff70a92001-09-10 23:53:53 +00001413 to exact tuples here. In contrast, lists always make
1414 a copy, so there's no need for exactness below. */
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001415 Py_INCREF(v);
1416 return v;
Guido van Rossume15dee51995-07-18 14:12:02 +00001417 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001418 if (PyList_Check(v))
1419 return PyList_AsTuple(v);
1420
Tim Peters6912d4d2001-05-05 03:56:37 +00001421 /* Get iterator. */
1422 it = PyObject_GetIter(v);
1423 if (it == NULL)
Tim Peters1fc240e2001-10-26 05:06:50 +00001424 return NULL;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001425
Tim Peters6912d4d2001-05-05 03:56:37 +00001426 /* Guess result size and allocate space. */
Raymond Hettinger6b27cda2005-09-24 21:23:05 +00001427 n = _PyObject_LengthCue(v);
Tim Peters6912d4d2001-05-05 03:56:37 +00001428 if (n < 0) {
Raymond Hettingera710b332005-08-21 11:03:59 +00001429 if (!PyErr_ExceptionMatches(PyExc_TypeError) &&
1430 !PyErr_ExceptionMatches(PyExc_AttributeError)) {
1431 Py_DECREF(it);
1432 return NULL;
1433 }
Tim Peters6912d4d2001-05-05 03:56:37 +00001434 PyErr_Clear();
1435 n = 10; /* arbitrary */
1436 }
1437 result = PyTuple_New(n);
1438 if (result == NULL)
1439 goto Fail;
1440
1441 /* Fill the tuple. */
1442 for (j = 0; ; ++j) {
1443 PyObject *item = PyIter_Next(it);
1444 if (item == NULL) {
1445 if (PyErr_Occurred())
1446 goto Fail;
1447 break;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001448 }
Tim Peters6912d4d2001-05-05 03:56:37 +00001449 if (j >= n) {
Raymond Hettinger4d012592004-12-16 10:38:38 +00001450 int oldn = n;
1451 /* The over-allocation strategy can grow a bit faster
1452 than for lists because unlike lists the
1453 over-allocation isn't permanent -- we reclaim
1454 the excess before the end of this routine.
1455 So, grow by ten and then add 25%.
1456 */
1457 n += 10;
1458 n += n >> 2;
1459 if (n < oldn) {
1460 /* Check for overflow */
1461 PyErr_NoMemory();
Raymond Hettingere6bdb372004-12-16 15:10:21 +00001462 Py_DECREF(item);
Raymond Hettinger4d012592004-12-16 10:38:38 +00001463 goto Fail;
1464 }
Tim Peters4324aa32001-05-28 22:30:08 +00001465 if (_PyTuple_Resize(&result, n) != 0) {
Tim Peters12d0a6c2001-05-05 04:10:25 +00001466 Py_DECREF(item);
Tim Peters6912d4d2001-05-05 03:56:37 +00001467 goto Fail;
Tim Peters12d0a6c2001-05-05 04:10:25 +00001468 }
Tim Peters6912d4d2001-05-05 03:56:37 +00001469 }
1470 PyTuple_SET_ITEM(result, j, item);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001471 }
1472
Tim Peters6912d4d2001-05-05 03:56:37 +00001473 /* Cut tuple back if guess was too large. */
1474 if (j < n &&
Tim Peters4324aa32001-05-28 22:30:08 +00001475 _PyTuple_Resize(&result, j) != 0)
Tim Peters6912d4d2001-05-05 03:56:37 +00001476 goto Fail;
1477
1478 Py_DECREF(it);
1479 return result;
1480
1481Fail:
1482 Py_XDECREF(result);
1483 Py_DECREF(it);
1484 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +00001485}
1486
Guido van Rossum3c5936a1996-12-05 21:51:24 +00001487PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001488PySequence_List(PyObject *v)
Guido van Rossum3c5936a1996-12-05 21:51:24 +00001489{
Tim Petersf553f892001-05-01 20:45:31 +00001490 PyObject *result; /* result list */
Raymond Hettinger8ca92ae2004-03-11 09:13:12 +00001491 PyObject *rv; /* return value from PyList_Extend */
Guido van Rossum4669fb41997-04-02 05:31:09 +00001492
Guido van Rossum5dba9e81998-07-10 18:03:50 +00001493 if (v == NULL)
1494 return null_error();
1495
Raymond Hettinger8ca92ae2004-03-11 09:13:12 +00001496 result = PyList_New(0);
1497 if (result == NULL)
Tim Petersf553f892001-05-01 20:45:31 +00001498 return NULL;
1499
Raymond Hettinger8ca92ae2004-03-11 09:13:12 +00001500 rv = _PyList_Extend((PyListObject *)result, v);
1501 if (rv == NULL) {
1502 Py_DECREF(result);
Tim Petersf553f892001-05-01 20:45:31 +00001503 return NULL;
1504 }
Raymond Hettinger969d8c02004-03-17 05:24:23 +00001505 Py_DECREF(rv);
Tim Petersf553f892001-05-01 20:45:31 +00001506 return result;
Guido van Rossum3c5936a1996-12-05 21:51:24 +00001507}
1508
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001509PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001510PySequence_Fast(PyObject *v, const char *m)
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001511{
Raymond Hettinger2fb70292004-01-11 23:26:51 +00001512 PyObject *it;
1513
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001514 if (v == NULL)
1515 return null_error();
1516
Michael W. Hudson2801fe12002-11-05 18:05:49 +00001517 if (PyList_CheckExact(v) || PyTuple_CheckExact(v)) {
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001518 Py_INCREF(v);
1519 return v;
1520 }
1521
Raymond Hettinger2fb70292004-01-11 23:26:51 +00001522 it = PyObject_GetIter(v);
1523 if (it == NULL) {
1524 if (PyErr_ExceptionMatches(PyExc_TypeError))
1525 return type_error(m);
1526 return NULL;
1527 }
1528
Raymond Hettinger193814c2004-12-18 19:00:59 +00001529 v = PySequence_List(it);
Raymond Hettinger2fb70292004-01-11 23:26:51 +00001530 Py_DECREF(it);
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001531
1532 return v;
1533}
1534
Tim Peters16a77ad2001-09-08 04:00:12 +00001535/* Iterate over seq. Result depends on the operation:
1536 PY_ITERSEARCH_COUNT: -1 if error, else # of times obj appears in seq.
1537 PY_ITERSEARCH_INDEX: 0-based index of first occurence of obj in seq;
1538 set ValueError and return -1 if none found; also return -1 on error.
1539 Py_ITERSEARCH_CONTAINS: return 1 if obj in seq, else 0; -1 on error.
1540*/
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001541int
Tim Peters16a77ad2001-09-08 04:00:12 +00001542_PySequence_IterSearch(PyObject *seq, PyObject *obj, int operation)
Guido van Rossume15dee51995-07-18 14:12:02 +00001543{
Tim Peters16a77ad2001-09-08 04:00:12 +00001544 int n;
1545 int wrapped; /* for PY_ITERSEARCH_INDEX, true iff n wrapped around */
1546 PyObject *it; /* iter(seq) */
Guido van Rossume15dee51995-07-18 14:12:02 +00001547
Tim Peters16a77ad2001-09-08 04:00:12 +00001548 if (seq == NULL || obj == NULL) {
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001549 null_error();
1550 return -1;
1551 }
Tim Peters75f8e352001-05-05 11:33:43 +00001552
Tim Peters16a77ad2001-09-08 04:00:12 +00001553 it = PyObject_GetIter(seq);
Tim Peters75f8e352001-05-05 11:33:43 +00001554 if (it == NULL) {
Tim Peters16a77ad2001-09-08 04:00:12 +00001555 type_error("iterable argument required");
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001556 return -1;
Tim Peters75f8e352001-05-05 11:33:43 +00001557 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001558
Tim Peters16a77ad2001-09-08 04:00:12 +00001559 n = wrapped = 0;
Tim Peters75f8e352001-05-05 11:33:43 +00001560 for (;;) {
1561 int cmp;
1562 PyObject *item = PyIter_Next(it);
1563 if (item == NULL) {
1564 if (PyErr_Occurred())
1565 goto Fail;
1566 break;
1567 }
Tim Peters16a77ad2001-09-08 04:00:12 +00001568
1569 cmp = PyObject_RichCompareBool(obj, item, Py_EQ);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001570 Py_DECREF(item);
Tim Peters75f8e352001-05-05 11:33:43 +00001571 if (cmp < 0)
1572 goto Fail;
1573 if (cmp > 0) {
Tim Peters16a77ad2001-09-08 04:00:12 +00001574 switch (operation) {
1575 case PY_ITERSEARCH_COUNT:
1576 ++n;
1577 if (n <= 0) {
1578 PyErr_SetString(PyExc_OverflowError,
Tim Peters75f8e352001-05-05 11:33:43 +00001579 "count exceeds C int size");
Tim Peters16a77ad2001-09-08 04:00:12 +00001580 goto Fail;
1581 }
1582 break;
1583
1584 case PY_ITERSEARCH_INDEX:
1585 if (wrapped) {
1586 PyErr_SetString(PyExc_OverflowError,
1587 "index exceeds C int size");
1588 goto Fail;
1589 }
1590 goto Done;
1591
1592 case PY_ITERSEARCH_CONTAINS:
1593 n = 1;
1594 goto Done;
1595
1596 default:
1597 assert(!"unknown operation");
Tim Peters75f8e352001-05-05 11:33:43 +00001598 }
Tim Peters16a77ad2001-09-08 04:00:12 +00001599 }
1600
1601 if (operation == PY_ITERSEARCH_INDEX) {
1602 ++n;
1603 if (n <= 0)
1604 wrapped = 1;
Tim Peters75f8e352001-05-05 11:33:43 +00001605 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001606 }
Tim Peters16a77ad2001-09-08 04:00:12 +00001607
1608 if (operation != PY_ITERSEARCH_INDEX)
1609 goto Done;
1610
1611 PyErr_SetString(PyExc_ValueError,
1612 "sequence.index(x): x not in sequence");
1613 /* fall into failure code */
1614Fail:
1615 n = -1;
1616 /* fall through */
1617Done:
Tim Peters75f8e352001-05-05 11:33:43 +00001618 Py_DECREF(it);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001619 return n;
Tim Peters75f8e352001-05-05 11:33:43 +00001620
Guido van Rossume15dee51995-07-18 14:12:02 +00001621}
1622
Tim Peters16a77ad2001-09-08 04:00:12 +00001623/* Return # of times o appears in s. */
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001624int
Tim Peters16a77ad2001-09-08 04:00:12 +00001625PySequence_Count(PyObject *s, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001626{
Tim Peters16a77ad2001-09-08 04:00:12 +00001627 return _PySequence_IterSearch(s, o, PY_ITERSEARCH_COUNT);
Guido van Rossume15dee51995-07-18 14:12:02 +00001628}
1629
Tim Peterscb8d3682001-05-05 21:05:01 +00001630/* Return -1 if error; 1 if ob in seq; 0 if ob not in seq.
Tim Peters16a77ad2001-09-08 04:00:12 +00001631 * Use sq_contains if possible, else defer to _PySequence_IterSearch().
Tim Peterscb8d3682001-05-05 21:05:01 +00001632 */
1633int
1634PySequence_Contains(PyObject *seq, PyObject *ob)
1635{
1636 if (PyType_HasFeature(seq->ob_type, Py_TPFLAGS_HAVE_SEQUENCE_IN)) {
1637 PySequenceMethods *sqm = seq->ob_type->tp_as_sequence;
1638 if (sqm != NULL && sqm->sq_contains != NULL)
1639 return (*sqm->sq_contains)(seq, ob);
1640 }
Tim Peters16a77ad2001-09-08 04:00:12 +00001641 return _PySequence_IterSearch(seq, ob, PY_ITERSEARCH_CONTAINS);
Tim Peterscb8d3682001-05-05 21:05:01 +00001642}
1643
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001644/* Backwards compatibility */
1645#undef PySequence_In
1646int
Fred Drake79912472000-07-09 04:06:11 +00001647PySequence_In(PyObject *w, PyObject *v)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001648{
1649 return PySequence_Contains(w, v);
1650}
1651
1652int
Fred Drake79912472000-07-09 04:06:11 +00001653PySequence_Index(PyObject *s, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001654{
Tim Peters16a77ad2001-09-08 04:00:12 +00001655 return _PySequence_IterSearch(s, o, PY_ITERSEARCH_INDEX);
Guido van Rossume15dee51995-07-18 14:12:02 +00001656}
1657
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001658/* Operations on mappings */
1659
1660int
Fred Drake79912472000-07-09 04:06:11 +00001661PyMapping_Check(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001662{
Raymond Hettinger1be1a792004-09-19 06:00:15 +00001663 if (o && PyInstance_Check(o))
Raymond Hettingere2eda602004-04-04 08:51:41 +00001664 return PyObject_HasAttrString(o, "__getitem__");
1665
1666 return o && o->ob_type->tp_as_mapping &&
1667 o->ob_type->tp_as_mapping->mp_subscript &&
Raymond Hettingered9192e2004-04-05 08:14:48 +00001668 !(o->ob_type->tp_as_sequence &&
1669 o->ob_type->tp_as_sequence->sq_slice);
Guido van Rossume15dee51995-07-18 14:12:02 +00001670}
1671
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001672int
Jeremy Hylton6253f832000-07-12 12:56:19 +00001673PyMapping_Size(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001674{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001675 PyMappingMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001676
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001677 if (o == NULL) {
1678 null_error();
1679 return -1;
1680 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001681
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001682 m = o->ob_type->tp_as_mapping;
1683 if (m && m->mp_length)
1684 return m->mp_length(o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001685
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001686 type_error("len() of unsized object");
1687 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +00001688}
1689
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +00001690#undef PyMapping_Length
1691int
1692PyMapping_Length(PyObject *o)
1693{
1694 return PyMapping_Size(o);
1695}
1696#define PyMapping_Length PyMapping_Size
1697
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001698PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001699PyMapping_GetItemString(PyObject *o, char *key)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001700{
1701 PyObject *okey, *r;
1702
1703 if (key == NULL)
1704 return null_error();
1705
1706 okey = PyString_FromString(key);
1707 if (okey == NULL)
1708 return NULL;
1709 r = PyObject_GetItem(o, okey);
1710 Py_DECREF(okey);
1711 return r;
1712}
1713
1714int
Fred Drake79912472000-07-09 04:06:11 +00001715PyMapping_SetItemString(PyObject *o, char *key, PyObject *value)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001716{
1717 PyObject *okey;
1718 int r;
1719
1720 if (key == NULL) {
1721 null_error();
1722 return -1;
1723 }
1724
1725 okey = PyString_FromString(key);
1726 if (okey == NULL)
Guido van Rossumed6219b1998-05-29 02:59:33 +00001727 return -1;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001728 r = PyObject_SetItem(o, okey, value);
1729 Py_DECREF(okey);
1730 return r;
1731}
1732
1733int
Fred Drake79912472000-07-09 04:06:11 +00001734PyMapping_HasKeyString(PyObject *o, char *key)
Guido van Rossume15dee51995-07-18 14:12:02 +00001735{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001736 PyObject *v;
Guido van Rossume15dee51995-07-18 14:12:02 +00001737
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001738 v = PyMapping_GetItemString(o, key);
1739 if (v) {
1740 Py_DECREF(v);
1741 return 1;
1742 }
1743 PyErr_Clear();
1744 return 0;
Guido van Rossume15dee51995-07-18 14:12:02 +00001745}
1746
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001747int
Fred Drake79912472000-07-09 04:06:11 +00001748PyMapping_HasKey(PyObject *o, PyObject *key)
Guido van Rossume15dee51995-07-18 14:12:02 +00001749{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001750 PyObject *v;
Guido van Rossume15dee51995-07-18 14:12:02 +00001751
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001752 v = PyObject_GetItem(o, key);
1753 if (v) {
1754 Py_DECREF(v);
1755 return 1;
1756 }
1757 PyErr_Clear();
1758 return 0;
Guido van Rossume15dee51995-07-18 14:12:02 +00001759}
1760
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001761/* Operations on callable objects */
1762
1763/* XXX PyCallable_Check() is in object.c */
1764
Guido van Rossume15dee51995-07-18 14:12:02 +00001765PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001766PyObject_CallObject(PyObject *o, PyObject *a)
Guido van Rossume15dee51995-07-18 14:12:02 +00001767{
Guido van Rossum5560b742001-09-14 16:47:50 +00001768 return PyEval_CallObjectWithKeywords(o, a, NULL);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001769}
Guido van Rossume15dee51995-07-18 14:12:02 +00001770
1771PyObject *
Tim Peters6d6c1a32001-08-02 04:15:00 +00001772PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw)
1773{
1774 ternaryfunc call;
1775
1776 if ((call = func->ob_type->tp_call) != NULL) {
1777 PyObject *result = (*call)(func, arg, kw);
1778 if (result == NULL && !PyErr_Occurred())
1779 PyErr_SetString(
1780 PyExc_SystemError,
1781 "NULL result without error in PyObject_Call");
1782 return result;
1783 }
Fred Drake573395a2001-11-01 20:26:12 +00001784 PyErr_Format(PyExc_TypeError, "'%s' object is not callable",
1785 func->ob_type->tp_name);
Tim Peters6d6c1a32001-08-02 04:15:00 +00001786 return NULL;
1787}
1788
1789PyObject *
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001790PyObject_CallFunction(PyObject *callable, char *format, ...)
Guido van Rossume15dee51995-07-18 14:12:02 +00001791{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001792 va_list va;
1793 PyObject *args, *retval;
Guido van Rossume15dee51995-07-18 14:12:02 +00001794
Fred Drakeb92cf062001-10-27 06:16:31 +00001795 if (callable == NULL)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001796 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001797
Fred Drakeb92cf062001-10-27 06:16:31 +00001798 if (format && *format) {
1799 va_start(va, format);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001800 args = Py_VaBuildValue(format, va);
Fred Drakeb92cf062001-10-27 06:16:31 +00001801 va_end(va);
1802 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001803 else
1804 args = PyTuple_New(0);
Guido van Rossume15dee51995-07-18 14:12:02 +00001805
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001806 if (args == NULL)
1807 return NULL;
1808
1809 if (!PyTuple_Check(args)) {
1810 PyObject *a;
1811
1812 a = PyTuple_New(1);
1813 if (a == NULL)
1814 return NULL;
1815 if (PyTuple_SetItem(a, 0, args) < 0)
1816 return NULL;
1817 args = a;
1818 }
Guido van Rossum84b2bed2002-08-16 17:01:09 +00001819 retval = PyObject_Call(callable, args, NULL);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001820
1821 Py_DECREF(args);
1822
1823 return retval;
Guido van Rossume15dee51995-07-18 14:12:02 +00001824}
1825
1826PyObject *
Guido van Rossume15dee51995-07-18 14:12:02 +00001827PyObject_CallMethod(PyObject *o, char *name, char *format, ...)
Guido van Rossume15dee51995-07-18 14:12:02 +00001828{
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001829 va_list va;
Michael W. Hudson0edc7a02005-07-12 10:21:19 +00001830 PyObject *args = NULL;
1831 PyObject *func = NULL;
1832 PyObject *retval = NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +00001833
Fred Drakeb92cf062001-10-27 06:16:31 +00001834 if (o == NULL || name == NULL)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001835 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001836
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001837 func = PyObject_GetAttrString(o, name);
1838 if (func == NULL) {
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001839 PyErr_SetString(PyExc_AttributeError, name);
1840 return 0;
1841 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001842
Michael W. Hudson0edc7a02005-07-12 10:21:19 +00001843 if (!PyCallable_Check(func)) {
1844 type_error("call of non-callable attribute");
1845 goto exit;
1846 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001847
Fred Drakeb92cf062001-10-27 06:16:31 +00001848 if (format && *format) {
1849 va_start(va, format);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001850 args = Py_VaBuildValue(format, va);
Fred Drakeb92cf062001-10-27 06:16:31 +00001851 va_end(va);
1852 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001853 else
1854 args = PyTuple_New(0);
Guido van Rossume15dee51995-07-18 14:12:02 +00001855
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001856 if (!args)
Michael W. Hudson0edc7a02005-07-12 10:21:19 +00001857 goto exit;
Guido van Rossume15dee51995-07-18 14:12:02 +00001858
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001859 if (!PyTuple_Check(args)) {
1860 PyObject *a;
Guido van Rossume15dee51995-07-18 14:12:02 +00001861
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001862 a = PyTuple_New(1);
1863 if (a == NULL)
Michael W. Hudson0edc7a02005-07-12 10:21:19 +00001864 goto exit;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001865 if (PyTuple_SetItem(a, 0, args) < 0)
Michael W. Hudson0edc7a02005-07-12 10:21:19 +00001866 goto exit;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001867 args = a;
1868 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001869
Guido van Rossum84b2bed2002-08-16 17:01:09 +00001870 retval = PyObject_Call(func, args, NULL);
Guido van Rossume15dee51995-07-18 14:12:02 +00001871
Michael W. Hudson0edc7a02005-07-12 10:21:19 +00001872 exit:
1873 Py_XDECREF(args);
1874 Py_XDECREF(func);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001875
1876 return retval;
Guido van Rossume15dee51995-07-18 14:12:02 +00001877}
Guido van Rossum823649d2001-03-21 18:40:58 +00001878
1879
Fred Drakeb421b8c2001-10-26 16:21:32 +00001880static PyObject *
Fred Drakeb0c079e2001-10-28 02:39:03 +00001881objargs_mktuple(va_list va)
Fred Drakeb421b8c2001-10-26 16:21:32 +00001882{
1883 int i, n = 0;
1884 va_list countva;
1885 PyObject *result, *tmp;
1886
1887#ifdef VA_LIST_IS_ARRAY
1888 memcpy(countva, va, sizeof(va_list));
1889#else
Martin v. Löwis75d2d942002-07-28 10:23:27 +00001890#ifdef __va_copy
1891 __va_copy(countva, va);
1892#else
Fred Drakeb421b8c2001-10-26 16:21:32 +00001893 countva = va;
1894#endif
Martin v. Löwis75d2d942002-07-28 10:23:27 +00001895#endif
Fred Drakeb421b8c2001-10-26 16:21:32 +00001896
1897 while (((PyObject *)va_arg(countva, PyObject *)) != NULL)
1898 ++n;
1899 result = PyTuple_New(n);
1900 if (result != NULL && n > 0) {
1901 for (i = 0; i < n; ++i) {
1902 tmp = (PyObject *)va_arg(va, PyObject *);
1903 PyTuple_SET_ITEM(result, i, tmp);
1904 Py_INCREF(tmp);
1905 }
1906 }
1907 return result;
1908}
1909
1910PyObject *
Fred Drakeb0c079e2001-10-28 02:39:03 +00001911PyObject_CallMethodObjArgs(PyObject *callable, PyObject *name, ...)
Fred Drakeb421b8c2001-10-26 16:21:32 +00001912{
1913 PyObject *args, *tmp;
1914 va_list vargs;
1915
1916 if (callable == NULL || name == NULL)
1917 return null_error();
1918
1919 callable = PyObject_GetAttr(callable, name);
1920 if (callable == NULL)
1921 return NULL;
1922
1923 /* count the args */
1924 va_start(vargs, name);
Fred Drakeb0c079e2001-10-28 02:39:03 +00001925 args = objargs_mktuple(vargs);
Fred Drakeb421b8c2001-10-26 16:21:32 +00001926 va_end(vargs);
1927 if (args == NULL) {
1928 Py_DECREF(callable);
1929 return NULL;
1930 }
1931 tmp = PyObject_Call(callable, args, NULL);
1932 Py_DECREF(args);
1933 Py_DECREF(callable);
1934
1935 return tmp;
1936}
1937
1938PyObject *
Fred Drakeb0c079e2001-10-28 02:39:03 +00001939PyObject_CallFunctionObjArgs(PyObject *callable, ...)
Fred Drakeb421b8c2001-10-26 16:21:32 +00001940{
1941 PyObject *args, *tmp;
1942 va_list vargs;
1943
1944 if (callable == NULL)
1945 return null_error();
1946
1947 /* count the args */
1948 va_start(vargs, callable);
Fred Drakeb0c079e2001-10-28 02:39:03 +00001949 args = objargs_mktuple(vargs);
Fred Drakeb421b8c2001-10-26 16:21:32 +00001950 va_end(vargs);
1951 if (args == NULL)
1952 return NULL;
1953 tmp = PyObject_Call(callable, args, NULL);
1954 Py_DECREF(args);
1955
1956 return tmp;
1957}
1958
1959
Guido van Rossum823649d2001-03-21 18:40:58 +00001960/* isinstance(), issubclass() */
1961
Barry Warsawf16951c2002-04-23 22:45:44 +00001962/* abstract_get_bases() has logically 4 return states, with a sort of 0th
1963 * state that will almost never happen.
1964 *
1965 * 0. creating the __bases__ static string could get a MemoryError
1966 * 1. getattr(cls, '__bases__') could raise an AttributeError
1967 * 2. getattr(cls, '__bases__') could raise some other exception
1968 * 3. getattr(cls, '__bases__') could return a tuple
1969 * 4. getattr(cls, '__bases__') could return something other than a tuple
1970 *
1971 * Only state #3 is a non-error state and only it returns a non-NULL object
1972 * (it returns the retrieved tuple).
1973 *
1974 * Any raised AttributeErrors are masked by clearing the exception and
1975 * returning NULL. If an object other than a tuple comes out of __bases__,
1976 * then again, the return value is NULL. So yes, these two situations
1977 * produce exactly the same results: NULL is returned and no error is set.
1978 *
1979 * If some exception other than AttributeError is raised, then NULL is also
1980 * returned, but the exception is not cleared. That's because we want the
1981 * exception to be propagated along.
1982 *
1983 * Callers are expected to test for PyErr_Occurred() when the return value
1984 * is NULL to decide whether a valid exception should be propagated or not.
1985 * When there's no exception to propagate, it's customary for the caller to
1986 * set a TypeError.
1987 */
Neil Schemenauer6b471292001-10-18 03:18:43 +00001988static PyObject *
1989abstract_get_bases(PyObject *cls)
Guido van Rossum823649d2001-03-21 18:40:58 +00001990{
1991 static PyObject *__bases__ = NULL;
1992 PyObject *bases;
Guido van Rossum823649d2001-03-21 18:40:58 +00001993
1994 if (__bases__ == NULL) {
1995 __bases__ = PyString_FromString("__bases__");
1996 if (__bases__ == NULL)
Neil Schemenauer6b471292001-10-18 03:18:43 +00001997 return NULL;
Guido van Rossum823649d2001-03-21 18:40:58 +00001998 }
Neil Schemenauer6b471292001-10-18 03:18:43 +00001999 bases = PyObject_GetAttr(cls, __bases__);
Barry Warsawf16951c2002-04-23 22:45:44 +00002000 if (bases == NULL) {
2001 if (PyErr_ExceptionMatches(PyExc_AttributeError))
2002 PyErr_Clear();
Neil Schemenauer6b471292001-10-18 03:18:43 +00002003 return NULL;
Guido van Rossum823649d2001-03-21 18:40:58 +00002004 }
Barry Warsawf16951c2002-04-23 22:45:44 +00002005 if (!PyTuple_Check(bases)) {
2006 Py_DECREF(bases);
2007 return NULL;
2008 }
Neil Schemenauer6b471292001-10-18 03:18:43 +00002009 return bases;
2010}
2011
2012
2013static int
2014abstract_issubclass(PyObject *derived, PyObject *cls)
2015{
2016 PyObject *bases;
2017 int i, n;
2018 int r = 0;
2019
2020
Guido van Rossum823649d2001-03-21 18:40:58 +00002021 if (derived == cls)
2022 return 1;
2023
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00002024 if (PyTuple_Check(cls)) {
2025 /* Not a general sequence -- that opens up the road to
2026 recursion and stack overflow. */
2027 n = PyTuple_GET_SIZE(cls);
2028 for (i = 0; i < n; i++) {
2029 if (derived == PyTuple_GET_ITEM(cls, i))
2030 return 1;
2031 }
2032 }
Neil Schemenauer6b471292001-10-18 03:18:43 +00002033 bases = abstract_get_bases(derived);
Barry Warsawf16951c2002-04-23 22:45:44 +00002034 if (bases == NULL) {
2035 if (PyErr_Occurred())
2036 return -1;
Neil Schemenauer6b471292001-10-18 03:18:43 +00002037 return 0;
Barry Warsawf16951c2002-04-23 22:45:44 +00002038 }
Guido van Rossum823649d2001-03-21 18:40:58 +00002039 n = PyTuple_GET_SIZE(bases);
2040 for (i = 0; i < n; i++) {
Neil Schemenauer6b471292001-10-18 03:18:43 +00002041 r = abstract_issubclass(PyTuple_GET_ITEM(bases, i), cls);
Guido van Rossum823649d2001-03-21 18:40:58 +00002042 if (r != 0)
2043 break;
2044 }
2045
2046 Py_DECREF(bases);
2047
2048 return r;
2049}
2050
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00002051static int
2052check_class(PyObject *cls, const char *error)
2053{
2054 PyObject *bases = abstract_get_bases(cls);
2055 if (bases == NULL) {
2056 /* Do not mask errors. */
2057 if (!PyErr_Occurred())
2058 PyErr_SetString(PyExc_TypeError, error);
2059 return 0;
2060 }
2061 Py_DECREF(bases);
2062 return -1;
2063}
2064
Brett Cannon4f653312004-03-20 22:52:14 +00002065static int
2066recursive_isinstance(PyObject *inst, PyObject *cls, int recursion_depth)
Guido van Rossum823649d2001-03-21 18:40:58 +00002067{
2068 PyObject *icls;
2069 static PyObject *__class__ = NULL;
2070 int retval = 0;
2071
Guido van Rossum03bc7d32003-02-12 03:32:58 +00002072 if (__class__ == NULL) {
2073 __class__ = PyString_FromString("__class__");
2074 if (__class__ == NULL)
2075 return -1;
2076 }
2077
Neil Schemenauer6b471292001-10-18 03:18:43 +00002078 if (PyClass_Check(cls) && PyInstance_Check(inst)) {
2079 PyObject *inclass =
2080 (PyObject*)((PyInstanceObject*)inst)->in_class;
2081 retval = PyClass_IsSubclass(inclass, cls);
Guido van Rossum823649d2001-03-21 18:40:58 +00002082 }
2083 else if (PyType_Check(cls)) {
Tim Peters6d6c1a32001-08-02 04:15:00 +00002084 retval = PyObject_TypeCheck(inst, (PyTypeObject *)cls);
Guido van Rossum03bc7d32003-02-12 03:32:58 +00002085 if (retval == 0) {
2086 PyObject *c = PyObject_GetAttr(inst, __class__);
2087 if (c == NULL) {
2088 PyErr_Clear();
2089 }
2090 else {
Guido van Rossume5b130b2003-02-12 03:36:05 +00002091 if (c != (PyObject *)(inst->ob_type) &&
2092 PyType_Check(c))
Guido van Rossum03bc7d32003-02-12 03:32:58 +00002093 retval = PyType_IsSubtype(
2094 (PyTypeObject *)c,
2095 (PyTypeObject *)cls);
2096 Py_DECREF(c);
2097 }
2098 }
Guido van Rossum823649d2001-03-21 18:40:58 +00002099 }
Guido van Rossum03290ec2001-10-07 20:54:12 +00002100 else if (PyTuple_Check(cls)) {
Guido van Rossum03290ec2001-10-07 20:54:12 +00002101 int i, n;
2102
Brett Cannon4f653312004-03-20 22:52:14 +00002103 if (!recursion_depth) {
2104 PyErr_SetString(PyExc_RuntimeError,
2105 "nest level of tuple too deep");
Tim Peters5f112eb2004-03-21 16:59:09 +00002106 return -1;
Brett Cannon4f653312004-03-20 22:52:14 +00002107 }
2108
Guido van Rossum03290ec2001-10-07 20:54:12 +00002109 n = PyTuple_GET_SIZE(cls);
2110 for (i = 0; i < n; i++) {
Brett Cannon4f653312004-03-20 22:52:14 +00002111 retval = recursive_isinstance(
2112 inst,
2113 PyTuple_GET_ITEM(cls, i),
2114 recursion_depth-1);
Guido van Rossum03290ec2001-10-07 20:54:12 +00002115 if (retval != 0)
2116 break;
2117 }
Guido van Rossum03290ec2001-10-07 20:54:12 +00002118 }
Neil Schemenauer6b471292001-10-18 03:18:43 +00002119 else {
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00002120 if (!check_class(cls,
2121 "isinstance() arg 2 must be a class, type,"
2122 " or tuple of classes and types"))
Neil Schemenauer6b471292001-10-18 03:18:43 +00002123 return -1;
Guido van Rossum823649d2001-03-21 18:40:58 +00002124 icls = PyObject_GetAttr(inst, __class__);
Neil Schemenauer6b471292001-10-18 03:18:43 +00002125 if (icls == NULL) {
2126 PyErr_Clear();
2127 retval = 0;
Guido van Rossum823649d2001-03-21 18:40:58 +00002128 }
Neil Schemenauer6b471292001-10-18 03:18:43 +00002129 else {
2130 retval = abstract_issubclass(icls, cls);
2131 Py_DECREF(icls);
2132 }
Guido van Rossum823649d2001-03-21 18:40:58 +00002133 }
Guido van Rossum823649d2001-03-21 18:40:58 +00002134
Guido van Rossum823649d2001-03-21 18:40:58 +00002135 return retval;
2136}
2137
2138int
Brett Cannon4f653312004-03-20 22:52:14 +00002139PyObject_IsInstance(PyObject *inst, PyObject *cls)
2140{
2141 return recursive_isinstance(inst, cls, Py_GetRecursionLimit());
2142}
2143
2144static int
2145recursive_issubclass(PyObject *derived, PyObject *cls, int recursion_depth)
Guido van Rossum823649d2001-03-21 18:40:58 +00002146{
2147 int retval;
2148
2149 if (!PyClass_Check(derived) || !PyClass_Check(cls)) {
Guido van Rossumf6c9ba82003-02-10 16:05:43 +00002150 if (!check_class(derived,
2151 "issubclass() arg 1 must be a class"))
Neil Schemenauer6b471292001-10-18 03:18:43 +00002152 return -1;
Neil Schemenauer6b471292001-10-18 03:18:43 +00002153
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00002154 if (PyTuple_Check(cls)) {
2155 int i;
2156 int n = PyTuple_GET_SIZE(cls);
Brett Cannon4f653312004-03-20 22:52:14 +00002157
2158 if (!recursion_depth) {
2159 PyErr_SetString(PyExc_RuntimeError,
2160 "nest level of tuple too deep");
Tim Peters5f112eb2004-03-21 16:59:09 +00002161 return -1;
Brett Cannon4f653312004-03-20 22:52:14 +00002162 }
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00002163 for (i = 0; i < n; ++i) {
Brett Cannon4f653312004-03-20 22:52:14 +00002164 retval = recursive_issubclass(
2165 derived,
2166 PyTuple_GET_ITEM(cls, i),
2167 recursion_depth-1);
Guido van Rossumf6c9ba82003-02-10 16:05:43 +00002168 if (retval != 0) {
2169 /* either found it, or got an error */
Walter Dörwald7e5c6a02002-12-12 19:14:08 +00002170 return retval;
Guido van Rossumf6c9ba82003-02-10 16:05:43 +00002171 }
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00002172 }
Walter Dörwald7e5c6a02002-12-12 19:14:08 +00002173 return 0;
Neil Schemenauer6b471292001-10-18 03:18:43 +00002174 }
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00002175 else {
2176 if (!check_class(cls,
2177 "issubclass() arg 2 must be a class"
2178 " or tuple of classes"))
2179 return -1;
2180 }
Neil Schemenauer6b471292001-10-18 03:18:43 +00002181
2182 retval = abstract_issubclass(derived, cls);
Guido van Rossum823649d2001-03-21 18:40:58 +00002183 }
2184 else {
2185 /* shortcut */
2186 if (!(retval = (derived == cls)))
2187 retval = PyClass_IsSubclass(derived, cls);
2188 }
2189
2190 return retval;
2191}
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002192
Brett Cannon4f653312004-03-20 22:52:14 +00002193int
2194PyObject_IsSubclass(PyObject *derived, PyObject *cls)
2195{
2196 return recursive_issubclass(derived, cls, Py_GetRecursionLimit());
2197}
2198
2199
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002200PyObject *
2201PyObject_GetIter(PyObject *o)
2202{
2203 PyTypeObject *t = o->ob_type;
2204 getiterfunc f = NULL;
2205 if (PyType_HasFeature(t, Py_TPFLAGS_HAVE_ITER))
2206 f = t->tp_iter;
2207 if (f == NULL) {
2208 if (PySequence_Check(o))
Guido van Rossum213c7a62001-04-23 14:08:49 +00002209 return PySeqIter_New(o);
Guido van Rossum77660912002-04-16 16:32:50 +00002210 PyErr_SetString(PyExc_TypeError,
Jeremy Hylton89c3a222001-11-09 21:59:42 +00002211 "iteration over non-sequence");
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002212 return NULL;
2213 }
Guido van Rossum213c7a62001-04-23 14:08:49 +00002214 else {
2215 PyObject *res = (*f)(o);
2216 if (res != NULL && !PyIter_Check(res)) {
2217 PyErr_Format(PyExc_TypeError,
2218 "iter() returned non-iterator "
2219 "of type '%.100s'",
2220 res->ob_type->tp_name);
2221 Py_DECREF(res);
2222 res = NULL;
2223 }
2224 return res;
2225 }
2226}
2227
Tim Petersf4848da2001-05-05 00:14:56 +00002228/* Return next item.
2229 * If an error occurs, return NULL. PyErr_Occurred() will be true.
2230 * If the iteration terminates normally, return NULL and clear the
2231 * PyExc_StopIteration exception (if it was set). PyErr_Occurred()
2232 * will be false.
2233 * Else return the next object. PyErr_Occurred() will be false.
2234 */
Guido van Rossum213c7a62001-04-23 14:08:49 +00002235PyObject *
2236PyIter_Next(PyObject *iter)
2237{
Tim Petersf4848da2001-05-05 00:14:56 +00002238 PyObject *result;
Raymond Hettinger8049dde2003-03-01 01:44:32 +00002239 assert(PyIter_Check(iter));
Tim Petersf4848da2001-05-05 00:14:56 +00002240 result = (*iter->ob_type->tp_iternext)(iter);
2241 if (result == NULL &&
2242 PyErr_Occurred() &&
2243 PyErr_ExceptionMatches(PyExc_StopIteration))
2244 PyErr_Clear();
2245 return result;
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002246}