blob: 2c1c76e4bdd7eae2889070a6f7d7521722271483 [file] [log] [blame]
Guido van Rossume15dee51995-07-18 14:12:02 +00001/* Abstract Object Interface (many thanks to Jim Fulton) */
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002
Guido van Rossume15dee51995-07-18 14:12:02 +00003#include "Python.h"
Guido van Rossumfa0b6ab1998-05-22 15:23:36 +00004#include <ctype.h>
Neil Schemenauer5a1f0152001-01-04 01:39:06 +00005#include "structmember.h" /* we need the offsetof() macro from there */
Tim Peters64b5ce32001-09-10 20:52:51 +00006#include "longintrepr.h"
Neil Schemenauer5a1f0152001-01-04 01:39:06 +00007
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00008
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00009
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000010/* Shorthands to return certain errors */
Guido van Rossume15dee51995-07-18 14:12:02 +000011
12static PyObject *
Thomas Wouters0e3f5912006-08-11 14:57:12 +000013type_error(const char *msg, PyObject *obj)
Guido van Rossume15dee51995-07-18 14:12:02 +000014{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000015 PyErr_Format(PyExc_TypeError, msg, obj->ob_type->tp_name);
16 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +000017}
18
Guido van Rossum052b7e11996-11-11 15:08:19 +000019static PyObject *
Fred Drake79912472000-07-09 04:06:11 +000020null_error(void)
Guido van Rossume15dee51995-07-18 14:12:02 +000021{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000022 if (!PyErr_Occurred())
23 PyErr_SetString(PyExc_SystemError,
24 "null argument to internal routine");
25 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +000026}
27
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000028/* Operations on any object */
29
Guido van Rossume15dee51995-07-18 14:12:02 +000030PyObject *
Fred Drake79912472000-07-09 04:06:11 +000031PyObject_Type(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +000032{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000033 PyObject *v;
Guido van Rossume15dee51995-07-18 14:12:02 +000034
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000035 if (o == NULL)
36 return null_error();
37 v = (PyObject *)o->ob_type;
38 Py_INCREF(v);
39 return v;
Guido van Rossume15dee51995-07-18 14:12:02 +000040}
41
Martin v. Löwis18e16552006-02-15 17:27:45 +000042Py_ssize_t
Jeremy Hylton6253f832000-07-12 12:56:19 +000043PyObject_Size(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +000044{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000045 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +000046
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000047 if (o == NULL) {
48 null_error();
49 return -1;
50 }
Guido van Rossume15dee51995-07-18 14:12:02 +000051
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000052 m = o->ob_type->tp_as_sequence;
53 if (m && m->sq_length)
54 return m->sq_length(o);
Guido van Rossume15dee51995-07-18 14:12:02 +000055
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000056 return PyMapping_Size(o);
Guido van Rossume15dee51995-07-18 14:12:02 +000057}
58
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +000059#undef PyObject_Length
Martin v. Löwis18e16552006-02-15 17:27:45 +000060Py_ssize_t
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +000061PyObject_Length(PyObject *o)
62{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000063 return PyObject_Size(o);
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +000064}
65#define PyObject_Length PyObject_Size
66
Armin Ronacheraa9a79d2012-10-06 14:03:24 +020067int
68_PyObject_HasLen(PyObject *o) {
69 return (Py_TYPE(o)->tp_as_sequence && Py_TYPE(o)->tp_as_sequence->sq_length) ||
70 (Py_TYPE(o)->tp_as_mapping && Py_TYPE(o)->tp_as_mapping->mp_length);
71}
Raymond Hettinger6b27cda2005-09-24 21:23:05 +000072
Christian Heimes255f53b2007-12-08 15:33:56 +000073/* The length hint function returns a non-negative value from o.__len__()
Armin Ronacher74b38b12012-10-07 10:29:32 +020074 or o.__length_hint__(). If those methods aren't found the defaultvalue is
75 returned. If one of the calls fails with an exception other than TypeError
76 this function returns -1.
Christian Heimes255f53b2007-12-08 15:33:56 +000077*/
78
79Py_ssize_t
Armin Ronacheraa9a79d2012-10-06 14:03:24 +020080PyObject_LengthHint(PyObject *o, Py_ssize_t defaultvalue)
Christian Heimes255f53b2007-12-08 15:33:56 +000081{
Christian Heimesb70e8a12012-10-06 17:16:39 +020082 PyObject *hint, *result;
Christian Heimes6314d162012-10-06 17:13:29 +020083 Py_ssize_t res;
Benjamin Petersonce798522012-01-22 11:24:29 -050084 _Py_IDENTIFIER(__length_hint__);
Serhiy Storchakaf740d462013-10-24 23:19:51 +030085 if (_PyObject_HasLen(o)) {
86 res = PyObject_Length(o);
87 if (res < 0 && PyErr_Occurred()) {
88 if (!PyErr_ExceptionMatches(PyExc_TypeError)) {
89 return -1;
90 }
91 PyErr_Clear();
Armin Ronacheraa9a79d2012-10-06 14:03:24 +020092 }
Serhiy Storchakaf740d462013-10-24 23:19:51 +030093 else {
94 return res;
95 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000096 }
Christian Heimes6314d162012-10-06 17:13:29 +020097 hint = _PyObject_LookupSpecial(o, &PyId___length_hint__);
Armin Ronacheraa9a79d2012-10-06 14:03:24 +020098 if (hint == NULL) {
99 if (PyErr_Occurred()) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000100 return -1;
Armin Ronacheraa9a79d2012-10-06 14:03:24 +0200101 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000102 return defaultvalue;
103 }
Christian Heimesb70e8a12012-10-06 17:16:39 +0200104 result = PyObject_CallFunctionObjArgs(hint, NULL);
Armin Ronacheraa9a79d2012-10-06 14:03:24 +0200105 Py_DECREF(hint);
106 if (result == NULL) {
107 if (PyErr_ExceptionMatches(PyExc_TypeError)) {
108 PyErr_Clear();
109 return defaultvalue;
110 }
111 return -1;
112 }
113 else if (result == Py_NotImplemented) {
114 Py_DECREF(result);
115 return defaultvalue;
116 }
117 if (!PyLong_Check(result)) {
Armin Ronacher74b38b12012-10-07 10:29:32 +0200118 PyErr_Format(PyExc_TypeError, "__length_hint__ must be an integer, not %.100s",
Armin Ronacheraa9a79d2012-10-06 14:03:24 +0200119 Py_TYPE(result)->tp_name);
120 Py_DECREF(result);
121 return -1;
122 }
Armin Ronacher74b38b12012-10-07 10:29:32 +0200123 res = PyLong_AsSsize_t(result);
Armin Ronacheraa9a79d2012-10-06 14:03:24 +0200124 Py_DECREF(result);
Armin Ronacher74b38b12012-10-07 10:29:32 +0200125 if (res < 0 && PyErr_Occurred()) {
Armin Ronacheraa9a79d2012-10-06 14:03:24 +0200126 return -1;
127 }
Armin Ronacher74b38b12012-10-07 10:29:32 +0200128 if (res < 0) {
Armin Ronacheraa9a79d2012-10-06 14:03:24 +0200129 PyErr_Format(PyExc_ValueError, "__length_hint__() should return >= 0");
130 return -1;
131 }
Armin Ronacher74b38b12012-10-07 10:29:32 +0200132 return res;
Raymond Hettinger6b27cda2005-09-24 21:23:05 +0000133}
134
Guido van Rossume15dee51995-07-18 14:12:02 +0000135PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000136PyObject_GetItem(PyObject *o, PyObject *key)
Guido van Rossume15dee51995-07-18 14:12:02 +0000137{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000138 PyMappingMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +0000139
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000140 if (o == NULL || key == NULL)
141 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +0000142
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000143 m = o->ob_type->tp_as_mapping;
Victor Stinnere20310f2015-11-05 13:56:58 +0100144 if (m && m->mp_subscript) {
145 PyObject *item = m->mp_subscript(o, key);
146 assert((item != NULL) ^ (PyErr_Occurred() != NULL));
147 return item;
148 }
Guido van Rossume15dee51995-07-18 14:12:02 +0000149
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000150 if (o->ob_type->tp_as_sequence) {
151 if (PyIndex_Check(key)) {
152 Py_ssize_t key_value;
153 key_value = PyNumber_AsSsize_t(key, PyExc_IndexError);
154 if (key_value == -1 && PyErr_Occurred())
155 return NULL;
156 return PySequence_GetItem(o, key_value);
157 }
158 else if (o->ob_type->tp_as_sequence->sq_item)
159 return type_error("sequence index must "
160 "be integer, not '%.200s'", key);
161 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000162
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000163 return type_error("'%.200s' object is not subscriptable", o);
Guido van Rossume15dee51995-07-18 14:12:02 +0000164}
165
166int
Fred Drake79912472000-07-09 04:06:11 +0000167PyObject_SetItem(PyObject *o, PyObject *key, PyObject *value)
Guido van Rossume15dee51995-07-18 14:12:02 +0000168{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000169 PyMappingMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +0000170
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000171 if (o == NULL || key == NULL || value == NULL) {
172 null_error();
173 return -1;
174 }
175 m = o->ob_type->tp_as_mapping;
176 if (m && m->mp_ass_subscript)
177 return m->mp_ass_subscript(o, key, value);
Guido van Rossume15dee51995-07-18 14:12:02 +0000178
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000179 if (o->ob_type->tp_as_sequence) {
180 if (PyIndex_Check(key)) {
181 Py_ssize_t key_value;
182 key_value = PyNumber_AsSsize_t(key, PyExc_IndexError);
183 if (key_value == -1 && PyErr_Occurred())
184 return -1;
185 return PySequence_SetItem(o, key_value, value);
186 }
187 else if (o->ob_type->tp_as_sequence->sq_ass_item) {
188 type_error("sequence index must be "
189 "integer, not '%.200s'", key);
190 return -1;
191 }
192 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000193
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000194 type_error("'%.200s' object does not support item assignment", o);
195 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +0000196}
197
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000198int
Fred Drake79912472000-07-09 04:06:11 +0000199PyObject_DelItem(PyObject *o, PyObject *key)
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000200{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000201 PyMappingMethods *m;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000202
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000203 if (o == NULL || key == NULL) {
204 null_error();
205 return -1;
206 }
207 m = o->ob_type->tp_as_mapping;
208 if (m && m->mp_ass_subscript)
209 return m->mp_ass_subscript(o, key, (PyObject*)NULL);
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000210
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000211 if (o->ob_type->tp_as_sequence) {
212 if (PyIndex_Check(key)) {
213 Py_ssize_t key_value;
214 key_value = PyNumber_AsSsize_t(key, PyExc_IndexError);
215 if (key_value == -1 && PyErr_Occurred())
216 return -1;
217 return PySequence_DelItem(o, key_value);
218 }
219 else if (o->ob_type->tp_as_sequence->sq_ass_item) {
220 type_error("sequence index must be "
221 "integer, not '%.200s'", key);
222 return -1;
223 }
224 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000225
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000226 type_error("'%.200s' object does not support item deletion", o);
227 return -1;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000228}
229
Martin v. Löwisb0d71d02002-01-05 10:50:30 +0000230int
Serhiy Storchakac6792272013-10-19 21:03:34 +0300231PyObject_DelItemString(PyObject *o, const char *key)
Martin v. Löwisb0d71d02002-01-05 10:50:30 +0000232{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000233 PyObject *okey;
234 int ret;
Martin v. Löwisb0d71d02002-01-05 10:50:30 +0000235
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000236 if (o == NULL || key == NULL) {
237 null_error();
238 return -1;
239 }
240 okey = PyUnicode_FromString(key);
241 if (okey == NULL)
242 return -1;
243 ret = PyObject_DelItem(o, okey);
244 Py_DECREF(okey);
245 return ret;
Martin v. Löwisb0d71d02002-01-05 10:50:30 +0000246}
247
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000248/* We release the buffer right after use of this function which could
Guido van Rossum98297ee2007-11-06 21:34:58 +0000249 cause issues later on. Don't use these functions in new code.
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000250 */
Thomas Wouters73e5a5b2006-06-08 15:35:45 +0000251int
252PyObject_AsCharBuffer(PyObject *obj,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000253 const char **buffer,
254 Py_ssize_t *buffer_len)
Guido van Rossum4c08d552000-03-10 22:55:18 +0000255{
Serhiy Storchaka4fdb6842015-02-03 01:21:08 +0200256 return PyObject_AsReadBuffer(obj, (const void **)buffer, buffer_len);
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000257}
Guido van Rossum4c08d552000-03-10 22:55:18 +0000258
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000259int
260PyObject_CheckReadBuffer(PyObject *obj)
261{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000262 PyBufferProcs *pb = obj->ob_type->tp_as_buffer;
263 Py_buffer view;
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000264
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000265 if (pb == NULL ||
266 pb->bf_getbuffer == NULL)
267 return 0;
268 if ((*pb->bf_getbuffer)(obj, &view, PyBUF_SIMPLE) == -1) {
269 PyErr_Clear();
270 return 0;
271 }
272 PyBuffer_Release(&view);
273 return 1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000274}
275
276int PyObject_AsReadBuffer(PyObject *obj,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000277 const void **buffer,
278 Py_ssize_t *buffer_len)
Guido van Rossum4c08d552000-03-10 22:55:18 +0000279{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000280 Py_buffer view;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000281
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000282 if (obj == NULL || buffer == NULL || buffer_len == NULL) {
283 null_error();
284 return -1;
285 }
Serhiy Storchaka4fdb6842015-02-03 01:21:08 +0200286 if (PyObject_GetBuffer(obj, &view, PyBUF_SIMPLE) != 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000287 return -1;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000288
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000289 *buffer = view.buf;
290 *buffer_len = view.len;
Serhiy Storchaka4fdb6842015-02-03 01:21:08 +0200291 PyBuffer_Release(&view);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000292 return 0;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000293}
294
295int PyObject_AsWriteBuffer(PyObject *obj,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000296 void **buffer,
297 Py_ssize_t *buffer_len)
Guido van Rossum4c08d552000-03-10 22:55:18 +0000298{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000299 PyBufferProcs *pb;
300 Py_buffer view;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000301
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000302 if (obj == NULL || buffer == NULL || buffer_len == NULL) {
303 null_error();
304 return -1;
305 }
306 pb = obj->ob_type->tp_as_buffer;
307 if (pb == NULL ||
308 pb->bf_getbuffer == NULL ||
309 ((*pb->bf_getbuffer)(obj, &view, PyBUF_WRITABLE) != 0)) {
310 PyErr_SetString(PyExc_TypeError,
R David Murray861470c2014-10-05 11:47:01 -0400311 "expected a writable bytes-like object");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000312 return -1;
313 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000314
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000315 *buffer = view.buf;
316 *buffer_len = view.len;
Serhiy Storchaka4fdb6842015-02-03 01:21:08 +0200317 PyBuffer_Release(&view);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000318 return 0;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000319}
320
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000321/* Buffer C-API for Python 3.0 */
322
323int
Travis E. Oliphant8ae62b62007-09-23 02:00:13 +0000324PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000325{
Serhiy Storchaka4fdb6842015-02-03 01:21:08 +0200326 PyBufferProcs *pb = obj->ob_type->tp_as_buffer;
327
328 if (pb == NULL || pb->bf_getbuffer == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000329 PyErr_Format(PyExc_TypeError,
R David Murray861470c2014-10-05 11:47:01 -0400330 "a bytes-like object is required, not '%.100s'",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000331 Py_TYPE(obj)->tp_name);
332 return -1;
333 }
Serhiy Storchaka4fdb6842015-02-03 01:21:08 +0200334 return (*pb->bf_getbuffer)(obj, view, flags);
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000335}
336
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000337static int
Stefan Krah9a2d99e2012-02-25 12:24:21 +0100338_IsFortranContiguous(const Py_buffer *view)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000339{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000340 Py_ssize_t sd, dim;
341 int i;
Guido van Rossum98297ee2007-11-06 21:34:58 +0000342
Stefan Krah363af442015-02-01 14:53:54 +0100343 /* 1) len = product(shape) * itemsize
344 2) itemsize > 0
345 3) len = 0 <==> exists i: shape[i] = 0 */
346 if (view->len == 0) return 1;
347 if (view->strides == NULL) { /* C-contiguous by definition */
348 /* Trivially F-contiguous */
349 if (view->ndim <= 1) return 1;
350
351 /* ndim > 1 implies shape != NULL */
352 assert(view->shape != NULL);
353
354 /* Effectively 1-d */
355 sd = 0;
356 for (i=0; i<view->ndim; i++) {
357 if (view->shape[i] > 1) sd += 1;
358 }
359 return sd <= 1;
360 }
361
362 /* strides != NULL implies both of these */
363 assert(view->ndim > 0);
364 assert(view->shape != NULL);
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000365
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000366 sd = view->itemsize;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000367 for (i=0; i<view->ndim; i++) {
368 dim = view->shape[i];
Stefan Krah363af442015-02-01 14:53:54 +0100369 if (dim > 1 && view->strides[i] != sd) {
370 return 0;
371 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000372 sd *= dim;
373 }
374 return 1;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000375}
376
377static int
Stefan Krah9a2d99e2012-02-25 12:24:21 +0100378_IsCContiguous(const Py_buffer *view)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000379{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000380 Py_ssize_t sd, dim;
381 int i;
Guido van Rossum98297ee2007-11-06 21:34:58 +0000382
Stefan Krah363af442015-02-01 14:53:54 +0100383 /* 1) len = product(shape) * itemsize
384 2) itemsize > 0
385 3) len = 0 <==> exists i: shape[i] = 0 */
386 if (view->len == 0) return 1;
387 if (view->strides == NULL) return 1; /* C-contiguous by definition */
388
389 /* strides != NULL implies both of these */
390 assert(view->ndim > 0);
391 assert(view->shape != NULL);
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000392
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000393 sd = view->itemsize;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000394 for (i=view->ndim-1; i>=0; i--) {
395 dim = view->shape[i];
Stefan Krah363af442015-02-01 14:53:54 +0100396 if (dim > 1 && view->strides[i] != sd) {
397 return 0;
398 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000399 sd *= dim;
400 }
401 return 1;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000402}
403
404int
Stefan Krah9a2d99e2012-02-25 12:24:21 +0100405PyBuffer_IsContiguous(const Py_buffer *view, char order)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000406{
407
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000408 if (view->suboffsets != NULL) return 0;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000409
Stefan Krah9a2d99e2012-02-25 12:24:21 +0100410 if (order == 'C')
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000411 return _IsCContiguous(view);
Stefan Krah9a2d99e2012-02-25 12:24:21 +0100412 else if (order == 'F')
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000413 return _IsFortranContiguous(view);
Stefan Krah9a2d99e2012-02-25 12:24:21 +0100414 else if (order == 'A')
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000415 return (_IsCContiguous(view) || _IsFortranContiguous(view));
416 return 0;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000417}
418
419
Guido van Rossum98297ee2007-11-06 21:34:58 +0000420void*
Travis E. Oliphant8ae62b62007-09-23 02:00:13 +0000421PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000422{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000423 char* pointer;
424 int i;
425 pointer = (char *)view->buf;
426 for (i = 0; i < view->ndim; i++) {
427 pointer += view->strides[i]*indices[i];
428 if ((view->suboffsets != NULL) && (view->suboffsets[i] >= 0)) {
429 pointer = *((char**)pointer) + view->suboffsets[i];
430 }
431 }
432 return (void*)pointer;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000433}
434
435
Guido van Rossum98297ee2007-11-06 21:34:58 +0000436void
Antoine Pitrouf68c2a72010-09-01 12:58:21 +0000437_Py_add_one_to_index_F(int nd, Py_ssize_t *index, const Py_ssize_t *shape)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000438{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000439 int k;
Guido van Rossum98297ee2007-11-06 21:34:58 +0000440
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000441 for (k=0; k<nd; k++) {
442 if (index[k] < shape[k]-1) {
443 index[k]++;
444 break;
445 }
446 else {
447 index[k] = 0;
448 }
449 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000450}
451
Guido van Rossum98297ee2007-11-06 21:34:58 +0000452void
Antoine Pitrouf68c2a72010-09-01 12:58:21 +0000453_Py_add_one_to_index_C(int nd, Py_ssize_t *index, const Py_ssize_t *shape)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000454{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000455 int k;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000456
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000457 for (k=nd-1; k>=0; k--) {
458 if (index[k] < shape[k]-1) {
459 index[k]++;
460 break;
461 }
462 else {
463 index[k] = 0;
464 }
465 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000466}
467
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000468int
Travis E. Oliphant8ae62b62007-09-23 02:00:13 +0000469PyBuffer_FromContiguous(Py_buffer *view, void *buf, Py_ssize_t len, char fort)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000470{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000471 int k;
Antoine Pitrouf68c2a72010-09-01 12:58:21 +0000472 void (*addone)(int, Py_ssize_t *, const Py_ssize_t *);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000473 Py_ssize_t *indices, elements;
474 char *src, *ptr;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000475
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000476 if (len > view->len) {
477 len = view->len;
478 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000479
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000480 if (PyBuffer_IsContiguous(view, fort)) {
481 /* simplest copy is all that is needed */
482 memcpy(view->buf, buf, len);
483 return 0;
484 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000485
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000486 /* Otherwise a more elaborate scheme is needed */
Guido van Rossum98297ee2007-11-06 21:34:58 +0000487
Stefan Krah7213fcc2015-02-01 16:19:23 +0100488 /* view->ndim <= 64 */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000489 indices = (Py_ssize_t *)PyMem_Malloc(sizeof(Py_ssize_t)*(view->ndim));
490 if (indices == NULL) {
491 PyErr_NoMemory();
492 return -1;
493 }
494 for (k=0; k<view->ndim;k++) {
495 indices[k] = 0;
496 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000497
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000498 if (fort == 'F') {
Antoine Pitrouf68c2a72010-09-01 12:58:21 +0000499 addone = _Py_add_one_to_index_F;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000500 }
501 else {
Antoine Pitrouf68c2a72010-09-01 12:58:21 +0000502 addone = _Py_add_one_to_index_C;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000503 }
504 src = buf;
505 /* XXX : This is not going to be the fastest code in the world
506 several optimizations are possible.
507 */
508 elements = len / view->itemsize;
509 while (elements--) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000510 ptr = PyBuffer_GetPointer(view, indices);
511 memcpy(ptr, src, view->itemsize);
512 src += view->itemsize;
Stefan Krah7213fcc2015-02-01 16:19:23 +0100513 addone(view->ndim, indices, view->shape);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000514 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000515
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000516 PyMem_Free(indices);
517 return 0;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000518}
519
Guido van Rossum98297ee2007-11-06 21:34:58 +0000520int PyObject_CopyData(PyObject *dest, PyObject *src)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000521{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000522 Py_buffer view_dest, view_src;
523 int k;
524 Py_ssize_t *indices, elements;
525 char *dptr, *sptr;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000526
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000527 if (!PyObject_CheckBuffer(dest) ||
528 !PyObject_CheckBuffer(src)) {
529 PyErr_SetString(PyExc_TypeError,
R David Murray861470c2014-10-05 11:47:01 -0400530 "both destination and source must be "\
531 "bytes-like objects");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000532 return -1;
533 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000534
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000535 if (PyObject_GetBuffer(dest, &view_dest, PyBUF_FULL) != 0) return -1;
536 if (PyObject_GetBuffer(src, &view_src, PyBUF_FULL_RO) != 0) {
537 PyBuffer_Release(&view_dest);
538 return -1;
539 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000540
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000541 if (view_dest.len < view_src.len) {
542 PyErr_SetString(PyExc_BufferError,
543 "destination is too small to receive data from source");
544 PyBuffer_Release(&view_dest);
545 PyBuffer_Release(&view_src);
546 return -1;
547 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000548
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000549 if ((PyBuffer_IsContiguous(&view_dest, 'C') &&
550 PyBuffer_IsContiguous(&view_src, 'C')) ||
551 (PyBuffer_IsContiguous(&view_dest, 'F') &&
552 PyBuffer_IsContiguous(&view_src, 'F'))) {
553 /* simplest copy is all that is needed */
554 memcpy(view_dest.buf, view_src.buf, view_src.len);
555 PyBuffer_Release(&view_dest);
556 PyBuffer_Release(&view_src);
557 return 0;
558 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000559
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000560 /* Otherwise a more elaborate copy scheme is needed */
Guido van Rossum98297ee2007-11-06 21:34:58 +0000561
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000562 /* XXX(nnorwitz): need to check for overflow! */
563 indices = (Py_ssize_t *)PyMem_Malloc(sizeof(Py_ssize_t)*view_src.ndim);
564 if (indices == NULL) {
565 PyErr_NoMemory();
566 PyBuffer_Release(&view_dest);
567 PyBuffer_Release(&view_src);
568 return -1;
569 }
570 for (k=0; k<view_src.ndim;k++) {
571 indices[k] = 0;
572 }
573 elements = 1;
574 for (k=0; k<view_src.ndim; k++) {
575 /* XXX(nnorwitz): can this overflow? */
576 elements *= view_src.shape[k];
577 }
578 while (elements--) {
Antoine Pitrouf68c2a72010-09-01 12:58:21 +0000579 _Py_add_one_to_index_C(view_src.ndim, indices, view_src.shape);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000580 dptr = PyBuffer_GetPointer(&view_dest, indices);
581 sptr = PyBuffer_GetPointer(&view_src, indices);
582 memcpy(dptr, sptr, view_src.itemsize);
583 }
584 PyMem_Free(indices);
585 PyBuffer_Release(&view_dest);
586 PyBuffer_Release(&view_src);
587 return 0;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000588}
589
590void
591PyBuffer_FillContiguousStrides(int nd, Py_ssize_t *shape,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000592 Py_ssize_t *strides, int itemsize,
593 char fort)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000594{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000595 int k;
596 Py_ssize_t sd;
Guido van Rossum98297ee2007-11-06 21:34:58 +0000597
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000598 sd = itemsize;
599 if (fort == 'F') {
600 for (k=0; k<nd; k++) {
601 strides[k] = sd;
602 sd *= shape[k];
603 }
604 }
605 else {
606 for (k=nd-1; k>=0; k--) {
607 strides[k] = sd;
608 sd *= shape[k];
609 }
610 }
611 return;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000612}
613
614int
Martin v. Löwis423be952008-08-13 15:53:07 +0000615PyBuffer_FillInfo(Py_buffer *view, PyObject *obj, void *buf, Py_ssize_t len,
Stefan Krah4e141742012-03-06 15:27:31 +0100616 int readonly, int flags)
Guido van Rossum98297ee2007-11-06 21:34:58 +0000617{
Stefan Krah5178d912015-02-03 16:57:21 +0100618 if (view == NULL) {
619 PyErr_SetString(PyExc_BufferError,
620 "PyBuffer_FillInfo: view==NULL argument is obsolete");
621 return -1;
622 }
623
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000624 if (((flags & PyBUF_WRITABLE) == PyBUF_WRITABLE) &&
625 (readonly == 1)) {
626 PyErr_SetString(PyExc_BufferError,
627 "Object is not writable.");
628 return -1;
629 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000630
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000631 view->obj = obj;
632 if (obj)
633 Py_INCREF(obj);
634 view->buf = buf;
635 view->len = len;
636 view->readonly = readonly;
637 view->itemsize = 1;
638 view->format = NULL;
639 if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT)
640 view->format = "B";
641 view->ndim = 1;
642 view->shape = NULL;
643 if ((flags & PyBUF_ND) == PyBUF_ND)
644 view->shape = &(view->len);
645 view->strides = NULL;
646 if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES)
647 view->strides = &(view->itemsize);
648 view->suboffsets = NULL;
649 view->internal = NULL;
650 return 0;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000651}
652
Martin v. Löwis423be952008-08-13 15:53:07 +0000653void
654PyBuffer_Release(Py_buffer *view)
655{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000656 PyObject *obj = view->obj;
Serhiy Storchaka4fdb6842015-02-03 01:21:08 +0200657 PyBufferProcs *pb;
658 if (obj == NULL)
659 return;
660 pb = Py_TYPE(obj)->tp_as_buffer;
661 if (pb && pb->bf_releasebuffer)
662 pb->bf_releasebuffer(obj, view);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000663 view->obj = NULL;
Serhiy Storchaka4fdb6842015-02-03 01:21:08 +0200664 Py_DECREF(obj);
Martin v. Löwis423be952008-08-13 15:53:07 +0000665}
666
Eric Smith8fd3eba2008-02-17 19:48:00 +0000667PyObject *
668PyObject_Format(PyObject *obj, PyObject *format_spec)
669{
Eric Smith8fd3eba2008-02-17 19:48:00 +0000670 PyObject *meth;
671 PyObject *empty = NULL;
672 PyObject *result = NULL;
Benjamin Petersonce798522012-01-22 11:24:29 -0500673 _Py_IDENTIFIER(__format__);
Eric Smith8fd3eba2008-02-17 19:48:00 +0000674
675 /* If no format_spec is provided, use an empty string */
676 if (format_spec == NULL) {
Victor Stinner9d3b93b2011-11-22 02:27:30 +0100677 empty = PyUnicode_New(0, 0);
Benjamin Petersonda2cf042010-06-05 00:45:37 +0000678 format_spec = empty;
Eric Smith8fd3eba2008-02-17 19:48:00 +0000679 }
680
Eric Smith8fd3eba2008-02-17 19:48:00 +0000681 /* Find the (unbound!) __format__ method (a borrowed reference) */
Benjamin Petersonce798522012-01-22 11:24:29 -0500682 meth = _PyObject_LookupSpecial(obj, &PyId___format__);
Eric Smith8fd3eba2008-02-17 19:48:00 +0000683 if (meth == NULL) {
Benjamin Petersonda2cf042010-06-05 00:45:37 +0000684 if (!PyErr_Occurred())
685 PyErr_Format(PyExc_TypeError,
686 "Type %.100s doesn't define __format__",
687 Py_TYPE(obj)->tp_name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000688 goto done;
Eric Smith8fd3eba2008-02-17 19:48:00 +0000689 }
690
Benjamin Petersonda2cf042010-06-05 00:45:37 +0000691 /* And call it. */
692 result = PyObject_CallFunctionObjArgs(meth, format_spec, NULL);
Benjamin Peterson6f889ad32010-06-05 02:11:45 +0000693 Py_DECREF(meth);
Eric Smith8fd3eba2008-02-17 19:48:00 +0000694
695 if (result && !PyUnicode_Check(result)) {
Ethan Furmanb95b5612015-01-23 20:05:18 -0800696 PyErr_Format(PyExc_TypeError,
697 "__format__ must return a str, not %.200s",
698 Py_TYPE(result)->tp_name);
Benjamin Petersonda2cf042010-06-05 00:45:37 +0000699 Py_DECREF(result);
700 result = NULL;
701 goto done;
Eric Smith8fd3eba2008-02-17 19:48:00 +0000702 }
703
704done:
705 Py_XDECREF(empty);
706 return result;
707}
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000708/* Operations on numbers */
709
710int
Fred Drake79912472000-07-09 04:06:11 +0000711PyNumber_Check(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +0000712{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000713 return o && o->ob_type->tp_as_number &&
714 (o->ob_type->tp_as_number->nb_int ||
715 o->ob_type->tp_as_number->nb_float);
Guido van Rossume15dee51995-07-18 14:12:02 +0000716}
717
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000718/* Binary operators */
Guido van Rossume15dee51995-07-18 14:12:02 +0000719
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000720#define NB_SLOT(x) offsetof(PyNumberMethods, x)
721#define NB_BINOP(nb_methods, slot) \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000722 (*(binaryfunc*)(& ((char*)nb_methods)[slot]))
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000723#define NB_TERNOP(nb_methods, slot) \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000724 (*(ternaryfunc*)(& ((char*)nb_methods)[slot]))
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000725
726/*
727 Calling scheme used for binary operations:
728
Neal Norwitz4886cc32006-08-21 17:06:07 +0000729 Order operations are tried until either a valid result or error:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000730 w.op(v,w)[*], v.op(v,w), w.op(v,w)
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000731
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000732 [*] only when v->ob_type != w->ob_type && w->ob_type is a subclass of
733 v->ob_type
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000734 */
735
736static PyObject *
737binary_op1(PyObject *v, PyObject *w, const int op_slot)
Guido van Rossume15dee51995-07-18 14:12:02 +0000738{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000739 PyObject *x;
740 binaryfunc slotv = NULL;
741 binaryfunc slotw = NULL;
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000742
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000743 if (v->ob_type->tp_as_number != NULL)
744 slotv = NB_BINOP(v->ob_type->tp_as_number, op_slot);
745 if (w->ob_type != v->ob_type &&
746 w->ob_type->tp_as_number != NULL) {
747 slotw = NB_BINOP(w->ob_type->tp_as_number, op_slot);
748 if (slotw == slotv)
749 slotw = NULL;
750 }
751 if (slotv) {
752 if (slotw && PyType_IsSubtype(w->ob_type, v->ob_type)) {
753 x = slotw(v, w);
754 if (x != Py_NotImplemented)
755 return x;
756 Py_DECREF(x); /* can't do it */
757 slotw = NULL;
758 }
759 x = slotv(v, w);
760 if (x != Py_NotImplemented)
761 return x;
762 Py_DECREF(x); /* can't do it */
763 }
764 if (slotw) {
765 x = slotw(v, w);
766 if (x != Py_NotImplemented)
767 return x;
768 Py_DECREF(x); /* can't do it */
769 }
Brian Curtindfc80e32011-08-10 20:28:54 -0500770 Py_RETURN_NOTIMPLEMENTED;
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000771}
Guido van Rossum77660912002-04-16 16:32:50 +0000772
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000773static PyObject *
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000774binop_type_error(PyObject *v, PyObject *w, const char *op_name)
775{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000776 PyErr_Format(PyExc_TypeError,
777 "unsupported operand type(s) for %.100s: "
778 "'%.100s' and '%.100s'",
779 op_name,
780 v->ob_type->tp_name,
781 w->ob_type->tp_name);
782 return NULL;
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000783}
784
785static PyObject *
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000786binary_op(PyObject *v, PyObject *w, const int op_slot, const char *op_name)
787{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000788 PyObject *result = binary_op1(v, w, op_slot);
789 if (result == Py_NotImplemented) {
790 Py_DECREF(result);
791 return binop_type_error(v, w, op_name);
792 }
793 return result;
Guido van Rossume15dee51995-07-18 14:12:02 +0000794}
795
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000796
797/*
798 Calling scheme used for ternary operations:
799
Neal Norwitz4886cc32006-08-21 17:06:07 +0000800 Order operations are tried until either a valid result or error:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000801 v.op(v,w,z), w.op(v,w,z), z.op(v,w,z)
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000802 */
803
804static PyObject *
805ternary_op(PyObject *v,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000806 PyObject *w,
807 PyObject *z,
808 const int op_slot,
809 const char *op_name)
Guido van Rossume15dee51995-07-18 14:12:02 +0000810{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000811 PyNumberMethods *mv, *mw, *mz;
812 PyObject *x = NULL;
813 ternaryfunc slotv = NULL;
814 ternaryfunc slotw = NULL;
815 ternaryfunc slotz = NULL;
Guido van Rossum77660912002-04-16 16:32:50 +0000816
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000817 mv = v->ob_type->tp_as_number;
818 mw = w->ob_type->tp_as_number;
819 if (mv != NULL)
820 slotv = NB_TERNOP(mv, op_slot);
821 if (w->ob_type != v->ob_type &&
822 mw != NULL) {
823 slotw = NB_TERNOP(mw, op_slot);
824 if (slotw == slotv)
825 slotw = NULL;
826 }
827 if (slotv) {
828 if (slotw && PyType_IsSubtype(w->ob_type, v->ob_type)) {
829 x = slotw(v, w, z);
830 if (x != Py_NotImplemented)
831 return x;
832 Py_DECREF(x); /* can't do it */
833 slotw = NULL;
834 }
835 x = slotv(v, w, z);
836 if (x != Py_NotImplemented)
837 return x;
838 Py_DECREF(x); /* can't do it */
839 }
840 if (slotw) {
841 x = slotw(v, w, z);
842 if (x != Py_NotImplemented)
843 return x;
844 Py_DECREF(x); /* can't do it */
845 }
846 mz = z->ob_type->tp_as_number;
847 if (mz != NULL) {
848 slotz = NB_TERNOP(mz, op_slot);
849 if (slotz == slotv || slotz == slotw)
850 slotz = NULL;
851 if (slotz) {
852 x = slotz(v, w, z);
853 if (x != Py_NotImplemented)
854 return x;
855 Py_DECREF(x); /* can't do it */
856 }
857 }
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000858
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000859 if (z == Py_None)
860 PyErr_Format(
861 PyExc_TypeError,
862 "unsupported operand type(s) for ** or pow(): "
863 "'%.100s' and '%.100s'",
864 v->ob_type->tp_name,
865 w->ob_type->tp_name);
866 else
867 PyErr_Format(
868 PyExc_TypeError,
869 "unsupported operand type(s) for pow(): "
870 "'%.100s', '%.100s', '%.100s'",
871 v->ob_type->tp_name,
872 w->ob_type->tp_name,
873 z->ob_type->tp_name);
874 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +0000875}
876
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000877#define BINARY_FUNC(func, op, op_name) \
878 PyObject * \
879 func(PyObject *v, PyObject *w) { \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000880 return binary_op(v, w, NB_SLOT(op), op_name); \
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000881 }
Guido van Rossume15dee51995-07-18 14:12:02 +0000882
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000883BINARY_FUNC(PyNumber_Or, nb_or, "|")
884BINARY_FUNC(PyNumber_Xor, nb_xor, "^")
885BINARY_FUNC(PyNumber_And, nb_and, "&")
886BINARY_FUNC(PyNumber_Lshift, nb_lshift, "<<")
887BINARY_FUNC(PyNumber_Rshift, nb_rshift, ">>")
888BINARY_FUNC(PyNumber_Subtract, nb_subtract, "-")
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000889BINARY_FUNC(PyNumber_Divmod, nb_divmod, "divmod()")
Guido van Rossume15dee51995-07-18 14:12:02 +0000890
891PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000892PyNumber_Add(PyObject *v, PyObject *w)
Guido van Rossume15dee51995-07-18 14:12:02 +0000893{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000894 PyObject *result = binary_op1(v, w, NB_SLOT(nb_add));
895 if (result == Py_NotImplemented) {
896 PySequenceMethods *m = v->ob_type->tp_as_sequence;
897 Py_DECREF(result);
898 if (m && m->sq_concat) {
899 return (*m->sq_concat)(v, w);
900 }
901 result = binop_type_error(v, w, "+");
902 }
903 return result;
Guido van Rossume15dee51995-07-18 14:12:02 +0000904}
905
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000906static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000907sequence_repeat(ssizeargfunc repeatfunc, PyObject *seq, PyObject *n)
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000908{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000909 Py_ssize_t count;
910 if (PyIndex_Check(n)) {
911 count = PyNumber_AsSsize_t(n, PyExc_OverflowError);
912 if (count == -1 && PyErr_Occurred())
913 return NULL;
914 }
915 else {
916 return type_error("can't multiply sequence by "
917 "non-int of type '%.200s'", n);
918 }
919 return (*repeatfunc)(seq, count);
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000920}
921
922PyObject *
923PyNumber_Multiply(PyObject *v, PyObject *w)
924{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000925 PyObject *result = binary_op1(v, w, NB_SLOT(nb_multiply));
926 if (result == Py_NotImplemented) {
927 PySequenceMethods *mv = v->ob_type->tp_as_sequence;
928 PySequenceMethods *mw = w->ob_type->tp_as_sequence;
929 Py_DECREF(result);
930 if (mv && mv->sq_repeat) {
931 return sequence_repeat(mv->sq_repeat, v, w);
932 }
933 else if (mw && mw->sq_repeat) {
934 return sequence_repeat(mw->sq_repeat, w, v);
935 }
936 result = binop_type_error(v, w, "*");
937 }
938 return result;
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000939}
940
Guido van Rossume15dee51995-07-18 14:12:02 +0000941PyObject *
Benjamin Petersond51374e2014-04-09 23:55:56 -0400942PyNumber_MatrixMultiply(PyObject *v, PyObject *w)
943{
944 return binary_op(v, w, NB_SLOT(nb_matrix_multiply), "@");
945}
946
947PyObject *
Guido van Rossum4668b002001-08-08 05:00:18 +0000948PyNumber_FloorDivide(PyObject *v, PyObject *w)
949{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000950 return binary_op(v, w, NB_SLOT(nb_floor_divide), "//");
Guido van Rossum4668b002001-08-08 05:00:18 +0000951}
952
953PyObject *
954PyNumber_TrueDivide(PyObject *v, PyObject *w)
955{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000956 return binary_op(v, w, NB_SLOT(nb_true_divide), "/");
Guido van Rossum4668b002001-08-08 05:00:18 +0000957}
958
959PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000960PyNumber_Remainder(PyObject *v, PyObject *w)
Guido van Rossume15dee51995-07-18 14:12:02 +0000961{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000962 return binary_op(v, w, NB_SLOT(nb_remainder), "%");
Guido van Rossume15dee51995-07-18 14:12:02 +0000963}
964
965PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000966PyNumber_Power(PyObject *v, PyObject *w, PyObject *z)
Guido van Rossume15dee51995-07-18 14:12:02 +0000967{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000968 return ternary_op(v, w, z, NB_SLOT(nb_power), "** or pow()");
Guido van Rossume15dee51995-07-18 14:12:02 +0000969}
970
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000971/* Binary in-place operators */
972
973/* The in-place operators are defined to fall back to the 'normal',
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000974 non in-place operations, if the in-place methods are not in place.
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000975
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000976 - If the left hand object has the appropriate struct members, and
977 they are filled, call the appropriate function and return the
978 result. No coercion is done on the arguments; the left-hand object
979 is the one the operation is performed on, and it's up to the
980 function to deal with the right-hand object.
Guido van Rossum77660912002-04-16 16:32:50 +0000981
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000982 - Otherwise, in-place modification is not supported. Handle it exactly as
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000983 a non in-place operation of the same kind.
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000984
985 */
986
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000987static PyObject *
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000988binary_iop1(PyObject *v, PyObject *w, const int iop_slot, const int op_slot)
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000989{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000990 PyNumberMethods *mv = v->ob_type->tp_as_number;
991 if (mv != NULL) {
992 binaryfunc slot = NB_BINOP(mv, iop_slot);
993 if (slot) {
994 PyObject *x = (slot)(v, w);
995 if (x != Py_NotImplemented) {
996 return x;
997 }
998 Py_DECREF(x);
999 }
1000 }
1001 return binary_op1(v, w, op_slot);
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +00001002}
1003
1004static PyObject *
1005binary_iop(PyObject *v, PyObject *w, const int iop_slot, const int op_slot,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001006 const char *op_name)
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +00001007{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001008 PyObject *result = binary_iop1(v, w, iop_slot, op_slot);
1009 if (result == Py_NotImplemented) {
1010 Py_DECREF(result);
1011 return binop_type_error(v, w, op_name);
1012 }
1013 return result;
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001014}
1015
Neil Schemenauer5a1f0152001-01-04 01:39:06 +00001016#define INPLACE_BINOP(func, iop, op, op_name) \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001017 PyObject * \
1018 func(PyObject *v, PyObject *w) { \
1019 return binary_iop(v, w, NB_SLOT(iop), NB_SLOT(op), op_name); \
1020 }
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001021
Neil Schemenauer5a1f0152001-01-04 01:39:06 +00001022INPLACE_BINOP(PyNumber_InPlaceOr, nb_inplace_or, nb_or, "|=")
1023INPLACE_BINOP(PyNumber_InPlaceXor, nb_inplace_xor, nb_xor, "^=")
1024INPLACE_BINOP(PyNumber_InPlaceAnd, nb_inplace_and, nb_and, "&=")
1025INPLACE_BINOP(PyNumber_InPlaceLshift, nb_inplace_lshift, nb_lshift, "<<=")
1026INPLACE_BINOP(PyNumber_InPlaceRshift, nb_inplace_rshift, nb_rshift, ">>=")
1027INPLACE_BINOP(PyNumber_InPlaceSubtract, nb_inplace_subtract, nb_subtract, "-=")
Benjamin Petersond51374e2014-04-09 23:55:56 -04001028INPLACE_BINOP(PyNumber_InMatrixMultiply, nb_inplace_matrix_multiply, nb_matrix_multiply, "@=")
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001029
1030PyObject *
Guido van Rossum4668b002001-08-08 05:00:18 +00001031PyNumber_InPlaceFloorDivide(PyObject *v, PyObject *w)
1032{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001033 return binary_iop(v, w, NB_SLOT(nb_inplace_floor_divide),
1034 NB_SLOT(nb_floor_divide), "//=");
Guido van Rossum4668b002001-08-08 05:00:18 +00001035}
1036
1037PyObject *
1038PyNumber_InPlaceTrueDivide(PyObject *v, PyObject *w)
1039{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001040 return binary_iop(v, w, NB_SLOT(nb_inplace_true_divide),
1041 NB_SLOT(nb_true_divide), "/=");
Guido van Rossum4668b002001-08-08 05:00:18 +00001042}
1043
1044PyObject *
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001045PyNumber_InPlaceAdd(PyObject *v, PyObject *w)
1046{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001047 PyObject *result = binary_iop1(v, w, NB_SLOT(nb_inplace_add),
1048 NB_SLOT(nb_add));
1049 if (result == Py_NotImplemented) {
1050 PySequenceMethods *m = v->ob_type->tp_as_sequence;
1051 Py_DECREF(result);
1052 if (m != NULL) {
1053 binaryfunc f = NULL;
1054 f = m->sq_inplace_concat;
1055 if (f == NULL)
1056 f = m->sq_concat;
1057 if (f != NULL)
1058 return (*f)(v, w);
1059 }
1060 result = binop_type_error(v, w, "+=");
1061 }
1062 return result;
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001063}
1064
1065PyObject *
1066PyNumber_InPlaceMultiply(PyObject *v, PyObject *w)
1067{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001068 PyObject *result = binary_iop1(v, w, NB_SLOT(nb_inplace_multiply),
1069 NB_SLOT(nb_multiply));
1070 if (result == Py_NotImplemented) {
1071 ssizeargfunc f = NULL;
1072 PySequenceMethods *mv = v->ob_type->tp_as_sequence;
1073 PySequenceMethods *mw = w->ob_type->tp_as_sequence;
1074 Py_DECREF(result);
1075 if (mv != NULL) {
1076 f = mv->sq_inplace_repeat;
1077 if (f == NULL)
1078 f = mv->sq_repeat;
1079 if (f != NULL)
1080 return sequence_repeat(f, v, w);
1081 }
1082 else if (mw != NULL) {
1083 /* Note that the right hand operand should not be
1084 * mutated in this case so sq_inplace_repeat is not
1085 * used. */
1086 if (mw->sq_repeat)
1087 return sequence_repeat(mw->sq_repeat, w, v);
1088 }
1089 result = binop_type_error(v, w, "*=");
1090 }
1091 return result;
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001092}
1093
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001094PyObject *
Benjamin Petersond51374e2014-04-09 23:55:56 -04001095PyNumber_InPlaceMatrixMultiply(PyObject *v, PyObject *w)
1096{
1097 return binary_iop(v, w, NB_SLOT(nb_inplace_matrix_multiply),
1098 NB_SLOT(nb_matrix_multiply), "@=");
1099}
1100
1101PyObject *
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001102PyNumber_InPlaceRemainder(PyObject *v, PyObject *w)
1103{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001104 return binary_iop(v, w, NB_SLOT(nb_inplace_remainder),
1105 NB_SLOT(nb_remainder), "%=");
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001106}
1107
1108PyObject *
1109PyNumber_InPlacePower(PyObject *v, PyObject *w, PyObject *z)
1110{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001111 if (v->ob_type->tp_as_number &&
1112 v->ob_type->tp_as_number->nb_inplace_power != NULL) {
1113 return ternary_op(v, w, z, NB_SLOT(nb_inplace_power), "**=");
1114 }
1115 else {
1116 return ternary_op(v, w, z, NB_SLOT(nb_power), "**=");
1117 }
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001118}
1119
1120
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001121/* Unary operators and functions */
Guido van Rossume15dee51995-07-18 14:12:02 +00001122
1123PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001124PyNumber_Negative(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001125{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001126 PyNumberMethods *m;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001127
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001128 if (o == NULL)
1129 return null_error();
1130 m = o->ob_type->tp_as_number;
1131 if (m && m->nb_negative)
1132 return (*m->nb_negative)(o);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001133
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001134 return type_error("bad operand type for unary -: '%.200s'", o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001135}
1136
1137PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001138PyNumber_Positive(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001139{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001140 PyNumberMethods *m;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001141
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001142 if (o == NULL)
1143 return null_error();
1144 m = o->ob_type->tp_as_number;
1145 if (m && m->nb_positive)
1146 return (*m->nb_positive)(o);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001147
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001148 return type_error("bad operand type for unary +: '%.200s'", o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001149}
1150
1151PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001152PyNumber_Invert(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001153{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001154 PyNumberMethods *m;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001155
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001156 if (o == NULL)
1157 return null_error();
1158 m = o->ob_type->tp_as_number;
1159 if (m && m->nb_invert)
1160 return (*m->nb_invert)(o);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001161
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001162 return type_error("bad operand type for unary ~: '%.200s'", o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001163}
1164
1165PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001166PyNumber_Absolute(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001167{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001168 PyNumberMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001169
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001170 if (o == NULL)
1171 return null_error();
1172 m = o->ob_type->tp_as_number;
1173 if (m && m->nb_absolute)
1174 return m->nb_absolute(o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001175
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001176 return type_error("bad operand type for abs(): '%.200s'", o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001177}
1178
Serhiy Storchaka31a65542013-12-11 21:07:54 +02001179/* Return a Python int from the object item.
Serhiy Storchaka95949422013-08-27 19:40:23 +03001180 Raise TypeError if the result is not an int
Guido van Rossum98297ee2007-11-06 21:34:58 +00001181 or if the object cannot be interpreted as an index.
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00001182*/
1183PyObject *
Guido van Rossum38fff8c2006-03-07 18:50:55 +00001184PyNumber_Index(PyObject *item)
1185{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001186 PyObject *result = NULL;
1187 if (item == NULL)
1188 return null_error();
1189 if (PyLong_Check(item)) {
1190 Py_INCREF(item);
1191 return item;
1192 }
Serhiy Storchaka31a65542013-12-11 21:07:54 +02001193 if (!PyIndex_Check(item)) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001194 PyErr_Format(PyExc_TypeError,
1195 "'%.200s' object cannot be interpreted "
1196 "as an integer", item->ob_type->tp_name);
Serhiy Storchaka31a65542013-12-11 21:07:54 +02001197 return NULL;
1198 }
1199 result = item->ob_type->tp_as_number->nb_index(item);
1200 if (!result || PyLong_CheckExact(result))
1201 return result;
1202 if (!PyLong_Check(result)) {
1203 PyErr_Format(PyExc_TypeError,
1204 "__index__ returned non-int (type %.200s)",
1205 result->ob_type->tp_name);
1206 Py_DECREF(result);
1207 return NULL;
1208 }
1209 /* Issue #17576: warn if 'result' not of exact type int. */
1210 if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
1211 "__index__ returned non-int (type %.200s). "
1212 "The ability to return an instance of a strict subclass of int "
1213 "is deprecated, and may be removed in a future version of Python.",
1214 result->ob_type->tp_name)) {
1215 Py_DECREF(result);
1216 return NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001217 }
1218 return result;
Guido van Rossum38fff8c2006-03-07 18:50:55 +00001219}
1220
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00001221/* Return an error on Overflow only if err is not NULL*/
1222
1223Py_ssize_t
1224PyNumber_AsSsize_t(PyObject *item, PyObject *err)
1225{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001226 Py_ssize_t result;
1227 PyObject *runerr;
1228 PyObject *value = PyNumber_Index(item);
1229 if (value == NULL)
1230 return -1;
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00001231
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001232 /* We're done if PyLong_AsSsize_t() returns without error. */
1233 result = PyLong_AsSsize_t(value);
1234 if (result != -1 || !(runerr = PyErr_Occurred()))
1235 goto finish;
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00001236
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001237 /* Error handling code -- only manage OverflowError differently */
1238 if (!PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError))
1239 goto finish;
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00001240
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001241 PyErr_Clear();
1242 /* If no error-handling desired then the default clipping
1243 is sufficient.
1244 */
1245 if (!err) {
1246 assert(PyLong_Check(value));
1247 /* Whether or not it is less than or equal to
1248 zero is determined by the sign of ob_size
1249 */
1250 if (_PyLong_Sign(value) < 0)
1251 result = PY_SSIZE_T_MIN;
1252 else
1253 result = PY_SSIZE_T_MAX;
1254 }
1255 else {
1256 /* Otherwise replace the error with caller's error object. */
1257 PyErr_Format(err,
1258 "cannot fit '%.200s' into an index-sized integer",
1259 item->ob_type->tp_name);
1260 }
Guido van Rossum98297ee2007-11-06 21:34:58 +00001261
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00001262 finish:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001263 Py_DECREF(value);
1264 return result;
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00001265}
1266
1267
Guido van Rossume15dee51995-07-18 14:12:02 +00001268PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001269PyNumber_Long(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001270{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001271 PyNumberMethods *m;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001272 PyObject *trunc_func;
Serhiy Storchaka4fdb6842015-02-03 01:21:08 +02001273 Py_buffer view;
Benjamin Peterson9fc9bf42012-03-20 23:26:41 -04001274 _Py_IDENTIFIER(__trunc__);
Christian Heimes15ebc882008-02-04 18:48:49 +00001275
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001276 if (o == NULL)
1277 return null_error();
1278 if (PyLong_CheckExact(o)) {
1279 Py_INCREF(o);
1280 return o;
1281 }
1282 m = o->ob_type->tp_as_number;
1283 if (m && m->nb_int) { /* This should include subclasses of int */
Serhiy Storchaka31a65542013-12-11 21:07:54 +02001284 return (PyObject *)_PyLong_FromNbInt(o);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001285 }
Benjamin Peterson1b1a8e72012-03-20 23:48:11 -04001286 trunc_func = _PyObject_LookupSpecial(o, &PyId___trunc__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001287 if (trunc_func) {
1288 PyObject *truncated = PyEval_CallObject(trunc_func, NULL);
1289 PyObject *int_instance;
1290 Py_DECREF(trunc_func);
Serhiy Storchaka31a65542013-12-11 21:07:54 +02001291 if (truncated == NULL || PyLong_Check(truncated))
1292 return truncated;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001293 /* __trunc__ is specified to return an Integral type,
Martin Panter7462b6492015-11-02 03:37:02 +00001294 but int() needs to return an int. */
Serhiy Storchaka31a65542013-12-11 21:07:54 +02001295 m = truncated->ob_type->tp_as_number;
1296 if (m == NULL || m->nb_int == NULL) {
1297 PyErr_Format(
1298 PyExc_TypeError,
1299 "__trunc__ returned non-Integral (type %.200s)",
1300 truncated->ob_type->tp_name);
1301 Py_DECREF(truncated);
1302 return NULL;
1303 }
1304 int_instance = (PyObject *)_PyLong_FromNbInt(truncated);
1305 Py_DECREF(truncated);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001306 return int_instance;
1307 }
Benjamin Peterson1b1a8e72012-03-20 23:48:11 -04001308 if (PyErr_Occurred())
1309 return NULL;
Christian Heimes15ebc882008-02-04 18:48:49 +00001310
Serhiy Storchaka4fdb6842015-02-03 01:21:08 +02001311 if (PyUnicode_Check(o))
1312 /* The below check is done in PyLong_FromUnicode(). */
1313 return PyLong_FromUnicodeObject(o, 10);
1314
1315 if (PyObject_GetBuffer(o, &view, PyBUF_SIMPLE) == 0) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001316 /* need to do extra error checking that PyLong_FromString()
Serhiy Storchakaf6d0aee2013-08-03 20:55:06 +03001317 * doesn't do. In particular int('9\x005') must raise an
1318 * exception, not truncate at the null.
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001319 */
Serhiy Storchaka4fdb6842015-02-03 01:21:08 +02001320 PyObject *result = _PyLong_FromBytes(view.buf, view.len, 10);
1321 PyBuffer_Release(&view);
1322 return result;
1323 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001324
Serhiy Storchaka4fdb6842015-02-03 01:21:08 +02001325 return type_error("int() argument must be a string, a bytes-like object "
1326 "or a number, not '%.200s'", o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001327}
1328
1329PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001330PyNumber_Float(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001331{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001332 PyNumberMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001333
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001334 if (o == NULL)
1335 return null_error();
1336 m = o->ob_type->tp_as_number;
1337 if (m && m->nb_float) { /* This should include subclasses of float */
1338 PyObject *res = m->nb_float(o);
1339 if (res && !PyFloat_Check(res)) {
1340 PyErr_Format(PyExc_TypeError,
1341 "__float__ returned non-float (type %.200s)",
1342 res->ob_type->tp_name);
1343 Py_DECREF(res);
1344 return NULL;
1345 }
1346 return res;
1347 }
1348 if (PyFloat_Check(o)) { /* A float subclass with nb_float == NULL */
1349 PyFloatObject *po = (PyFloatObject *)o;
1350 return PyFloat_FromDouble(po->ob_fval);
1351 }
1352 return PyFloat_FromString(o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001353}
1354
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001355
1356PyObject *
1357PyNumber_ToBase(PyObject *n, int base)
1358{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001359 PyObject *res = NULL;
1360 PyObject *index = PyNumber_Index(n);
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001361
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001362 if (!index)
1363 return NULL;
1364 if (PyLong_Check(index))
1365 res = _PyLong_Format(index, base);
1366 else
1367 /* It should not be possible to get here, as
1368 PyNumber_Index already has a check for the same
1369 condition */
Serhiy Storchaka95949422013-08-27 19:40:23 +03001370 PyErr_SetString(PyExc_ValueError, "PyNumber_ToBase: index not int");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001371 Py_DECREF(index);
1372 return res;
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001373}
1374
1375
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001376/* Operations on sequences */
Guido van Rossume15dee51995-07-18 14:12:02 +00001377
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001378int
Fred Drake79912472000-07-09 04:06:11 +00001379PySequence_Check(PyObject *s)
Guido van Rossume15dee51995-07-18 14:12:02 +00001380{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001381 if (PyDict_Check(s))
1382 return 0;
1383 return s != NULL && s->ob_type->tp_as_sequence &&
1384 s->ob_type->tp_as_sequence->sq_item != NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +00001385}
1386
Martin v. Löwis18e16552006-02-15 17:27:45 +00001387Py_ssize_t
Jeremy Hylton6253f832000-07-12 12:56:19 +00001388PySequence_Size(PyObject *s)
Guido van Rossume15dee51995-07-18 14:12:02 +00001389{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001390 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001391
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001392 if (s == NULL) {
1393 null_error();
1394 return -1;
1395 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001396
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001397 m = s->ob_type->tp_as_sequence;
1398 if (m && m->sq_length)
1399 return m->sq_length(s);
Guido van Rossume15dee51995-07-18 14:12:02 +00001400
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001401 type_error("object of type '%.200s' has no len()", s);
1402 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +00001403}
1404
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +00001405#undef PySequence_Length
Martin v. Löwis18e16552006-02-15 17:27:45 +00001406Py_ssize_t
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +00001407PySequence_Length(PyObject *s)
1408{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001409 return PySequence_Size(s);
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +00001410}
1411#define PySequence_Length PySequence_Size
1412
Guido van Rossume15dee51995-07-18 14:12:02 +00001413PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001414PySequence_Concat(PyObject *s, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001415{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001416 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001417
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001418 if (s == NULL || o == NULL)
1419 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001420
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001421 m = s->ob_type->tp_as_sequence;
1422 if (m && m->sq_concat)
1423 return m->sq_concat(s, o);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001424
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001425 /* Instances of user classes defining an __add__() method only
1426 have an nb_add slot, not an sq_concat slot. So we fall back
1427 to nb_add if both arguments appear to be sequences. */
1428 if (PySequence_Check(s) && PySequence_Check(o)) {
1429 PyObject *result = binary_op1(s, o, NB_SLOT(nb_add));
1430 if (result != Py_NotImplemented)
1431 return result;
1432 Py_DECREF(result);
1433 }
1434 return type_error("'%.200s' object can't be concatenated", s);
Guido van Rossume15dee51995-07-18 14:12:02 +00001435}
1436
1437PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +00001438PySequence_Repeat(PyObject *o, Py_ssize_t count)
Guido van Rossume15dee51995-07-18 14:12:02 +00001439{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001440 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001441
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001442 if (o == NULL)
1443 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001444
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001445 m = o->ob_type->tp_as_sequence;
1446 if (m && m->sq_repeat)
1447 return m->sq_repeat(o, count);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001448
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001449 /* Instances of user classes defining a __mul__() method only
1450 have an nb_multiply slot, not an sq_repeat slot. so we fall back
1451 to nb_multiply if o appears to be a sequence. */
1452 if (PySequence_Check(o)) {
1453 PyObject *n, *result;
1454 n = PyLong_FromSsize_t(count);
1455 if (n == NULL)
1456 return NULL;
1457 result = binary_op1(o, n, NB_SLOT(nb_multiply));
1458 Py_DECREF(n);
1459 if (result != Py_NotImplemented)
1460 return result;
1461 Py_DECREF(result);
1462 }
1463 return type_error("'%.200s' object can't be repeated", o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001464}
1465
1466PyObject *
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001467PySequence_InPlaceConcat(PyObject *s, PyObject *o)
1468{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001469 PySequenceMethods *m;
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001470
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001471 if (s == NULL || o == NULL)
1472 return null_error();
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001473
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001474 m = s->ob_type->tp_as_sequence;
1475 if (m && m->sq_inplace_concat)
1476 return m->sq_inplace_concat(s, o);
1477 if (m && m->sq_concat)
1478 return m->sq_concat(s, o);
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001479
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001480 if (PySequence_Check(s) && PySequence_Check(o)) {
1481 PyObject *result = binary_iop1(s, o, NB_SLOT(nb_inplace_add),
1482 NB_SLOT(nb_add));
1483 if (result != Py_NotImplemented)
1484 return result;
1485 Py_DECREF(result);
1486 }
1487 return type_error("'%.200s' object can't be concatenated", s);
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001488}
1489
1490PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +00001491PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count)
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001492{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001493 PySequenceMethods *m;
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001494
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001495 if (o == NULL)
1496 return null_error();
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001497
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001498 m = o->ob_type->tp_as_sequence;
1499 if (m && m->sq_inplace_repeat)
1500 return m->sq_inplace_repeat(o, count);
1501 if (m && m->sq_repeat)
1502 return m->sq_repeat(o, count);
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001503
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001504 if (PySequence_Check(o)) {
1505 PyObject *n, *result;
1506 n = PyLong_FromSsize_t(count);
1507 if (n == NULL)
1508 return NULL;
1509 result = binary_iop1(o, n, NB_SLOT(nb_inplace_multiply),
1510 NB_SLOT(nb_multiply));
1511 Py_DECREF(n);
1512 if (result != Py_NotImplemented)
1513 return result;
1514 Py_DECREF(result);
1515 }
1516 return type_error("'%.200s' object can't be repeated", o);
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001517}
1518
1519PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +00001520PySequence_GetItem(PyObject *s, Py_ssize_t i)
Guido van Rossume15dee51995-07-18 14:12:02 +00001521{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001522 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001523
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001524 if (s == NULL)
1525 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001526
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001527 m = s->ob_type->tp_as_sequence;
1528 if (m && m->sq_item) {
1529 if (i < 0) {
1530 if (m->sq_length) {
1531 Py_ssize_t l = (*m->sq_length)(s);
Victor Stinnere20310f2015-11-05 13:56:58 +01001532 if (l < 0) {
1533 assert(PyErr_Occurred());
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001534 return NULL;
Victor Stinnere20310f2015-11-05 13:56:58 +01001535 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001536 i += l;
1537 }
1538 }
1539 return m->sq_item(s, i);
1540 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001541
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001542 return type_error("'%.200s' object does not support indexing", s);
Guido van Rossume15dee51995-07-18 14:12:02 +00001543}
1544
1545PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +00001546PySequence_GetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2)
Guido van Rossume15dee51995-07-18 14:12:02 +00001547{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001548 PyMappingMethods *mp;
Guido van Rossume15dee51995-07-18 14:12:02 +00001549
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001550 if (!s) return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001551
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001552 mp = s->ob_type->tp_as_mapping;
Benjamin Peterson568867a2010-09-11 16:02:03 +00001553 if (mp && mp->mp_subscript) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001554 PyObject *res;
1555 PyObject *slice = _PySlice_FromIndices(i1, i2);
1556 if (!slice)
1557 return NULL;
1558 res = mp->mp_subscript(s, slice);
1559 Py_DECREF(slice);
1560 return res;
1561 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001562
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001563 return type_error("'%.200s' object is unsliceable", s);
Guido van Rossume15dee51995-07-18 14:12:02 +00001564}
1565
1566int
Martin v. Löwis18e16552006-02-15 17:27:45 +00001567PySequence_SetItem(PyObject *s, Py_ssize_t i, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001568{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001569 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001570
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001571 if (s == NULL) {
1572 null_error();
1573 return -1;
1574 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001575
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001576 m = s->ob_type->tp_as_sequence;
1577 if (m && m->sq_ass_item) {
1578 if (i < 0) {
1579 if (m->sq_length) {
1580 Py_ssize_t l = (*m->sq_length)(s);
1581 if (l < 0)
1582 return -1;
1583 i += l;
1584 }
1585 }
1586 return m->sq_ass_item(s, i, o);
1587 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001588
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001589 type_error("'%.200s' object does not support item assignment", s);
1590 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +00001591}
1592
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001593int
Martin v. Löwis18e16552006-02-15 17:27:45 +00001594PySequence_DelItem(PyObject *s, Py_ssize_t i)
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001595{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001596 PySequenceMethods *m;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001597
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001598 if (s == NULL) {
1599 null_error();
1600 return -1;
1601 }
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001602
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001603 m = s->ob_type->tp_as_sequence;
1604 if (m && m->sq_ass_item) {
1605 if (i < 0) {
1606 if (m->sq_length) {
1607 Py_ssize_t l = (*m->sq_length)(s);
1608 if (l < 0)
1609 return -1;
1610 i += l;
1611 }
1612 }
1613 return m->sq_ass_item(s, i, (PyObject *)NULL);
1614 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001615
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001616 type_error("'%.200s' object doesn't support item deletion", s);
1617 return -1;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001618}
1619
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001620int
Martin v. Löwis18e16552006-02-15 17:27:45 +00001621PySequence_SetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001622{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001623 PyMappingMethods *mp;
Guido van Rossume15dee51995-07-18 14:12:02 +00001624
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001625 if (s == NULL) {
1626 null_error();
1627 return -1;
1628 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001629
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001630 mp = s->ob_type->tp_as_mapping;
Benjamin Peterson568867a2010-09-11 16:02:03 +00001631 if (mp && mp->mp_ass_subscript) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001632 int res;
1633 PyObject *slice = _PySlice_FromIndices(i1, i2);
1634 if (!slice)
1635 return -1;
1636 res = mp->mp_ass_subscript(s, slice, o);
1637 Py_DECREF(slice);
1638 return res;
1639 }
Thomas Wouters1d75a792000-08-17 22:37:32 +00001640
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001641 type_error("'%.200s' object doesn't support slice assignment", s);
1642 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +00001643}
1644
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001645int
Martin v. Löwis18e16552006-02-15 17:27:45 +00001646PySequence_DelSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2)
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001647{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001648 PyMappingMethods *mp;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001649
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001650 if (s == NULL) {
1651 null_error();
1652 return -1;
1653 }
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001654
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001655 mp = s->ob_type->tp_as_mapping;
Benjamin Peterson568867a2010-09-11 16:02:03 +00001656 if (mp && mp->mp_ass_subscript) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001657 int res;
1658 PyObject *slice = _PySlice_FromIndices(i1, i2);
1659 if (!slice)
1660 return -1;
1661 res = mp->mp_ass_subscript(s, slice, NULL);
1662 Py_DECREF(slice);
1663 return res;
1664 }
1665 type_error("'%.200s' object doesn't support slice deletion", s);
1666 return -1;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001667}
1668
Guido van Rossume15dee51995-07-18 14:12:02 +00001669PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001670PySequence_Tuple(PyObject *v)
Guido van Rossume15dee51995-07-18 14:12:02 +00001671{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001672 PyObject *it; /* iter(v) */
1673 Py_ssize_t n; /* guess for result tuple size */
1674 PyObject *result = NULL;
1675 Py_ssize_t j;
Guido van Rossume15dee51995-07-18 14:12:02 +00001676
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001677 if (v == NULL)
1678 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001679
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001680 /* Special-case the common tuple and list cases, for efficiency. */
1681 if (PyTuple_CheckExact(v)) {
1682 /* Note that we can't know whether it's safe to return
1683 a tuple *subclass* instance as-is, hence the restriction
1684 to exact tuples here. In contrast, lists always make
1685 a copy, so there's no need for exactness below. */
1686 Py_INCREF(v);
1687 return v;
1688 }
Raymond Hettinger610a51f2015-05-17 14:45:58 -07001689 if (PyList_CheckExact(v))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001690 return PyList_AsTuple(v);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001691
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001692 /* Get iterator. */
1693 it = PyObject_GetIter(v);
1694 if (it == NULL)
1695 return NULL;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001696
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001697 /* Guess result size and allocate space. */
Armin Ronacheraa9a79d2012-10-06 14:03:24 +02001698 n = PyObject_LengthHint(v, 10);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001699 if (n == -1)
1700 goto Fail;
1701 result = PyTuple_New(n);
1702 if (result == NULL)
1703 goto Fail;
Tim Peters6912d4d2001-05-05 03:56:37 +00001704
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001705 /* Fill the tuple. */
1706 for (j = 0; ; ++j) {
1707 PyObject *item = PyIter_Next(it);
1708 if (item == NULL) {
1709 if (PyErr_Occurred())
1710 goto Fail;
1711 break;
1712 }
1713 if (j >= n) {
1714 Py_ssize_t oldn = n;
1715 /* The over-allocation strategy can grow a bit faster
1716 than for lists because unlike lists the
1717 over-allocation isn't permanent -- we reclaim
1718 the excess before the end of this routine.
1719 So, grow by ten and then add 25%.
1720 */
1721 n += 10;
1722 n += n >> 2;
1723 if (n < oldn) {
1724 /* Check for overflow */
1725 PyErr_NoMemory();
1726 Py_DECREF(item);
1727 goto Fail;
1728 }
1729 if (_PyTuple_Resize(&result, n) != 0) {
1730 Py_DECREF(item);
1731 goto Fail;
1732 }
1733 }
1734 PyTuple_SET_ITEM(result, j, item);
1735 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001736
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001737 /* Cut tuple back if guess was too large. */
1738 if (j < n &&
1739 _PyTuple_Resize(&result, j) != 0)
1740 goto Fail;
Tim Peters6912d4d2001-05-05 03:56:37 +00001741
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001742 Py_DECREF(it);
1743 return result;
Tim Peters6912d4d2001-05-05 03:56:37 +00001744
1745Fail:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001746 Py_XDECREF(result);
1747 Py_DECREF(it);
1748 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +00001749}
1750
Guido van Rossum3c5936a1996-12-05 21:51:24 +00001751PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001752PySequence_List(PyObject *v)
Guido van Rossum3c5936a1996-12-05 21:51:24 +00001753{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001754 PyObject *result; /* result list */
1755 PyObject *rv; /* return value from PyList_Extend */
Guido van Rossum4669fb41997-04-02 05:31:09 +00001756
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001757 if (v == NULL)
1758 return null_error();
Guido van Rossum5dba9e81998-07-10 18:03:50 +00001759
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001760 result = PyList_New(0);
1761 if (result == NULL)
1762 return NULL;
Tim Petersf553f892001-05-01 20:45:31 +00001763
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001764 rv = _PyList_Extend((PyListObject *)result, v);
1765 if (rv == NULL) {
1766 Py_DECREF(result);
1767 return NULL;
1768 }
1769 Py_DECREF(rv);
1770 return result;
Guido van Rossum3c5936a1996-12-05 21:51:24 +00001771}
1772
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001773PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001774PySequence_Fast(PyObject *v, const char *m)
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001775{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001776 PyObject *it;
Raymond Hettinger2fb70292004-01-11 23:26:51 +00001777
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001778 if (v == NULL)
1779 return null_error();
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001780
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001781 if (PyList_CheckExact(v) || PyTuple_CheckExact(v)) {
1782 Py_INCREF(v);
1783 return v;
1784 }
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001785
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001786 it = PyObject_GetIter(v);
1787 if (it == NULL) {
1788 if (PyErr_ExceptionMatches(PyExc_TypeError))
1789 PyErr_SetString(PyExc_TypeError, m);
1790 return NULL;
1791 }
Raymond Hettinger2fb70292004-01-11 23:26:51 +00001792
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001793 v = PySequence_List(it);
1794 Py_DECREF(it);
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001795
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001796 return v;
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001797}
1798
Tim Peters16a77ad2001-09-08 04:00:12 +00001799/* Iterate over seq. Result depends on the operation:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001800 PY_ITERSEARCH_COUNT: -1 if error, else # of times obj appears in seq.
1801 PY_ITERSEARCH_INDEX: 0-based index of first occurrence of obj in seq;
1802 set ValueError and return -1 if none found; also return -1 on error.
Tim Peters16a77ad2001-09-08 04:00:12 +00001803 Py_ITERSEARCH_CONTAINS: return 1 if obj in seq, else 0; -1 on error.
1804*/
Neal Norwitz1fc4b772006-03-04 18:49:58 +00001805Py_ssize_t
Tim Peters16a77ad2001-09-08 04:00:12 +00001806_PySequence_IterSearch(PyObject *seq, PyObject *obj, int operation)
Guido van Rossume15dee51995-07-18 14:12:02 +00001807{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001808 Py_ssize_t n;
1809 int wrapped; /* for PY_ITERSEARCH_INDEX, true iff n wrapped around */
1810 PyObject *it; /* iter(seq) */
Guido van Rossume15dee51995-07-18 14:12:02 +00001811
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001812 if (seq == NULL || obj == NULL) {
1813 null_error();
1814 return -1;
1815 }
Tim Peters75f8e352001-05-05 11:33:43 +00001816
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001817 it = PyObject_GetIter(seq);
1818 if (it == NULL) {
1819 type_error("argument of type '%.200s' is not iterable", seq);
1820 return -1;
1821 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001822
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001823 n = wrapped = 0;
1824 for (;;) {
1825 int cmp;
1826 PyObject *item = PyIter_Next(it);
1827 if (item == NULL) {
1828 if (PyErr_Occurred())
1829 goto Fail;
1830 break;
1831 }
Tim Peters16a77ad2001-09-08 04:00:12 +00001832
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001833 cmp = PyObject_RichCompareBool(obj, item, Py_EQ);
1834 Py_DECREF(item);
1835 if (cmp < 0)
1836 goto Fail;
1837 if (cmp > 0) {
1838 switch (operation) {
1839 case PY_ITERSEARCH_COUNT:
1840 if (n == PY_SSIZE_T_MAX) {
1841 PyErr_SetString(PyExc_OverflowError,
1842 "count exceeds C integer size");
1843 goto Fail;
1844 }
1845 ++n;
1846 break;
Tim Peters16a77ad2001-09-08 04:00:12 +00001847
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001848 case PY_ITERSEARCH_INDEX:
1849 if (wrapped) {
1850 PyErr_SetString(PyExc_OverflowError,
1851 "index exceeds C integer size");
1852 goto Fail;
1853 }
1854 goto Done;
Tim Peters16a77ad2001-09-08 04:00:12 +00001855
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001856 case PY_ITERSEARCH_CONTAINS:
1857 n = 1;
1858 goto Done;
Tim Peters16a77ad2001-09-08 04:00:12 +00001859
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001860 default:
1861 assert(!"unknown operation");
1862 }
1863 }
Tim Peters16a77ad2001-09-08 04:00:12 +00001864
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001865 if (operation == PY_ITERSEARCH_INDEX) {
1866 if (n == PY_SSIZE_T_MAX)
1867 wrapped = 1;
1868 ++n;
1869 }
1870 }
Tim Peters16a77ad2001-09-08 04:00:12 +00001871
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001872 if (operation != PY_ITERSEARCH_INDEX)
1873 goto Done;
Tim Peters16a77ad2001-09-08 04:00:12 +00001874
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001875 PyErr_SetString(PyExc_ValueError,
1876 "sequence.index(x): x not in sequence");
1877 /* fall into failure code */
Tim Peters16a77ad2001-09-08 04:00:12 +00001878Fail:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001879 n = -1;
1880 /* fall through */
Tim Peters16a77ad2001-09-08 04:00:12 +00001881Done:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001882 Py_DECREF(it);
1883 return n;
Tim Peters75f8e352001-05-05 11:33:43 +00001884
Guido van Rossume15dee51995-07-18 14:12:02 +00001885}
1886
Tim Peters16a77ad2001-09-08 04:00:12 +00001887/* Return # of times o appears in s. */
Neal Norwitz1fc4b772006-03-04 18:49:58 +00001888Py_ssize_t
Tim Peters16a77ad2001-09-08 04:00:12 +00001889PySequence_Count(PyObject *s, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001890{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001891 return _PySequence_IterSearch(s, o, PY_ITERSEARCH_COUNT);
Guido van Rossume15dee51995-07-18 14:12:02 +00001892}
1893
Tim Peterscb8d3682001-05-05 21:05:01 +00001894/* Return -1 if error; 1 if ob in seq; 0 if ob not in seq.
Tim Peters16a77ad2001-09-08 04:00:12 +00001895 * Use sq_contains if possible, else defer to _PySequence_IterSearch().
Tim Peterscb8d3682001-05-05 21:05:01 +00001896 */
1897int
1898PySequence_Contains(PyObject *seq, PyObject *ob)
1899{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001900 Py_ssize_t result;
1901 PySequenceMethods *sqm = seq->ob_type->tp_as_sequence;
1902 if (sqm != NULL && sqm->sq_contains != NULL)
1903 return (*sqm->sq_contains)(seq, ob);
1904 result = _PySequence_IterSearch(seq, ob, PY_ITERSEARCH_CONTAINS);
1905 return Py_SAFE_DOWNCAST(result, Py_ssize_t, int);
Tim Peterscb8d3682001-05-05 21:05:01 +00001906}
1907
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001908/* Backwards compatibility */
1909#undef PySequence_In
1910int
Fred Drake79912472000-07-09 04:06:11 +00001911PySequence_In(PyObject *w, PyObject *v)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001912{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001913 return PySequence_Contains(w, v);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001914}
1915
Neal Norwitz1fc4b772006-03-04 18:49:58 +00001916Py_ssize_t
Fred Drake79912472000-07-09 04:06:11 +00001917PySequence_Index(PyObject *s, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001918{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001919 return _PySequence_IterSearch(s, o, PY_ITERSEARCH_INDEX);
Guido van Rossume15dee51995-07-18 14:12:02 +00001920}
1921
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001922/* Operations on mappings */
1923
1924int
Fred Drake79912472000-07-09 04:06:11 +00001925PyMapping_Check(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001926{
Benjamin Peterson21992272011-12-28 12:01:31 -06001927 return o && o->ob_type->tp_as_mapping &&
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001928 o->ob_type->tp_as_mapping->mp_subscript;
Guido van Rossume15dee51995-07-18 14:12:02 +00001929}
1930
Martin v. Löwis18e16552006-02-15 17:27:45 +00001931Py_ssize_t
Jeremy Hylton6253f832000-07-12 12:56:19 +00001932PyMapping_Size(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001933{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001934 PyMappingMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001935
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001936 if (o == NULL) {
1937 null_error();
1938 return -1;
1939 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001940
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001941 m = o->ob_type->tp_as_mapping;
1942 if (m && m->mp_length)
1943 return m->mp_length(o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001944
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001945 type_error("object of type '%.200s' has no len()", o);
1946 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +00001947}
1948
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +00001949#undef PyMapping_Length
Martin v. Löwis18e16552006-02-15 17:27:45 +00001950Py_ssize_t
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +00001951PyMapping_Length(PyObject *o)
1952{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001953 return PyMapping_Size(o);
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +00001954}
1955#define PyMapping_Length PyMapping_Size
1956
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001957PyObject *
Serhiy Storchakac6792272013-10-19 21:03:34 +03001958PyMapping_GetItemString(PyObject *o, const char *key)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001959{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001960 PyObject *okey, *r;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001961
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001962 if (key == NULL)
1963 return null_error();
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001964
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001965 okey = PyUnicode_FromString(key);
1966 if (okey == NULL)
1967 return NULL;
1968 r = PyObject_GetItem(o, okey);
1969 Py_DECREF(okey);
1970 return r;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001971}
1972
1973int
Serhiy Storchakac6792272013-10-19 21:03:34 +03001974PyMapping_SetItemString(PyObject *o, const char *key, PyObject *value)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001975{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001976 PyObject *okey;
1977 int r;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001978
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001979 if (key == NULL) {
1980 null_error();
1981 return -1;
1982 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001983
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001984 okey = PyUnicode_FromString(key);
1985 if (okey == NULL)
1986 return -1;
1987 r = PyObject_SetItem(o, okey, value);
1988 Py_DECREF(okey);
1989 return r;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001990}
1991
1992int
Serhiy Storchakac6792272013-10-19 21:03:34 +03001993PyMapping_HasKeyString(PyObject *o, const char *key)
Guido van Rossume15dee51995-07-18 14:12:02 +00001994{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001995 PyObject *v;
Guido van Rossume15dee51995-07-18 14:12:02 +00001996
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001997 v = PyMapping_GetItemString(o, key);
1998 if (v) {
1999 Py_DECREF(v);
2000 return 1;
2001 }
2002 PyErr_Clear();
2003 return 0;
Guido van Rossume15dee51995-07-18 14:12:02 +00002004}
2005
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002006int
Fred Drake79912472000-07-09 04:06:11 +00002007PyMapping_HasKey(PyObject *o, PyObject *key)
Guido van Rossume15dee51995-07-18 14:12:02 +00002008{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002009 PyObject *v;
Guido van Rossume15dee51995-07-18 14:12:02 +00002010
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002011 v = PyObject_GetItem(o, key);
2012 if (v) {
2013 Py_DECREF(v);
2014 return 1;
2015 }
2016 PyErr_Clear();
2017 return 0;
Guido van Rossume15dee51995-07-18 14:12:02 +00002018}
2019
Guido van Rossumcc2b0162007-02-11 06:12:03 +00002020PyObject *
2021PyMapping_Keys(PyObject *o)
2022{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002023 PyObject *keys;
2024 PyObject *fast;
Martin v. Löwisbd928fe2011-10-14 10:20:37 +02002025 _Py_IDENTIFIER(keys);
Guido van Rossumcc2b0162007-02-11 06:12:03 +00002026
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002027 if (PyDict_CheckExact(o))
2028 return PyDict_Keys(o);
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002029 keys = _PyObject_CallMethodId(o, &PyId_keys, NULL);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002030 if (keys == NULL)
2031 return NULL;
2032 fast = PySequence_Fast(keys, "o.keys() are not iterable");
2033 Py_DECREF(keys);
2034 return fast;
Guido van Rossumcc2b0162007-02-11 06:12:03 +00002035}
2036
2037PyObject *
2038PyMapping_Items(PyObject *o)
2039{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002040 PyObject *items;
2041 PyObject *fast;
Martin v. Löwisbd928fe2011-10-14 10:20:37 +02002042 _Py_IDENTIFIER(items);
Guido van Rossumcc2b0162007-02-11 06:12:03 +00002043
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002044 if (PyDict_CheckExact(o))
2045 return PyDict_Items(o);
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002046 items = _PyObject_CallMethodId(o, &PyId_items, NULL);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002047 if (items == NULL)
2048 return NULL;
2049 fast = PySequence_Fast(items, "o.items() are not iterable");
2050 Py_DECREF(items);
2051 return fast;
Guido van Rossumcc2b0162007-02-11 06:12:03 +00002052}
2053
2054PyObject *
2055PyMapping_Values(PyObject *o)
2056{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002057 PyObject *values;
2058 PyObject *fast;
Martin v. Löwisbd928fe2011-10-14 10:20:37 +02002059 _Py_IDENTIFIER(values);
Guido van Rossumcc2b0162007-02-11 06:12:03 +00002060
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002061 if (PyDict_CheckExact(o))
2062 return PyDict_Values(o);
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002063 values = _PyObject_CallMethodId(o, &PyId_values, NULL);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002064 if (values == NULL)
2065 return NULL;
2066 fast = PySequence_Fast(values, "o.values() are not iterable");
2067 Py_DECREF(values);
2068 return fast;
Guido van Rossumcc2b0162007-02-11 06:12:03 +00002069}
2070
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002071/* Operations on callable objects */
2072
2073/* XXX PyCallable_Check() is in object.c */
2074
Guido van Rossume15dee51995-07-18 14:12:02 +00002075PyObject *
Fred Drake79912472000-07-09 04:06:11 +00002076PyObject_CallObject(PyObject *o, PyObject *a)
Guido van Rossume15dee51995-07-18 14:12:02 +00002077{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002078 return PyEval_CallObjectWithKeywords(o, a, NULL);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002079}
Guido van Rossume15dee51995-07-18 14:12:02 +00002080
Victor Stinner4a7cc882015-03-06 23:35:27 +01002081PyObject*
Victor Stinnerefde1462015-03-21 15:04:43 +01002082_Py_CheckFunctionResult(PyObject *func, PyObject *result, const char *where)
Victor Stinner4a7cc882015-03-06 23:35:27 +01002083{
2084 int err_occurred = (PyErr_Occurred() != NULL);
2085
Victor Stinnerefde1462015-03-21 15:04:43 +01002086 assert((func != NULL) ^ (where != NULL));
2087
Victor Stinner4a7cc882015-03-06 23:35:27 +01002088 if (result == NULL) {
2089 if (!err_occurred) {
Victor Stinnerefde1462015-03-21 15:04:43 +01002090 if (func)
2091 PyErr_Format(PyExc_SystemError,
2092 "%R returned NULL without setting an error",
2093 func);
2094 else
2095 PyErr_Format(PyExc_SystemError,
2096 "%s returned NULL without setting an error",
2097 where);
Victor Stinner944fbcc2015-03-24 16:28:52 +01002098#ifdef Py_DEBUG
2099 /* Ensure that the bug is catched in debug mode */
2100 Py_FatalError("a function returned NULL without setting an error");
2101#endif
2102 return NULL;
Victor Stinner4a7cc882015-03-06 23:35:27 +01002103 }
2104 }
2105 else {
2106 if (err_occurred) {
2107 PyObject *exc, *val, *tb;
2108 PyErr_Fetch(&exc, &val, &tb);
2109
2110 Py_DECREF(result);
2111
Victor Stinnerefde1462015-03-21 15:04:43 +01002112 if (func)
2113 PyErr_Format(PyExc_SystemError,
2114 "%R returned a result with an error set",
2115 func);
2116 else
2117 PyErr_Format(PyExc_SystemError,
2118 "%s returned a result with an error set",
2119 where);
Victor Stinner4a7cc882015-03-06 23:35:27 +01002120 _PyErr_ChainExceptions(exc, val, tb);
Victor Stinner944fbcc2015-03-24 16:28:52 +01002121#ifdef Py_DEBUG
2122 /* Ensure that the bug is catched in debug mode */
2123 Py_FatalError("a function returned a result with an error set");
2124#endif
2125 return NULL;
Victor Stinner4a7cc882015-03-06 23:35:27 +01002126 }
2127 }
2128 return result;
2129}
2130
Guido van Rossume15dee51995-07-18 14:12:02 +00002131PyObject *
Tim Peters6d6c1a32001-08-02 04:15:00 +00002132PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw)
2133{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002134 ternaryfunc call;
Victor Stinner4a7cc882015-03-06 23:35:27 +01002135 PyObject *result;
Tim Peters6d6c1a32001-08-02 04:15:00 +00002136
Victor Stinner8f4ec8d2014-09-05 01:10:29 +02002137 /* PyObject_Call() must not be called with an exception set,
2138 because it may clear it (directly or indirectly) and so the
Martin Panterec1aa5c2015-10-07 11:03:53 +00002139 caller loses its exception */
Victor Stinner8f4ec8d2014-09-05 01:10:29 +02002140 assert(!PyErr_Occurred());
2141
Victor Stinner4a7cc882015-03-06 23:35:27 +01002142 call = func->ob_type->tp_call;
2143 if (call == NULL) {
2144 PyErr_Format(PyExc_TypeError, "'%.200s' object is not callable",
2145 func->ob_type->tp_name);
2146 return NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002147 }
Victor Stinner4a7cc882015-03-06 23:35:27 +01002148
2149 if (Py_EnterRecursiveCall(" while calling a Python object"))
2150 return NULL;
2151
2152 result = (*call)(func, arg, kw);
2153
2154 Py_LeaveRecursiveCall();
2155
Victor Stinnerefde1462015-03-21 15:04:43 +01002156 return _Py_CheckFunctionResult(func, result, NULL);
Tim Peters6d6c1a32001-08-02 04:15:00 +00002157}
2158
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002159static PyObject*
2160call_function_tail(PyObject *callable, PyObject *args)
2161{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002162 PyObject *retval;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002163
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002164 if (args == NULL)
2165 return NULL;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002166
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002167 if (!PyTuple_Check(args)) {
2168 PyObject *a;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002169
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002170 a = PyTuple_New(1);
2171 if (a == NULL) {
2172 Py_DECREF(args);
2173 return NULL;
2174 }
2175 PyTuple_SET_ITEM(a, 0, args);
2176 args = a;
2177 }
2178 retval = PyObject_Call(callable, args, NULL);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002179
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002180 Py_DECREF(args);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002181
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002182 return retval;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002183}
2184
Tim Peters6d6c1a32001-08-02 04:15:00 +00002185PyObject *
Serhiy Storchaka1cfebc72013-05-29 18:50:54 +03002186PyObject_CallFunction(PyObject *callable, const char *format, ...)
Guido van Rossume15dee51995-07-18 14:12:02 +00002187{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002188 va_list va;
2189 PyObject *args;
Guido van Rossume15dee51995-07-18 14:12:02 +00002190
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002191 if (callable == NULL)
2192 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00002193
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002194 if (format && *format) {
2195 va_start(va, format);
2196 args = Py_VaBuildValue(format, va);
2197 va_end(va);
2198 }
2199 else
2200 args = PyTuple_New(0);
Victor Stinner0b0c8672013-10-29 19:29:52 +01002201 if (args == NULL)
2202 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +00002203
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002204 return call_function_tail(callable, args);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002205}
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002206
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002207PyObject *
Serhiy Storchaka1cfebc72013-05-29 18:50:54 +03002208_PyObject_CallFunction_SizeT(PyObject *callable, const char *format, ...)
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002209{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002210 va_list va;
2211 PyObject *args;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002212
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002213 if (callable == NULL)
2214 return null_error();
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002215
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002216 if (format && *format) {
2217 va_start(va, format);
2218 args = _Py_VaBuildValue_SizeT(format, va);
2219 va_end(va);
2220 }
2221 else
2222 args = PyTuple_New(0);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002223
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002224 return call_function_tail(callable, args);
Guido van Rossume15dee51995-07-18 14:12:02 +00002225}
2226
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002227static PyObject*
Serhiy Storchaka1cfebc72013-05-29 18:50:54 +03002228callmethod(PyObject* func, const char *format, va_list va, int is_size_t)
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002229{
2230 PyObject *retval = NULL;
2231 PyObject *args;
2232
2233 if (!PyCallable_Check(func)) {
2234 type_error("attribute of type '%.200s' is not callable", func);
2235 goto exit;
2236 }
2237
2238 if (format && *format) {
2239 if (is_size_t)
2240 args = _Py_VaBuildValue_SizeT(format, va);
2241 else
2242 args = Py_VaBuildValue(format, va);
2243 }
2244 else
2245 args = PyTuple_New(0);
2246
2247 retval = call_function_tail(func, args);
2248
2249 exit:
2250 /* args gets consumed in call_function_tail */
2251 Py_XDECREF(func);
2252
2253 return retval;
2254}
2255
Guido van Rossume15dee51995-07-18 14:12:02 +00002256PyObject *
Serhiy Storchaka1cfebc72013-05-29 18:50:54 +03002257PyObject_CallMethod(PyObject *o, const char *name, const char *format, ...)
Guido van Rossume15dee51995-07-18 14:12:02 +00002258{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002259 va_list va;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002260 PyObject *func = NULL;
2261 PyObject *retval = NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +00002262
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002263 if (o == NULL || name == NULL)
2264 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00002265
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002266 func = PyObject_GetAttrString(o, name);
Benjamin Peterson1791c222014-06-26 23:29:13 -07002267 if (func == NULL)
2268 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +00002269
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002270 va_start(va, format);
2271 retval = callmethod(func, format, va, 0);
2272 va_end(va);
2273 return retval;
2274}
2275
2276PyObject *
Serhiy Storchaka1cfebc72013-05-29 18:50:54 +03002277_PyObject_CallMethodId(PyObject *o, _Py_Identifier *name,
2278 const char *format, ...)
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002279{
2280 va_list va;
2281 PyObject *func = NULL;
2282 PyObject *retval = NULL;
2283
2284 if (o == NULL || name == NULL)
2285 return null_error();
2286
2287 func = _PyObject_GetAttrId(o, name);
Benjamin Peterson1791c222014-06-26 23:29:13 -07002288 if (func == NULL)
2289 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +00002290
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002291 va_start(va, format);
2292 retval = callmethod(func, format, va, 0);
2293 va_end(va);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002294 return retval;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002295}
2296
2297PyObject *
Serhiy Storchaka1cfebc72013-05-29 18:50:54 +03002298_PyObject_CallMethod_SizeT(PyObject *o, const char *name,
2299 const char *format, ...)
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002300{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002301 va_list va;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002302 PyObject *func = NULL;
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002303 PyObject *retval;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002304
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002305 if (o == NULL || name == NULL)
2306 return null_error();
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002307
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002308 func = PyObject_GetAttrString(o, name);
Benjamin Peterson1791c222014-06-26 23:29:13 -07002309 if (func == NULL)
2310 return NULL;
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002311 va_start(va, format);
2312 retval = callmethod(func, format, va, 1);
2313 va_end(va);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002314 return retval;
Guido van Rossume15dee51995-07-18 14:12:02 +00002315}
Guido van Rossum823649d2001-03-21 18:40:58 +00002316
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002317PyObject *
Serhiy Storchaka1cfebc72013-05-29 18:50:54 +03002318_PyObject_CallMethodId_SizeT(PyObject *o, _Py_Identifier *name,
2319 const char *format, ...)
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002320{
2321 va_list va;
2322 PyObject *func = NULL;
2323 PyObject *retval;
2324
2325 if (o == NULL || name == NULL)
2326 return null_error();
2327
2328 func = _PyObject_GetAttrId(o, name);
2329 if (func == NULL) {
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002330 return NULL;
2331 }
2332 va_start(va, format);
2333 retval = callmethod(func, format, va, 1);
2334 va_end(va);
2335 return retval;
2336}
Guido van Rossum823649d2001-03-21 18:40:58 +00002337
Fred Drakeb421b8c2001-10-26 16:21:32 +00002338static PyObject *
Fred Drakeb0c079e2001-10-28 02:39:03 +00002339objargs_mktuple(va_list va)
Fred Drakeb421b8c2001-10-26 16:21:32 +00002340{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002341 int i, n = 0;
2342 va_list countva;
2343 PyObject *result, *tmp;
Fred Drakeb421b8c2001-10-26 16:21:32 +00002344
Alexander Belopolskyf0f45142010-08-11 17:31:17 +00002345 Py_VA_COPY(countva, va);
Fred Drakeb421b8c2001-10-26 16:21:32 +00002346
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002347 while (((PyObject *)va_arg(countva, PyObject *)) != NULL)
2348 ++n;
2349 result = PyTuple_New(n);
2350 if (result != NULL && n > 0) {
2351 for (i = 0; i < n; ++i) {
2352 tmp = (PyObject *)va_arg(va, PyObject *);
2353 PyTuple_SET_ITEM(result, i, tmp);
2354 Py_INCREF(tmp);
2355 }
2356 }
2357 return result;
Fred Drakeb421b8c2001-10-26 16:21:32 +00002358}
2359
2360PyObject *
Fred Drakeb0c079e2001-10-28 02:39:03 +00002361PyObject_CallMethodObjArgs(PyObject *callable, PyObject *name, ...)
Fred Drakeb421b8c2001-10-26 16:21:32 +00002362{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002363 PyObject *args, *tmp;
2364 va_list vargs;
Fred Drakeb421b8c2001-10-26 16:21:32 +00002365
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002366 if (callable == NULL || name == NULL)
2367 return null_error();
Fred Drakeb421b8c2001-10-26 16:21:32 +00002368
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002369 callable = PyObject_GetAttr(callable, name);
2370 if (callable == NULL)
2371 return NULL;
Fred Drakeb421b8c2001-10-26 16:21:32 +00002372
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002373 /* count the args */
2374 va_start(vargs, name);
2375 args = objargs_mktuple(vargs);
2376 va_end(vargs);
2377 if (args == NULL) {
2378 Py_DECREF(callable);
2379 return NULL;
2380 }
2381 tmp = PyObject_Call(callable, args, NULL);
2382 Py_DECREF(args);
2383 Py_DECREF(callable);
Fred Drakeb421b8c2001-10-26 16:21:32 +00002384
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002385 return tmp;
Fred Drakeb421b8c2001-10-26 16:21:32 +00002386}
2387
2388PyObject *
Alexandre Vassalotti865eaa12013-05-02 10:44:04 -07002389_PyObject_CallMethodIdObjArgs(PyObject *callable,
Brett Cannonfd074152012-04-14 14:10:13 -04002390 struct _Py_Identifier *name, ...)
2391{
2392 PyObject *args, *tmp;
2393 va_list vargs;
2394
2395 if (callable == NULL || name == NULL)
2396 return null_error();
2397
2398 callable = _PyObject_GetAttrId(callable, name);
2399 if (callable == NULL)
2400 return NULL;
2401
2402 /* count the args */
2403 va_start(vargs, name);
2404 args = objargs_mktuple(vargs);
2405 va_end(vargs);
2406 if (args == NULL) {
2407 Py_DECREF(callable);
2408 return NULL;
2409 }
2410 tmp = PyObject_Call(callable, args, NULL);
2411 Py_DECREF(args);
2412 Py_DECREF(callable);
2413
2414 return tmp;
2415}
2416
2417PyObject *
Fred Drakeb0c079e2001-10-28 02:39:03 +00002418PyObject_CallFunctionObjArgs(PyObject *callable, ...)
Fred Drakeb421b8c2001-10-26 16:21:32 +00002419{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002420 PyObject *args, *tmp;
2421 va_list vargs;
Fred Drakeb421b8c2001-10-26 16:21:32 +00002422
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002423 if (callable == NULL)
2424 return null_error();
Fred Drakeb421b8c2001-10-26 16:21:32 +00002425
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002426 /* count the args */
2427 va_start(vargs, callable);
2428 args = objargs_mktuple(vargs);
2429 va_end(vargs);
2430 if (args == NULL)
2431 return NULL;
2432 tmp = PyObject_Call(callable, args, NULL);
2433 Py_DECREF(args);
Fred Drakeb421b8c2001-10-26 16:21:32 +00002434
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002435 return tmp;
Fred Drakeb421b8c2001-10-26 16:21:32 +00002436}
2437
2438
Guido van Rossum823649d2001-03-21 18:40:58 +00002439/* isinstance(), issubclass() */
2440
Benjamin Peterson9fc9bf42012-03-20 23:26:41 -04002441/* abstract_get_bases() has logically 4 return states:
Barry Warsawf16951c2002-04-23 22:45:44 +00002442 *
Barry Warsawf16951c2002-04-23 22:45:44 +00002443 * 1. getattr(cls, '__bases__') could raise an AttributeError
2444 * 2. getattr(cls, '__bases__') could raise some other exception
2445 * 3. getattr(cls, '__bases__') could return a tuple
2446 * 4. getattr(cls, '__bases__') could return something other than a tuple
2447 *
2448 * Only state #3 is a non-error state and only it returns a non-NULL object
2449 * (it returns the retrieved tuple).
2450 *
2451 * Any raised AttributeErrors are masked by clearing the exception and
2452 * returning NULL. If an object other than a tuple comes out of __bases__,
2453 * then again, the return value is NULL. So yes, these two situations
2454 * produce exactly the same results: NULL is returned and no error is set.
2455 *
2456 * If some exception other than AttributeError is raised, then NULL is also
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002457 * returned, but the exception is not cleared. That's because we want the
Barry Warsawf16951c2002-04-23 22:45:44 +00002458 * exception to be propagated along.
2459 *
2460 * Callers are expected to test for PyErr_Occurred() when the return value
2461 * is NULL to decide whether a valid exception should be propagated or not.
2462 * When there's no exception to propagate, it's customary for the caller to
2463 * set a TypeError.
2464 */
Neil Schemenauer6b471292001-10-18 03:18:43 +00002465static PyObject *
2466abstract_get_bases(PyObject *cls)
Guido van Rossum823649d2001-03-21 18:40:58 +00002467{
Benjamin Peterson9fc9bf42012-03-20 23:26:41 -04002468 _Py_IDENTIFIER(__bases__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002469 PyObject *bases;
Guido van Rossum823649d2001-03-21 18:40:58 +00002470
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002471 Py_ALLOW_RECURSION
Benjamin Peterson9fc9bf42012-03-20 23:26:41 -04002472 bases = _PyObject_GetAttrId(cls, &PyId___bases__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002473 Py_END_ALLOW_RECURSION
2474 if (bases == NULL) {
2475 if (PyErr_ExceptionMatches(PyExc_AttributeError))
2476 PyErr_Clear();
2477 return NULL;
2478 }
2479 if (!PyTuple_Check(bases)) {
2480 Py_DECREF(bases);
2481 return NULL;
2482 }
2483 return bases;
Neil Schemenauer6b471292001-10-18 03:18:43 +00002484}
2485
2486
2487static int
2488abstract_issubclass(PyObject *derived, PyObject *cls)
2489{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002490 PyObject *bases = NULL;
2491 Py_ssize_t i, n;
2492 int r = 0;
Neil Schemenauer6b471292001-10-18 03:18:43 +00002493
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002494 while (1) {
2495 if (derived == cls)
2496 return 1;
2497 bases = abstract_get_bases(derived);
2498 if (bases == NULL) {
2499 if (PyErr_Occurred())
2500 return -1;
2501 return 0;
2502 }
2503 n = PyTuple_GET_SIZE(bases);
2504 if (n == 0) {
2505 Py_DECREF(bases);
2506 return 0;
2507 }
2508 /* Avoid recursivity in the single inheritance case */
2509 if (n == 1) {
2510 derived = PyTuple_GET_ITEM(bases, 0);
2511 Py_DECREF(bases);
2512 continue;
2513 }
2514 for (i = 0; i < n; i++) {
2515 r = abstract_issubclass(PyTuple_GET_ITEM(bases, i), cls);
2516 if (r != 0)
2517 break;
2518 }
2519 Py_DECREF(bases);
2520 return r;
2521 }
Guido van Rossum823649d2001-03-21 18:40:58 +00002522}
2523
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00002524static int
2525check_class(PyObject *cls, const char *error)
2526{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002527 PyObject *bases = abstract_get_bases(cls);
2528 if (bases == NULL) {
2529 /* Do not mask errors. */
2530 if (!PyErr_Occurred())
2531 PyErr_SetString(PyExc_TypeError, error);
2532 return 0;
2533 }
2534 Py_DECREF(bases);
2535 return -1;
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00002536}
2537
Brett Cannon4f653312004-03-20 22:52:14 +00002538static int
Antoine Pitrouec569b72008-08-26 22:40:48 +00002539recursive_isinstance(PyObject *inst, PyObject *cls)
Guido van Rossum823649d2001-03-21 18:40:58 +00002540{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002541 PyObject *icls;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002542 int retval = 0;
Benjamin Peterson9fc9bf42012-03-20 23:26:41 -04002543 _Py_IDENTIFIER(__class__);
Guido van Rossum03bc7d32003-02-12 03:32:58 +00002544
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002545 if (PyType_Check(cls)) {
2546 retval = PyObject_TypeCheck(inst, (PyTypeObject *)cls);
2547 if (retval == 0) {
Benjamin Peterson9fc9bf42012-03-20 23:26:41 -04002548 PyObject *c = _PyObject_GetAttrId(inst, &PyId___class__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002549 if (c == NULL) {
Benjamin Peterson72288d42010-11-20 17:21:08 +00002550 if (PyErr_ExceptionMatches(PyExc_AttributeError))
R. David Murray6bb99892010-11-20 16:33:30 +00002551 PyErr_Clear();
Benjamin Peterson72288d42010-11-20 17:21:08 +00002552 else
R. David Murray6bb99892010-11-20 16:33:30 +00002553 retval = -1;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002554 }
2555 else {
2556 if (c != (PyObject *)(inst->ob_type) &&
2557 PyType_Check(c))
2558 retval = PyType_IsSubtype(
2559 (PyTypeObject *)c,
2560 (PyTypeObject *)cls);
2561 Py_DECREF(c);
2562 }
2563 }
2564 }
2565 else {
2566 if (!check_class(cls,
Benjamin Petersone893af52010-06-28 19:43:42 +00002567 "isinstance() arg 2 must be a type or tuple of types"))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002568 return -1;
Benjamin Peterson9fc9bf42012-03-20 23:26:41 -04002569 icls = _PyObject_GetAttrId(inst, &PyId___class__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002570 if (icls == NULL) {
Benjamin Peterson72288d42010-11-20 17:21:08 +00002571 if (PyErr_ExceptionMatches(PyExc_AttributeError))
R. David Murray6bb99892010-11-20 16:33:30 +00002572 PyErr_Clear();
Benjamin Peterson72288d42010-11-20 17:21:08 +00002573 else
R. David Murray6bb99892010-11-20 16:33:30 +00002574 retval = -1;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002575 }
2576 else {
2577 retval = abstract_issubclass(icls, cls);
2578 Py_DECREF(icls);
2579 }
2580 }
Guido van Rossum823649d2001-03-21 18:40:58 +00002581
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002582 return retval;
Guido van Rossum823649d2001-03-21 18:40:58 +00002583}
2584
2585int
Brett Cannon4f653312004-03-20 22:52:14 +00002586PyObject_IsInstance(PyObject *inst, PyObject *cls)
2587{
Benjamin Petersonce798522012-01-22 11:24:29 -05002588 _Py_IDENTIFIER(__instancecheck__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002589 PyObject *checker;
Christian Heimesd5e2b6f2008-03-19 21:50:51 +00002590
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002591 /* Quick test for an exact match */
2592 if (Py_TYPE(inst) == (PyTypeObject *)cls)
2593 return 1;
Christian Heimesd5e2b6f2008-03-19 21:50:51 +00002594
Georg Brandl72b8a802014-10-03 09:26:37 +02002595 /* We know what type's __instancecheck__ does. */
2596 if (PyType_CheckExact(cls)) {
2597 return recursive_isinstance(inst, cls);
2598 }
2599
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002600 if (PyTuple_Check(cls)) {
2601 Py_ssize_t i;
2602 Py_ssize_t n;
2603 int r = 0;
Antoine Pitrouec569b72008-08-26 22:40:48 +00002604
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002605 if (Py_EnterRecursiveCall(" in __instancecheck__"))
2606 return -1;
2607 n = PyTuple_GET_SIZE(cls);
2608 for (i = 0; i < n; ++i) {
2609 PyObject *item = PyTuple_GET_ITEM(cls, i);
2610 r = PyObject_IsInstance(inst, item);
2611 if (r != 0)
2612 /* either found it, or got an error */
2613 break;
2614 }
2615 Py_LeaveRecursiveCall();
2616 return r;
2617 }
Benjamin Peterson88fe5f92009-05-16 21:55:24 +00002618
Benjamin Petersonce798522012-01-22 11:24:29 -05002619 checker = _PyObject_LookupSpecial(cls, &PyId___instancecheck__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002620 if (checker != NULL) {
2621 PyObject *res;
2622 int ok = -1;
2623 if (Py_EnterRecursiveCall(" in __instancecheck__")) {
2624 Py_DECREF(checker);
2625 return ok;
2626 }
2627 res = PyObject_CallFunctionObjArgs(checker, inst, NULL);
2628 Py_LeaveRecursiveCall();
2629 Py_DECREF(checker);
2630 if (res != NULL) {
2631 ok = PyObject_IsTrue(res);
2632 Py_DECREF(res);
2633 }
2634 return ok;
2635 }
2636 else if (PyErr_Occurred())
2637 return -1;
Georg Brandl72b8a802014-10-03 09:26:37 +02002638 /* Probably never reached anymore. */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002639 return recursive_isinstance(inst, cls);
Brett Cannon4f653312004-03-20 22:52:14 +00002640}
2641
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002642static int
Antoine Pitrouec569b72008-08-26 22:40:48 +00002643recursive_issubclass(PyObject *derived, PyObject *cls)
Guido van Rossum823649d2001-03-21 18:40:58 +00002644{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002645 if (PyType_Check(cls) && PyType_Check(derived)) {
2646 /* Fast path (non-recursive) */
2647 return PyType_IsSubtype((PyTypeObject *)derived, (PyTypeObject *)cls);
2648 }
2649 if (!check_class(derived,
2650 "issubclass() arg 1 must be a class"))
2651 return -1;
2652 if (!check_class(cls,
2653 "issubclass() arg 2 must be a class"
2654 " or tuple of classes"))
2655 return -1;
Guido van Rossum823649d2001-03-21 18:40:58 +00002656
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002657 return abstract_issubclass(derived, cls);
Guido van Rossum823649d2001-03-21 18:40:58 +00002658}
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002659
Brett Cannon4f653312004-03-20 22:52:14 +00002660int
2661PyObject_IsSubclass(PyObject *derived, PyObject *cls)
2662{
Benjamin Petersonce798522012-01-22 11:24:29 -05002663 _Py_IDENTIFIER(__subclasscheck__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002664 PyObject *checker;
Georg Brandldcfe8e42009-05-17 08:22:45 +00002665
Georg Brandl72b8a802014-10-03 09:26:37 +02002666 /* We know what type's __subclasscheck__ does. */
2667 if (PyType_CheckExact(cls)) {
2668 /* Quick test for an exact match */
2669 if (derived == cls)
2670 return 1;
2671 return recursive_issubclass(derived, cls);
2672 }
2673
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002674 if (PyTuple_Check(cls)) {
2675 Py_ssize_t i;
2676 Py_ssize_t n;
2677 int r = 0;
Antoine Pitrouec569b72008-08-26 22:40:48 +00002678
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002679 if (Py_EnterRecursiveCall(" in __subclasscheck__"))
2680 return -1;
2681 n = PyTuple_GET_SIZE(cls);
2682 for (i = 0; i < n; ++i) {
2683 PyObject *item = PyTuple_GET_ITEM(cls, i);
2684 r = PyObject_IsSubclass(derived, item);
2685 if (r != 0)
2686 /* either found it, or got an error */
2687 break;
2688 }
2689 Py_LeaveRecursiveCall();
2690 return r;
2691 }
Benjamin Peterson88fe5f92009-05-16 21:55:24 +00002692
Benjamin Petersonce798522012-01-22 11:24:29 -05002693 checker = _PyObject_LookupSpecial(cls, &PyId___subclasscheck__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002694 if (checker != NULL) {
2695 PyObject *res;
2696 int ok = -1;
2697 if (Py_EnterRecursiveCall(" in __subclasscheck__")) {
2698 Py_DECREF(checker);
2699 return ok;
2700 }
2701 res = PyObject_CallFunctionObjArgs(checker, derived, NULL);
2702 Py_LeaveRecursiveCall();
2703 Py_DECREF(checker);
2704 if (res != NULL) {
2705 ok = PyObject_IsTrue(res);
2706 Py_DECREF(res);
2707 }
2708 return ok;
2709 }
2710 else if (PyErr_Occurred())
2711 return -1;
Georg Brandl72b8a802014-10-03 09:26:37 +02002712 /* Probably never reached anymore. */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002713 return recursive_issubclass(derived, cls);
Antoine Pitrouec569b72008-08-26 22:40:48 +00002714}
2715
2716int
2717_PyObject_RealIsInstance(PyObject *inst, PyObject *cls)
2718{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002719 return recursive_isinstance(inst, cls);
Antoine Pitrouec569b72008-08-26 22:40:48 +00002720}
2721
2722int
2723_PyObject_RealIsSubclass(PyObject *derived, PyObject *cls)
2724{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002725 return recursive_issubclass(derived, cls);
Brett Cannon4f653312004-03-20 22:52:14 +00002726}
2727
2728
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002729PyObject *
2730PyObject_GetIter(PyObject *o)
2731{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002732 PyTypeObject *t = o->ob_type;
2733 getiterfunc f = NULL;
2734 f = t->tp_iter;
2735 if (f == NULL) {
2736 if (PySequence_Check(o))
2737 return PySeqIter_New(o);
2738 return type_error("'%.200s' object is not iterable", o);
2739 }
2740 else {
2741 PyObject *res = (*f)(o);
2742 if (res != NULL && !PyIter_Check(res)) {
2743 PyErr_Format(PyExc_TypeError,
2744 "iter() returned non-iterator "
2745 "of type '%.100s'",
2746 res->ob_type->tp_name);
2747 Py_DECREF(res);
2748 res = NULL;
2749 }
2750 return res;
2751 }
Guido van Rossum213c7a62001-04-23 14:08:49 +00002752}
2753
Tim Petersf4848da2001-05-05 00:14:56 +00002754/* Return next item.
2755 * If an error occurs, return NULL. PyErr_Occurred() will be true.
2756 * If the iteration terminates normally, return NULL and clear the
2757 * PyExc_StopIteration exception (if it was set). PyErr_Occurred()
2758 * will be false.
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002759 * Else return the next object. PyErr_Occurred() will be false.
Tim Petersf4848da2001-05-05 00:14:56 +00002760 */
Guido van Rossum213c7a62001-04-23 14:08:49 +00002761PyObject *
2762PyIter_Next(PyObject *iter)
2763{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002764 PyObject *result;
2765 result = (*iter->ob_type->tp_iternext)(iter);
2766 if (result == NULL &&
2767 PyErr_Occurred() &&
2768 PyErr_ExceptionMatches(PyExc_StopIteration))
2769 PyErr_Clear();
2770 return result;
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002771}
Gregory P. Smithfb94c5f2010-03-14 06:49:55 +00002772
2773
2774/*
2775 * Flatten a sequence of bytes() objects into a C array of
2776 * NULL terminated string pointers with a NULL char* terminating the array.
2777 * (ie: an argv or env list)
2778 *
Victor Stinner0e2d3cf2013-07-07 17:22:41 +02002779 * Memory allocated for the returned list is allocated using PyMem_Malloc()
2780 * and MUST be freed by _Py_FreeCharPArray().
Gregory P. Smithfb94c5f2010-03-14 06:49:55 +00002781 */
2782char *const *
2783_PySequence_BytesToCharpArray(PyObject* self)
2784{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002785 char **array;
2786 Py_ssize_t i, argc;
2787 PyObject *item = NULL;
Victor Stinner0e2d3cf2013-07-07 17:22:41 +02002788 Py_ssize_t size;
Gregory P. Smithfb94c5f2010-03-14 06:49:55 +00002789
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002790 argc = PySequence_Size(self);
2791 if (argc == -1)
2792 return NULL;
Gregory P. Smithfb94c5f2010-03-14 06:49:55 +00002793
Stefan Krah7cacd2e2012-08-21 08:16:09 +02002794 assert(argc >= 0);
2795
2796 if ((size_t)argc > (PY_SSIZE_T_MAX-sizeof(char *)) / sizeof(char *)) {
2797 PyErr_NoMemory();
2798 return NULL;
2799 }
2800
Victor Stinner0e2d3cf2013-07-07 17:22:41 +02002801 array = PyMem_Malloc((argc + 1) * sizeof(char *));
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002802 if (array == NULL) {
2803 PyErr_NoMemory();
2804 return NULL;
2805 }
2806 for (i = 0; i < argc; ++i) {
2807 char *data;
2808 item = PySequence_GetItem(self, i);
Stefan Krahfd24f9e2012-08-20 11:04:24 +02002809 if (item == NULL) {
2810 /* NULL terminate before freeing. */
2811 array[i] = NULL;
2812 goto fail;
2813 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002814 data = PyBytes_AsString(item);
2815 if (data == NULL) {
2816 /* NULL terminate before freeing. */
2817 array[i] = NULL;
2818 goto fail;
2819 }
Victor Stinner0e2d3cf2013-07-07 17:22:41 +02002820 size = PyBytes_GET_SIZE(item) + 1;
2821 array[i] = PyMem_Malloc(size);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002822 if (!array[i]) {
2823 PyErr_NoMemory();
2824 goto fail;
2825 }
Victor Stinner0e2d3cf2013-07-07 17:22:41 +02002826 memcpy(array[i], data, size);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002827 Py_DECREF(item);
2828 }
2829 array[argc] = NULL;
Gregory P. Smithfb94c5f2010-03-14 06:49:55 +00002830
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002831 return array;
Gregory P. Smithfb94c5f2010-03-14 06:49:55 +00002832
2833fail:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002834 Py_XDECREF(item);
2835 _Py_FreeCharPArray(array);
2836 return NULL;
Gregory P. Smithfb94c5f2010-03-14 06:49:55 +00002837}
2838
2839
2840/* Free's a NULL terminated char** array of C strings. */
2841void
2842_Py_FreeCharPArray(char *const array[])
2843{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002844 Py_ssize_t i;
2845 for (i = 0; array[i] != NULL; ++i) {
Victor Stinner0e2d3cf2013-07-07 17:22:41 +02002846 PyMem_Free(array[i]);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002847 }
Victor Stinner0e2d3cf2013-07-07 17:22:41 +02002848 PyMem_Free((void*)array);
Gregory P. Smithfb94c5f2010-03-14 06:49:55 +00002849}