blob: 589d9e8fd9b067b0908292573cbffb009f0f63bb [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
Victor Stinner71aea8e2016-08-19 16:59:55 +020035 if (o == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000036 return null_error();
Victor Stinner71aea8e2016-08-19 16:59:55 +020037 }
38
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000039 v = (PyObject *)o->ob_type;
40 Py_INCREF(v);
41 return v;
Guido van Rossume15dee51995-07-18 14:12:02 +000042}
43
Martin v. Löwis18e16552006-02-15 17:27:45 +000044Py_ssize_t
Jeremy Hylton6253f832000-07-12 12:56:19 +000045PyObject_Size(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +000046{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000047 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +000048
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000049 if (o == NULL) {
50 null_error();
51 return -1;
52 }
Guido van Rossume15dee51995-07-18 14:12:02 +000053
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000054 m = o->ob_type->tp_as_sequence;
55 if (m && m->sq_length)
56 return m->sq_length(o);
Guido van Rossume15dee51995-07-18 14:12:02 +000057
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000058 return PyMapping_Size(o);
Guido van Rossume15dee51995-07-18 14:12:02 +000059}
60
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +000061#undef PyObject_Length
Martin v. Löwis18e16552006-02-15 17:27:45 +000062Py_ssize_t
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +000063PyObject_Length(PyObject *o)
64{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000065 return PyObject_Size(o);
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +000066}
67#define PyObject_Length PyObject_Size
68
Armin Ronacheraa9a79d2012-10-06 14:03:24 +020069int
70_PyObject_HasLen(PyObject *o) {
71 return (Py_TYPE(o)->tp_as_sequence && Py_TYPE(o)->tp_as_sequence->sq_length) ||
72 (Py_TYPE(o)->tp_as_mapping && Py_TYPE(o)->tp_as_mapping->mp_length);
73}
Raymond Hettinger6b27cda2005-09-24 21:23:05 +000074
Christian Heimes255f53b2007-12-08 15:33:56 +000075/* The length hint function returns a non-negative value from o.__len__()
Armin Ronacher74b38b12012-10-07 10:29:32 +020076 or o.__length_hint__(). If those methods aren't found the defaultvalue is
77 returned. If one of the calls fails with an exception other than TypeError
78 this function returns -1.
Christian Heimes255f53b2007-12-08 15:33:56 +000079*/
80
81Py_ssize_t
Armin Ronacheraa9a79d2012-10-06 14:03:24 +020082PyObject_LengthHint(PyObject *o, Py_ssize_t defaultvalue)
Christian Heimes255f53b2007-12-08 15:33:56 +000083{
Christian Heimesb70e8a12012-10-06 17:16:39 +020084 PyObject *hint, *result;
Christian Heimes6314d162012-10-06 17:13:29 +020085 Py_ssize_t res;
Benjamin Petersonce798522012-01-22 11:24:29 -050086 _Py_IDENTIFIER(__length_hint__);
Serhiy Storchakaf740d462013-10-24 23:19:51 +030087 if (_PyObject_HasLen(o)) {
88 res = PyObject_Length(o);
89 if (res < 0 && PyErr_Occurred()) {
90 if (!PyErr_ExceptionMatches(PyExc_TypeError)) {
91 return -1;
92 }
93 PyErr_Clear();
Armin Ronacheraa9a79d2012-10-06 14:03:24 +020094 }
Serhiy Storchakaf740d462013-10-24 23:19:51 +030095 else {
96 return res;
97 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000098 }
Christian Heimes6314d162012-10-06 17:13:29 +020099 hint = _PyObject_LookupSpecial(o, &PyId___length_hint__);
Armin Ronacheraa9a79d2012-10-06 14:03:24 +0200100 if (hint == NULL) {
101 if (PyErr_Occurred()) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000102 return -1;
Armin Ronacheraa9a79d2012-10-06 14:03:24 +0200103 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000104 return defaultvalue;
105 }
Victor Stinnerf17c3de2016-12-06 18:46:19 +0100106 result = _PyObject_CallNoArg(hint);
Armin Ronacheraa9a79d2012-10-06 14:03:24 +0200107 Py_DECREF(hint);
108 if (result == NULL) {
109 if (PyErr_ExceptionMatches(PyExc_TypeError)) {
110 PyErr_Clear();
111 return defaultvalue;
112 }
113 return -1;
114 }
115 else if (result == Py_NotImplemented) {
116 Py_DECREF(result);
117 return defaultvalue;
118 }
119 if (!PyLong_Check(result)) {
Armin Ronacher74b38b12012-10-07 10:29:32 +0200120 PyErr_Format(PyExc_TypeError, "__length_hint__ must be an integer, not %.100s",
Armin Ronacheraa9a79d2012-10-06 14:03:24 +0200121 Py_TYPE(result)->tp_name);
122 Py_DECREF(result);
123 return -1;
124 }
Armin Ronacher74b38b12012-10-07 10:29:32 +0200125 res = PyLong_AsSsize_t(result);
Armin Ronacheraa9a79d2012-10-06 14:03:24 +0200126 Py_DECREF(result);
Armin Ronacher74b38b12012-10-07 10:29:32 +0200127 if (res < 0 && PyErr_Occurred()) {
Armin Ronacheraa9a79d2012-10-06 14:03:24 +0200128 return -1;
129 }
Armin Ronacher74b38b12012-10-07 10:29:32 +0200130 if (res < 0) {
Armin Ronacheraa9a79d2012-10-06 14:03:24 +0200131 PyErr_Format(PyExc_ValueError, "__length_hint__() should return >= 0");
132 return -1;
133 }
Armin Ronacher74b38b12012-10-07 10:29:32 +0200134 return res;
Raymond Hettinger6b27cda2005-09-24 21:23:05 +0000135}
136
Guido van Rossume15dee51995-07-18 14:12:02 +0000137PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000138PyObject_GetItem(PyObject *o, PyObject *key)
Guido van Rossume15dee51995-07-18 14:12:02 +0000139{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000140 PyMappingMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +0000141
Victor Stinner71aea8e2016-08-19 16:59:55 +0200142 if (o == NULL || key == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000143 return null_error();
Victor Stinner71aea8e2016-08-19 16:59:55 +0200144 }
Guido van Rossume15dee51995-07-18 14:12:02 +0000145
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000146 m = o->ob_type->tp_as_mapping;
Victor Stinnere20310f2015-11-05 13:56:58 +0100147 if (m && m->mp_subscript) {
148 PyObject *item = m->mp_subscript(o, key);
149 assert((item != NULL) ^ (PyErr_Occurred() != NULL));
150 return item;
151 }
Guido van Rossume15dee51995-07-18 14:12:02 +0000152
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000153 if (o->ob_type->tp_as_sequence) {
154 if (PyIndex_Check(key)) {
155 Py_ssize_t key_value;
156 key_value = PyNumber_AsSsize_t(key, PyExc_IndexError);
157 if (key_value == -1 && PyErr_Occurred())
158 return NULL;
159 return PySequence_GetItem(o, key_value);
160 }
161 else if (o->ob_type->tp_as_sequence->sq_item)
162 return type_error("sequence index must "
163 "be integer, not '%.200s'", key);
164 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000165
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000166 return type_error("'%.200s' object is not subscriptable", o);
Guido van Rossume15dee51995-07-18 14:12:02 +0000167}
168
169int
Fred Drake79912472000-07-09 04:06:11 +0000170PyObject_SetItem(PyObject *o, PyObject *key, PyObject *value)
Guido van Rossume15dee51995-07-18 14:12:02 +0000171{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000172 PyMappingMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +0000173
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000174 if (o == NULL || key == NULL || value == NULL) {
175 null_error();
176 return -1;
177 }
178 m = o->ob_type->tp_as_mapping;
179 if (m && m->mp_ass_subscript)
180 return m->mp_ass_subscript(o, key, value);
Guido van Rossume15dee51995-07-18 14:12:02 +0000181
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000182 if (o->ob_type->tp_as_sequence) {
183 if (PyIndex_Check(key)) {
184 Py_ssize_t key_value;
185 key_value = PyNumber_AsSsize_t(key, PyExc_IndexError);
186 if (key_value == -1 && PyErr_Occurred())
187 return -1;
188 return PySequence_SetItem(o, key_value, value);
189 }
190 else if (o->ob_type->tp_as_sequence->sq_ass_item) {
191 type_error("sequence index must be "
192 "integer, not '%.200s'", key);
193 return -1;
194 }
195 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000196
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000197 type_error("'%.200s' object does not support item assignment", o);
198 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +0000199}
200
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000201int
Fred Drake79912472000-07-09 04:06:11 +0000202PyObject_DelItem(PyObject *o, PyObject *key)
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000203{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000204 PyMappingMethods *m;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000205
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000206 if (o == NULL || key == NULL) {
207 null_error();
208 return -1;
209 }
210 m = o->ob_type->tp_as_mapping;
211 if (m && m->mp_ass_subscript)
212 return m->mp_ass_subscript(o, key, (PyObject*)NULL);
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000213
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000214 if (o->ob_type->tp_as_sequence) {
215 if (PyIndex_Check(key)) {
216 Py_ssize_t key_value;
217 key_value = PyNumber_AsSsize_t(key, PyExc_IndexError);
218 if (key_value == -1 && PyErr_Occurred())
219 return -1;
220 return PySequence_DelItem(o, key_value);
221 }
222 else if (o->ob_type->tp_as_sequence->sq_ass_item) {
223 type_error("sequence index must be "
224 "integer, not '%.200s'", key);
225 return -1;
226 }
227 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000228
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000229 type_error("'%.200s' object does not support item deletion", o);
230 return -1;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000231}
232
Martin v. Löwisb0d71d02002-01-05 10:50:30 +0000233int
Serhiy Storchakac6792272013-10-19 21:03:34 +0300234PyObject_DelItemString(PyObject *o, const char *key)
Martin v. Löwisb0d71d02002-01-05 10:50:30 +0000235{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000236 PyObject *okey;
237 int ret;
Martin v. Löwisb0d71d02002-01-05 10:50:30 +0000238
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000239 if (o == NULL || key == NULL) {
240 null_error();
241 return -1;
242 }
243 okey = PyUnicode_FromString(key);
244 if (okey == NULL)
245 return -1;
246 ret = PyObject_DelItem(o, okey);
247 Py_DECREF(okey);
248 return ret;
Martin v. Löwisb0d71d02002-01-05 10:50:30 +0000249}
250
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000251/* We release the buffer right after use of this function which could
Guido van Rossum98297ee2007-11-06 21:34:58 +0000252 cause issues later on. Don't use these functions in new code.
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000253 */
Thomas Wouters73e5a5b2006-06-08 15:35:45 +0000254int
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000255PyObject_CheckReadBuffer(PyObject *obj)
256{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000257 PyBufferProcs *pb = obj->ob_type->tp_as_buffer;
258 Py_buffer view;
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000259
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000260 if (pb == NULL ||
261 pb->bf_getbuffer == NULL)
262 return 0;
263 if ((*pb->bf_getbuffer)(obj, &view, PyBUF_SIMPLE) == -1) {
264 PyErr_Clear();
265 return 0;
266 }
267 PyBuffer_Release(&view);
268 return 1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000269}
270
Serhiy Storchaka460bd0d2016-11-20 12:16:46 +0200271static int
272as_read_buffer(PyObject *obj, const void **buffer, Py_ssize_t *buffer_len)
Guido van Rossum4c08d552000-03-10 22:55:18 +0000273{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000274 Py_buffer view;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000275
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000276 if (obj == NULL || buffer == NULL || buffer_len == NULL) {
277 null_error();
278 return -1;
279 }
Serhiy Storchaka4fdb6842015-02-03 01:21:08 +0200280 if (PyObject_GetBuffer(obj, &view, PyBUF_SIMPLE) != 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000281 return -1;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000282
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000283 *buffer = view.buf;
284 *buffer_len = view.len;
Serhiy Storchaka4fdb6842015-02-03 01:21:08 +0200285 PyBuffer_Release(&view);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000286 return 0;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000287}
288
Serhiy Storchaka460bd0d2016-11-20 12:16:46 +0200289int
290PyObject_AsCharBuffer(PyObject *obj,
291 const char **buffer,
292 Py_ssize_t *buffer_len)
293{
294 return as_read_buffer(obj, (const void **)buffer, buffer_len);
295}
296
297int PyObject_AsReadBuffer(PyObject *obj,
298 const void **buffer,
299 Py_ssize_t *buffer_len)
300{
301 return as_read_buffer(obj, buffer, buffer_len);
302}
303
Guido van Rossum4c08d552000-03-10 22:55:18 +0000304int PyObject_AsWriteBuffer(PyObject *obj,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000305 void **buffer,
306 Py_ssize_t *buffer_len)
Guido van Rossum4c08d552000-03-10 22:55:18 +0000307{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000308 PyBufferProcs *pb;
309 Py_buffer view;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000310
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000311 if (obj == NULL || buffer == NULL || buffer_len == NULL) {
312 null_error();
313 return -1;
314 }
315 pb = obj->ob_type->tp_as_buffer;
316 if (pb == NULL ||
317 pb->bf_getbuffer == NULL ||
318 ((*pb->bf_getbuffer)(obj, &view, PyBUF_WRITABLE) != 0)) {
319 PyErr_SetString(PyExc_TypeError,
R David Murray861470c2014-10-05 11:47:01 -0400320 "expected a writable bytes-like object");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000321 return -1;
322 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000323
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000324 *buffer = view.buf;
325 *buffer_len = view.len;
Serhiy Storchaka4fdb6842015-02-03 01:21:08 +0200326 PyBuffer_Release(&view);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000327 return 0;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000328}
329
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000330/* Buffer C-API for Python 3.0 */
331
332int
Travis E. Oliphant8ae62b62007-09-23 02:00:13 +0000333PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000334{
Serhiy Storchaka4fdb6842015-02-03 01:21:08 +0200335 PyBufferProcs *pb = obj->ob_type->tp_as_buffer;
336
337 if (pb == NULL || pb->bf_getbuffer == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000338 PyErr_Format(PyExc_TypeError,
R David Murray861470c2014-10-05 11:47:01 -0400339 "a bytes-like object is required, not '%.100s'",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000340 Py_TYPE(obj)->tp_name);
341 return -1;
342 }
Serhiy Storchaka4fdb6842015-02-03 01:21:08 +0200343 return (*pb->bf_getbuffer)(obj, view, flags);
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000344}
345
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000346static int
Stefan Krah9a2d99e2012-02-25 12:24:21 +0100347_IsFortranContiguous(const Py_buffer *view)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000348{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000349 Py_ssize_t sd, dim;
350 int i;
Guido van Rossum98297ee2007-11-06 21:34:58 +0000351
Stefan Krah363af442015-02-01 14:53:54 +0100352 /* 1) len = product(shape) * itemsize
353 2) itemsize > 0
354 3) len = 0 <==> exists i: shape[i] = 0 */
355 if (view->len == 0) return 1;
356 if (view->strides == NULL) { /* C-contiguous by definition */
357 /* Trivially F-contiguous */
358 if (view->ndim <= 1) return 1;
359
360 /* ndim > 1 implies shape != NULL */
361 assert(view->shape != NULL);
362
363 /* Effectively 1-d */
364 sd = 0;
365 for (i=0; i<view->ndim; i++) {
366 if (view->shape[i] > 1) sd += 1;
367 }
368 return sd <= 1;
369 }
370
371 /* strides != NULL implies both of these */
372 assert(view->ndim > 0);
373 assert(view->shape != NULL);
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000374
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000375 sd = view->itemsize;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000376 for (i=0; i<view->ndim; i++) {
377 dim = view->shape[i];
Stefan Krah363af442015-02-01 14:53:54 +0100378 if (dim > 1 && view->strides[i] != sd) {
379 return 0;
380 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000381 sd *= dim;
382 }
383 return 1;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000384}
385
386static int
Stefan Krah9a2d99e2012-02-25 12:24:21 +0100387_IsCContiguous(const Py_buffer *view)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000388{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000389 Py_ssize_t sd, dim;
390 int i;
Guido van Rossum98297ee2007-11-06 21:34:58 +0000391
Stefan Krah363af442015-02-01 14:53:54 +0100392 /* 1) len = product(shape) * itemsize
393 2) itemsize > 0
394 3) len = 0 <==> exists i: shape[i] = 0 */
395 if (view->len == 0) return 1;
396 if (view->strides == NULL) return 1; /* C-contiguous by definition */
397
398 /* strides != NULL implies both of these */
399 assert(view->ndim > 0);
400 assert(view->shape != NULL);
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000401
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000402 sd = view->itemsize;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000403 for (i=view->ndim-1; i>=0; i--) {
404 dim = view->shape[i];
Stefan Krah363af442015-02-01 14:53:54 +0100405 if (dim > 1 && view->strides[i] != sd) {
406 return 0;
407 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000408 sd *= dim;
409 }
410 return 1;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000411}
412
413int
Stefan Krah9a2d99e2012-02-25 12:24:21 +0100414PyBuffer_IsContiguous(const Py_buffer *view, char order)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000415{
416
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000417 if (view->suboffsets != NULL) return 0;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000418
Stefan Krah9a2d99e2012-02-25 12:24:21 +0100419 if (order == 'C')
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000420 return _IsCContiguous(view);
Stefan Krah9a2d99e2012-02-25 12:24:21 +0100421 else if (order == 'F')
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000422 return _IsFortranContiguous(view);
Stefan Krah9a2d99e2012-02-25 12:24:21 +0100423 else if (order == 'A')
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000424 return (_IsCContiguous(view) || _IsFortranContiguous(view));
425 return 0;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000426}
427
428
Guido van Rossum98297ee2007-11-06 21:34:58 +0000429void*
Travis E. Oliphant8ae62b62007-09-23 02:00:13 +0000430PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000431{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000432 char* pointer;
433 int i;
434 pointer = (char *)view->buf;
435 for (i = 0; i < view->ndim; i++) {
436 pointer += view->strides[i]*indices[i];
437 if ((view->suboffsets != NULL) && (view->suboffsets[i] >= 0)) {
438 pointer = *((char**)pointer) + view->suboffsets[i];
439 }
440 }
441 return (void*)pointer;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000442}
443
444
Guido van Rossum98297ee2007-11-06 21:34:58 +0000445void
Antoine Pitrouf68c2a72010-09-01 12:58:21 +0000446_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 +0000447{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000448 int k;
Guido van Rossum98297ee2007-11-06 21:34:58 +0000449
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000450 for (k=0; k<nd; k++) {
451 if (index[k] < shape[k]-1) {
452 index[k]++;
453 break;
454 }
455 else {
456 index[k] = 0;
457 }
458 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000459}
460
Guido van Rossum98297ee2007-11-06 21:34:58 +0000461void
Antoine Pitrouf68c2a72010-09-01 12:58:21 +0000462_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 +0000463{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000464 int k;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000465
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000466 for (k=nd-1; k>=0; k--) {
467 if (index[k] < shape[k]-1) {
468 index[k]++;
469 break;
470 }
471 else {
472 index[k] = 0;
473 }
474 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000475}
476
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000477int
Travis E. Oliphant8ae62b62007-09-23 02:00:13 +0000478PyBuffer_FromContiguous(Py_buffer *view, void *buf, Py_ssize_t len, char fort)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000479{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000480 int k;
Antoine Pitrouf68c2a72010-09-01 12:58:21 +0000481 void (*addone)(int, Py_ssize_t *, const Py_ssize_t *);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000482 Py_ssize_t *indices, elements;
483 char *src, *ptr;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000484
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000485 if (len > view->len) {
486 len = view->len;
487 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000488
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000489 if (PyBuffer_IsContiguous(view, fort)) {
490 /* simplest copy is all that is needed */
491 memcpy(view->buf, buf, len);
492 return 0;
493 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000494
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000495 /* Otherwise a more elaborate scheme is needed */
Guido van Rossum98297ee2007-11-06 21:34:58 +0000496
Stefan Krah7213fcc2015-02-01 16:19:23 +0100497 /* view->ndim <= 64 */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000498 indices = (Py_ssize_t *)PyMem_Malloc(sizeof(Py_ssize_t)*(view->ndim));
499 if (indices == NULL) {
500 PyErr_NoMemory();
501 return -1;
502 }
503 for (k=0; k<view->ndim;k++) {
504 indices[k] = 0;
505 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000506
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000507 if (fort == 'F') {
Antoine Pitrouf68c2a72010-09-01 12:58:21 +0000508 addone = _Py_add_one_to_index_F;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000509 }
510 else {
Antoine Pitrouf68c2a72010-09-01 12:58:21 +0000511 addone = _Py_add_one_to_index_C;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000512 }
513 src = buf;
514 /* XXX : This is not going to be the fastest code in the world
515 several optimizations are possible.
516 */
517 elements = len / view->itemsize;
518 while (elements--) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000519 ptr = PyBuffer_GetPointer(view, indices);
520 memcpy(ptr, src, view->itemsize);
521 src += view->itemsize;
Stefan Krah7213fcc2015-02-01 16:19:23 +0100522 addone(view->ndim, indices, view->shape);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000523 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000524
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000525 PyMem_Free(indices);
526 return 0;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000527}
528
Guido van Rossum98297ee2007-11-06 21:34:58 +0000529int PyObject_CopyData(PyObject *dest, PyObject *src)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000530{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000531 Py_buffer view_dest, view_src;
532 int k;
533 Py_ssize_t *indices, elements;
534 char *dptr, *sptr;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000535
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000536 if (!PyObject_CheckBuffer(dest) ||
537 !PyObject_CheckBuffer(src)) {
538 PyErr_SetString(PyExc_TypeError,
R David Murray861470c2014-10-05 11:47:01 -0400539 "both destination and source must be "\
540 "bytes-like objects");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000541 return -1;
542 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000543
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000544 if (PyObject_GetBuffer(dest, &view_dest, PyBUF_FULL) != 0) return -1;
545 if (PyObject_GetBuffer(src, &view_src, PyBUF_FULL_RO) != 0) {
546 PyBuffer_Release(&view_dest);
547 return -1;
548 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000549
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000550 if (view_dest.len < view_src.len) {
551 PyErr_SetString(PyExc_BufferError,
552 "destination is too small to receive data from source");
553 PyBuffer_Release(&view_dest);
554 PyBuffer_Release(&view_src);
555 return -1;
556 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000557
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000558 if ((PyBuffer_IsContiguous(&view_dest, 'C') &&
559 PyBuffer_IsContiguous(&view_src, 'C')) ||
560 (PyBuffer_IsContiguous(&view_dest, 'F') &&
561 PyBuffer_IsContiguous(&view_src, 'F'))) {
562 /* simplest copy is all that is needed */
563 memcpy(view_dest.buf, view_src.buf, view_src.len);
564 PyBuffer_Release(&view_dest);
565 PyBuffer_Release(&view_src);
566 return 0;
567 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000568
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000569 /* Otherwise a more elaborate copy scheme is needed */
Guido van Rossum98297ee2007-11-06 21:34:58 +0000570
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000571 /* XXX(nnorwitz): need to check for overflow! */
572 indices = (Py_ssize_t *)PyMem_Malloc(sizeof(Py_ssize_t)*view_src.ndim);
573 if (indices == NULL) {
574 PyErr_NoMemory();
575 PyBuffer_Release(&view_dest);
576 PyBuffer_Release(&view_src);
577 return -1;
578 }
579 for (k=0; k<view_src.ndim;k++) {
580 indices[k] = 0;
581 }
582 elements = 1;
583 for (k=0; k<view_src.ndim; k++) {
584 /* XXX(nnorwitz): can this overflow? */
585 elements *= view_src.shape[k];
586 }
587 while (elements--) {
Antoine Pitrouf68c2a72010-09-01 12:58:21 +0000588 _Py_add_one_to_index_C(view_src.ndim, indices, view_src.shape);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000589 dptr = PyBuffer_GetPointer(&view_dest, indices);
590 sptr = PyBuffer_GetPointer(&view_src, indices);
591 memcpy(dptr, sptr, view_src.itemsize);
592 }
593 PyMem_Free(indices);
594 PyBuffer_Release(&view_dest);
595 PyBuffer_Release(&view_src);
596 return 0;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000597}
598
599void
600PyBuffer_FillContiguousStrides(int nd, Py_ssize_t *shape,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000601 Py_ssize_t *strides, int itemsize,
602 char fort)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000603{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000604 int k;
605 Py_ssize_t sd;
Guido van Rossum98297ee2007-11-06 21:34:58 +0000606
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000607 sd = itemsize;
608 if (fort == 'F') {
609 for (k=0; k<nd; k++) {
610 strides[k] = sd;
611 sd *= shape[k];
612 }
613 }
614 else {
615 for (k=nd-1; k>=0; k--) {
616 strides[k] = sd;
617 sd *= shape[k];
618 }
619 }
620 return;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000621}
622
623int
Martin v. Löwis423be952008-08-13 15:53:07 +0000624PyBuffer_FillInfo(Py_buffer *view, PyObject *obj, void *buf, Py_ssize_t len,
Stefan Krah4e141742012-03-06 15:27:31 +0100625 int readonly, int flags)
Guido van Rossum98297ee2007-11-06 21:34:58 +0000626{
Stefan Krah5178d912015-02-03 16:57:21 +0100627 if (view == NULL) {
628 PyErr_SetString(PyExc_BufferError,
629 "PyBuffer_FillInfo: view==NULL argument is obsolete");
630 return -1;
631 }
632
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000633 if (((flags & PyBUF_WRITABLE) == PyBUF_WRITABLE) &&
634 (readonly == 1)) {
635 PyErr_SetString(PyExc_BufferError,
636 "Object is not writable.");
637 return -1;
638 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000639
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000640 view->obj = obj;
641 if (obj)
642 Py_INCREF(obj);
643 view->buf = buf;
644 view->len = len;
645 view->readonly = readonly;
646 view->itemsize = 1;
647 view->format = NULL;
648 if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT)
649 view->format = "B";
650 view->ndim = 1;
651 view->shape = NULL;
652 if ((flags & PyBUF_ND) == PyBUF_ND)
653 view->shape = &(view->len);
654 view->strides = NULL;
655 if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES)
656 view->strides = &(view->itemsize);
657 view->suboffsets = NULL;
658 view->internal = NULL;
659 return 0;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000660}
661
Martin v. Löwis423be952008-08-13 15:53:07 +0000662void
663PyBuffer_Release(Py_buffer *view)
664{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000665 PyObject *obj = view->obj;
Serhiy Storchaka4fdb6842015-02-03 01:21:08 +0200666 PyBufferProcs *pb;
667 if (obj == NULL)
668 return;
669 pb = Py_TYPE(obj)->tp_as_buffer;
670 if (pb && pb->bf_releasebuffer)
671 pb->bf_releasebuffer(obj, view);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000672 view->obj = NULL;
Serhiy Storchaka4fdb6842015-02-03 01:21:08 +0200673 Py_DECREF(obj);
Martin v. Löwis423be952008-08-13 15:53:07 +0000674}
675
Eric Smith8fd3eba2008-02-17 19:48:00 +0000676PyObject *
677PyObject_Format(PyObject *obj, PyObject *format_spec)
678{
Eric Smith8fd3eba2008-02-17 19:48:00 +0000679 PyObject *meth;
680 PyObject *empty = NULL;
681 PyObject *result = NULL;
Benjamin Petersonce798522012-01-22 11:24:29 -0500682 _Py_IDENTIFIER(__format__);
Eric Smith8fd3eba2008-02-17 19:48:00 +0000683
Serhiy Storchakaea525a22016-09-06 22:07:53 +0300684 if (format_spec != NULL && !PyUnicode_Check(format_spec)) {
685 PyErr_Format(PyExc_SystemError,
686 "Format specifier must be a string, not %.200s",
687 Py_TYPE(format_spec)->tp_name);
688 return NULL;
689 }
690
691 /* Fast path for common types. */
692 if (format_spec == NULL || PyUnicode_GET_LENGTH(format_spec) == 0) {
693 if (PyUnicode_CheckExact(obj)) {
694 Py_INCREF(obj);
695 return obj;
696 }
697 if (PyLong_CheckExact(obj)) {
698 return PyObject_Str(obj);
699 }
700 }
701
Eric Smith8fd3eba2008-02-17 19:48:00 +0000702 /* If no format_spec is provided, use an empty string */
703 if (format_spec == NULL) {
Victor Stinner9d3b93b2011-11-22 02:27:30 +0100704 empty = PyUnicode_New(0, 0);
Benjamin Petersonda2cf042010-06-05 00:45:37 +0000705 format_spec = empty;
Eric Smith8fd3eba2008-02-17 19:48:00 +0000706 }
707
Serhiy Storchakaea525a22016-09-06 22:07:53 +0300708 /* Find the (unbound!) __format__ method */
Benjamin Petersonce798522012-01-22 11:24:29 -0500709 meth = _PyObject_LookupSpecial(obj, &PyId___format__);
Eric Smith8fd3eba2008-02-17 19:48:00 +0000710 if (meth == NULL) {
Benjamin Petersonda2cf042010-06-05 00:45:37 +0000711 if (!PyErr_Occurred())
712 PyErr_Format(PyExc_TypeError,
713 "Type %.100s doesn't define __format__",
714 Py_TYPE(obj)->tp_name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000715 goto done;
Eric Smith8fd3eba2008-02-17 19:48:00 +0000716 }
717
Benjamin Petersonda2cf042010-06-05 00:45:37 +0000718 /* And call it. */
Victor Stinnerde4ae3d2016-12-04 22:59:09 +0100719 result = PyObject_CallFunctionObjArgs(meth, format_spec, NULL);
Benjamin Peterson6f889ad32010-06-05 02:11:45 +0000720 Py_DECREF(meth);
Eric Smith8fd3eba2008-02-17 19:48:00 +0000721
722 if (result && !PyUnicode_Check(result)) {
Ethan Furmanb95b5612015-01-23 20:05:18 -0800723 PyErr_Format(PyExc_TypeError,
724 "__format__ must return a str, not %.200s",
725 Py_TYPE(result)->tp_name);
Benjamin Petersonda2cf042010-06-05 00:45:37 +0000726 Py_DECREF(result);
727 result = NULL;
728 goto done;
Eric Smith8fd3eba2008-02-17 19:48:00 +0000729 }
730
731done:
732 Py_XDECREF(empty);
733 return result;
734}
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000735/* Operations on numbers */
736
737int
Fred Drake79912472000-07-09 04:06:11 +0000738PyNumber_Check(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +0000739{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000740 return o && o->ob_type->tp_as_number &&
741 (o->ob_type->tp_as_number->nb_int ||
742 o->ob_type->tp_as_number->nb_float);
Guido van Rossume15dee51995-07-18 14:12:02 +0000743}
744
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000745/* Binary operators */
Guido van Rossume15dee51995-07-18 14:12:02 +0000746
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000747#define NB_SLOT(x) offsetof(PyNumberMethods, x)
748#define NB_BINOP(nb_methods, slot) \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000749 (*(binaryfunc*)(& ((char*)nb_methods)[slot]))
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000750#define NB_TERNOP(nb_methods, slot) \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000751 (*(ternaryfunc*)(& ((char*)nb_methods)[slot]))
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000752
753/*
754 Calling scheme used for binary operations:
755
Neal Norwitz4886cc32006-08-21 17:06:07 +0000756 Order operations are tried until either a valid result or error:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000757 w.op(v,w)[*], v.op(v,w), w.op(v,w)
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000758
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000759 [*] only when v->ob_type != w->ob_type && w->ob_type is a subclass of
760 v->ob_type
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000761 */
762
763static PyObject *
764binary_op1(PyObject *v, PyObject *w, const int op_slot)
Guido van Rossume15dee51995-07-18 14:12:02 +0000765{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000766 PyObject *x;
767 binaryfunc slotv = NULL;
768 binaryfunc slotw = NULL;
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000769
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000770 if (v->ob_type->tp_as_number != NULL)
771 slotv = NB_BINOP(v->ob_type->tp_as_number, op_slot);
772 if (w->ob_type != v->ob_type &&
773 w->ob_type->tp_as_number != NULL) {
774 slotw = NB_BINOP(w->ob_type->tp_as_number, op_slot);
775 if (slotw == slotv)
776 slotw = NULL;
777 }
778 if (slotv) {
779 if (slotw && PyType_IsSubtype(w->ob_type, v->ob_type)) {
780 x = slotw(v, w);
781 if (x != Py_NotImplemented)
782 return x;
783 Py_DECREF(x); /* can't do it */
784 slotw = NULL;
785 }
786 x = slotv(v, w);
787 if (x != Py_NotImplemented)
788 return x;
789 Py_DECREF(x); /* can't do it */
790 }
791 if (slotw) {
792 x = slotw(v, w);
793 if (x != Py_NotImplemented)
794 return x;
795 Py_DECREF(x); /* can't do it */
796 }
Brian Curtindfc80e32011-08-10 20:28:54 -0500797 Py_RETURN_NOTIMPLEMENTED;
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000798}
Guido van Rossum77660912002-04-16 16:32:50 +0000799
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000800static PyObject *
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000801binop_type_error(PyObject *v, PyObject *w, const char *op_name)
802{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000803 PyErr_Format(PyExc_TypeError,
804 "unsupported operand type(s) for %.100s: "
805 "'%.100s' and '%.100s'",
806 op_name,
807 v->ob_type->tp_name,
808 w->ob_type->tp_name);
809 return NULL;
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000810}
811
812static PyObject *
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000813binary_op(PyObject *v, PyObject *w, const int op_slot, const char *op_name)
814{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000815 PyObject *result = binary_op1(v, w, op_slot);
816 if (result == Py_NotImplemented) {
817 Py_DECREF(result);
818 return binop_type_error(v, w, op_name);
819 }
820 return result;
Guido van Rossume15dee51995-07-18 14:12:02 +0000821}
822
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000823
824/*
825 Calling scheme used for ternary operations:
826
Neal Norwitz4886cc32006-08-21 17:06:07 +0000827 Order operations are tried until either a valid result or error:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000828 v.op(v,w,z), w.op(v,w,z), z.op(v,w,z)
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000829 */
830
831static PyObject *
832ternary_op(PyObject *v,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000833 PyObject *w,
834 PyObject *z,
835 const int op_slot,
836 const char *op_name)
Guido van Rossume15dee51995-07-18 14:12:02 +0000837{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000838 PyNumberMethods *mv, *mw, *mz;
839 PyObject *x = NULL;
840 ternaryfunc slotv = NULL;
841 ternaryfunc slotw = NULL;
842 ternaryfunc slotz = NULL;
Guido van Rossum77660912002-04-16 16:32:50 +0000843
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000844 mv = v->ob_type->tp_as_number;
845 mw = w->ob_type->tp_as_number;
846 if (mv != NULL)
847 slotv = NB_TERNOP(mv, op_slot);
848 if (w->ob_type != v->ob_type &&
849 mw != NULL) {
850 slotw = NB_TERNOP(mw, op_slot);
851 if (slotw == slotv)
852 slotw = NULL;
853 }
854 if (slotv) {
855 if (slotw && PyType_IsSubtype(w->ob_type, v->ob_type)) {
856 x = slotw(v, w, z);
857 if (x != Py_NotImplemented)
858 return x;
859 Py_DECREF(x); /* can't do it */
860 slotw = NULL;
861 }
862 x = slotv(v, w, z);
863 if (x != Py_NotImplemented)
864 return x;
865 Py_DECREF(x); /* can't do it */
866 }
867 if (slotw) {
868 x = slotw(v, w, z);
869 if (x != Py_NotImplemented)
870 return x;
871 Py_DECREF(x); /* can't do it */
872 }
873 mz = z->ob_type->tp_as_number;
874 if (mz != NULL) {
875 slotz = NB_TERNOP(mz, op_slot);
876 if (slotz == slotv || slotz == slotw)
877 slotz = NULL;
878 if (slotz) {
879 x = slotz(v, w, z);
880 if (x != Py_NotImplemented)
881 return x;
882 Py_DECREF(x); /* can't do it */
883 }
884 }
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000885
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000886 if (z == Py_None)
887 PyErr_Format(
888 PyExc_TypeError,
889 "unsupported operand type(s) for ** or pow(): "
890 "'%.100s' and '%.100s'",
891 v->ob_type->tp_name,
892 w->ob_type->tp_name);
893 else
894 PyErr_Format(
895 PyExc_TypeError,
896 "unsupported operand type(s) for pow(): "
897 "'%.100s', '%.100s', '%.100s'",
898 v->ob_type->tp_name,
899 w->ob_type->tp_name,
900 z->ob_type->tp_name);
901 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +0000902}
903
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000904#define BINARY_FUNC(func, op, op_name) \
905 PyObject * \
906 func(PyObject *v, PyObject *w) { \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000907 return binary_op(v, w, NB_SLOT(op), op_name); \
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000908 }
Guido van Rossume15dee51995-07-18 14:12:02 +0000909
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000910BINARY_FUNC(PyNumber_Or, nb_or, "|")
911BINARY_FUNC(PyNumber_Xor, nb_xor, "^")
912BINARY_FUNC(PyNumber_And, nb_and, "&")
913BINARY_FUNC(PyNumber_Lshift, nb_lshift, "<<")
914BINARY_FUNC(PyNumber_Rshift, nb_rshift, ">>")
915BINARY_FUNC(PyNumber_Subtract, nb_subtract, "-")
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000916BINARY_FUNC(PyNumber_Divmod, nb_divmod, "divmod()")
Guido van Rossume15dee51995-07-18 14:12:02 +0000917
918PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000919PyNumber_Add(PyObject *v, PyObject *w)
Guido van Rossume15dee51995-07-18 14:12:02 +0000920{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000921 PyObject *result = binary_op1(v, w, NB_SLOT(nb_add));
922 if (result == Py_NotImplemented) {
923 PySequenceMethods *m = v->ob_type->tp_as_sequence;
924 Py_DECREF(result);
925 if (m && m->sq_concat) {
926 return (*m->sq_concat)(v, w);
927 }
928 result = binop_type_error(v, w, "+");
929 }
930 return result;
Guido van Rossume15dee51995-07-18 14:12:02 +0000931}
932
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000933static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000934sequence_repeat(ssizeargfunc repeatfunc, PyObject *seq, PyObject *n)
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000935{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000936 Py_ssize_t count;
937 if (PyIndex_Check(n)) {
938 count = PyNumber_AsSsize_t(n, PyExc_OverflowError);
939 if (count == -1 && PyErr_Occurred())
940 return NULL;
941 }
942 else {
943 return type_error("can't multiply sequence by "
944 "non-int of type '%.200s'", n);
945 }
946 return (*repeatfunc)(seq, count);
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000947}
948
949PyObject *
950PyNumber_Multiply(PyObject *v, PyObject *w)
951{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000952 PyObject *result = binary_op1(v, w, NB_SLOT(nb_multiply));
953 if (result == Py_NotImplemented) {
954 PySequenceMethods *mv = v->ob_type->tp_as_sequence;
955 PySequenceMethods *mw = w->ob_type->tp_as_sequence;
956 Py_DECREF(result);
957 if (mv && mv->sq_repeat) {
958 return sequence_repeat(mv->sq_repeat, v, w);
959 }
960 else if (mw && mw->sq_repeat) {
961 return sequence_repeat(mw->sq_repeat, w, v);
962 }
963 result = binop_type_error(v, w, "*");
964 }
965 return result;
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000966}
967
Guido van Rossume15dee51995-07-18 14:12:02 +0000968PyObject *
Benjamin Petersond51374e2014-04-09 23:55:56 -0400969PyNumber_MatrixMultiply(PyObject *v, PyObject *w)
970{
971 return binary_op(v, w, NB_SLOT(nb_matrix_multiply), "@");
972}
973
974PyObject *
Guido van Rossum4668b002001-08-08 05:00:18 +0000975PyNumber_FloorDivide(PyObject *v, PyObject *w)
976{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000977 return binary_op(v, w, NB_SLOT(nb_floor_divide), "//");
Guido van Rossum4668b002001-08-08 05:00:18 +0000978}
979
980PyObject *
981PyNumber_TrueDivide(PyObject *v, PyObject *w)
982{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000983 return binary_op(v, w, NB_SLOT(nb_true_divide), "/");
Guido van Rossum4668b002001-08-08 05:00:18 +0000984}
985
986PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000987PyNumber_Remainder(PyObject *v, PyObject *w)
Guido van Rossume15dee51995-07-18 14:12:02 +0000988{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000989 return binary_op(v, w, NB_SLOT(nb_remainder), "%");
Guido van Rossume15dee51995-07-18 14:12:02 +0000990}
991
992PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000993PyNumber_Power(PyObject *v, PyObject *w, PyObject *z)
Guido van Rossume15dee51995-07-18 14:12:02 +0000994{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000995 return ternary_op(v, w, z, NB_SLOT(nb_power), "** or pow()");
Guido van Rossume15dee51995-07-18 14:12:02 +0000996}
997
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000998/* Binary in-place operators */
999
1000/* The in-place operators are defined to fall back to the 'normal',
Neil Schemenauer5a1f0152001-01-04 01:39:06 +00001001 non in-place operations, if the in-place methods are not in place.
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001002
Neil Schemenauer5a1f0152001-01-04 01:39:06 +00001003 - If the left hand object has the appropriate struct members, and
1004 they are filled, call the appropriate function and return the
1005 result. No coercion is done on the arguments; the left-hand object
1006 is the one the operation is performed on, and it's up to the
1007 function to deal with the right-hand object.
Guido van Rossum77660912002-04-16 16:32:50 +00001008
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001009 - Otherwise, in-place modification is not supported. Handle it exactly as
Neil Schemenauer5a1f0152001-01-04 01:39:06 +00001010 a non in-place operation of the same kind.
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001011
1012 */
1013
Neil Schemenauer5a1f0152001-01-04 01:39:06 +00001014static PyObject *
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +00001015binary_iop1(PyObject *v, PyObject *w, const int iop_slot, const int op_slot)
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001016{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001017 PyNumberMethods *mv = v->ob_type->tp_as_number;
1018 if (mv != NULL) {
1019 binaryfunc slot = NB_BINOP(mv, iop_slot);
1020 if (slot) {
1021 PyObject *x = (slot)(v, w);
1022 if (x != Py_NotImplemented) {
1023 return x;
1024 }
1025 Py_DECREF(x);
1026 }
1027 }
1028 return binary_op1(v, w, op_slot);
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +00001029}
1030
1031static PyObject *
1032binary_iop(PyObject *v, PyObject *w, const int iop_slot, const int op_slot,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001033 const char *op_name)
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +00001034{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001035 PyObject *result = binary_iop1(v, w, iop_slot, op_slot);
1036 if (result == Py_NotImplemented) {
1037 Py_DECREF(result);
1038 return binop_type_error(v, w, op_name);
1039 }
1040 return result;
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001041}
1042
Neil Schemenauer5a1f0152001-01-04 01:39:06 +00001043#define INPLACE_BINOP(func, iop, op, op_name) \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001044 PyObject * \
1045 func(PyObject *v, PyObject *w) { \
1046 return binary_iop(v, w, NB_SLOT(iop), NB_SLOT(op), op_name); \
1047 }
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001048
Neil Schemenauer5a1f0152001-01-04 01:39:06 +00001049INPLACE_BINOP(PyNumber_InPlaceOr, nb_inplace_or, nb_or, "|=")
1050INPLACE_BINOP(PyNumber_InPlaceXor, nb_inplace_xor, nb_xor, "^=")
1051INPLACE_BINOP(PyNumber_InPlaceAnd, nb_inplace_and, nb_and, "&=")
1052INPLACE_BINOP(PyNumber_InPlaceLshift, nb_inplace_lshift, nb_lshift, "<<=")
1053INPLACE_BINOP(PyNumber_InPlaceRshift, nb_inplace_rshift, nb_rshift, ">>=")
1054INPLACE_BINOP(PyNumber_InPlaceSubtract, nb_inplace_subtract, nb_subtract, "-=")
Benjamin Petersond51374e2014-04-09 23:55:56 -04001055INPLACE_BINOP(PyNumber_InMatrixMultiply, nb_inplace_matrix_multiply, nb_matrix_multiply, "@=")
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001056
1057PyObject *
Guido van Rossum4668b002001-08-08 05:00:18 +00001058PyNumber_InPlaceFloorDivide(PyObject *v, PyObject *w)
1059{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001060 return binary_iop(v, w, NB_SLOT(nb_inplace_floor_divide),
1061 NB_SLOT(nb_floor_divide), "//=");
Guido van Rossum4668b002001-08-08 05:00:18 +00001062}
1063
1064PyObject *
1065PyNumber_InPlaceTrueDivide(PyObject *v, PyObject *w)
1066{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001067 return binary_iop(v, w, NB_SLOT(nb_inplace_true_divide),
1068 NB_SLOT(nb_true_divide), "/=");
Guido van Rossum4668b002001-08-08 05:00:18 +00001069}
1070
1071PyObject *
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001072PyNumber_InPlaceAdd(PyObject *v, PyObject *w)
1073{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001074 PyObject *result = binary_iop1(v, w, NB_SLOT(nb_inplace_add),
1075 NB_SLOT(nb_add));
1076 if (result == Py_NotImplemented) {
1077 PySequenceMethods *m = v->ob_type->tp_as_sequence;
1078 Py_DECREF(result);
1079 if (m != NULL) {
1080 binaryfunc f = NULL;
1081 f = m->sq_inplace_concat;
1082 if (f == NULL)
1083 f = m->sq_concat;
1084 if (f != NULL)
1085 return (*f)(v, w);
1086 }
1087 result = binop_type_error(v, w, "+=");
1088 }
1089 return result;
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001090}
1091
1092PyObject *
1093PyNumber_InPlaceMultiply(PyObject *v, PyObject *w)
1094{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001095 PyObject *result = binary_iop1(v, w, NB_SLOT(nb_inplace_multiply),
1096 NB_SLOT(nb_multiply));
1097 if (result == Py_NotImplemented) {
1098 ssizeargfunc f = NULL;
1099 PySequenceMethods *mv = v->ob_type->tp_as_sequence;
1100 PySequenceMethods *mw = w->ob_type->tp_as_sequence;
1101 Py_DECREF(result);
1102 if (mv != NULL) {
1103 f = mv->sq_inplace_repeat;
1104 if (f == NULL)
1105 f = mv->sq_repeat;
1106 if (f != NULL)
1107 return sequence_repeat(f, v, w);
1108 }
1109 else if (mw != NULL) {
1110 /* Note that the right hand operand should not be
1111 * mutated in this case so sq_inplace_repeat is not
1112 * used. */
1113 if (mw->sq_repeat)
1114 return sequence_repeat(mw->sq_repeat, w, v);
1115 }
1116 result = binop_type_error(v, w, "*=");
1117 }
1118 return result;
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001119}
1120
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001121PyObject *
Benjamin Petersond51374e2014-04-09 23:55:56 -04001122PyNumber_InPlaceMatrixMultiply(PyObject *v, PyObject *w)
1123{
1124 return binary_iop(v, w, NB_SLOT(nb_inplace_matrix_multiply),
1125 NB_SLOT(nb_matrix_multiply), "@=");
1126}
1127
1128PyObject *
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001129PyNumber_InPlaceRemainder(PyObject *v, PyObject *w)
1130{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001131 return binary_iop(v, w, NB_SLOT(nb_inplace_remainder),
1132 NB_SLOT(nb_remainder), "%=");
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001133}
1134
1135PyObject *
1136PyNumber_InPlacePower(PyObject *v, PyObject *w, PyObject *z)
1137{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001138 if (v->ob_type->tp_as_number &&
1139 v->ob_type->tp_as_number->nb_inplace_power != NULL) {
1140 return ternary_op(v, w, z, NB_SLOT(nb_inplace_power), "**=");
1141 }
1142 else {
1143 return ternary_op(v, w, z, NB_SLOT(nb_power), "**=");
1144 }
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001145}
1146
1147
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001148/* Unary operators and functions */
Guido van Rossume15dee51995-07-18 14:12:02 +00001149
1150PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001151PyNumber_Negative(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001152{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001153 PyNumberMethods *m;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001154
Victor Stinner71aea8e2016-08-19 16:59:55 +02001155 if (o == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001156 return null_error();
Victor Stinner71aea8e2016-08-19 16:59:55 +02001157 }
1158
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001159 m = o->ob_type->tp_as_number;
1160 if (m && m->nb_negative)
1161 return (*m->nb_negative)(o);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001162
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001163 return type_error("bad operand type for unary -: '%.200s'", o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001164}
1165
1166PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001167PyNumber_Positive(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001168{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001169 PyNumberMethods *m;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001170
Victor Stinner71aea8e2016-08-19 16:59:55 +02001171 if (o == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001172 return null_error();
Victor Stinner71aea8e2016-08-19 16:59:55 +02001173 }
1174
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001175 m = o->ob_type->tp_as_number;
1176 if (m && m->nb_positive)
1177 return (*m->nb_positive)(o);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001178
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001179 return type_error("bad operand type for unary +: '%.200s'", o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001180}
1181
1182PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001183PyNumber_Invert(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001184{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001185 PyNumberMethods *m;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001186
Victor Stinner71aea8e2016-08-19 16:59:55 +02001187 if (o == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001188 return null_error();
Victor Stinner71aea8e2016-08-19 16:59:55 +02001189 }
1190
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001191 m = o->ob_type->tp_as_number;
1192 if (m && m->nb_invert)
1193 return (*m->nb_invert)(o);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001194
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001195 return type_error("bad operand type for unary ~: '%.200s'", o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001196}
1197
1198PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001199PyNumber_Absolute(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001200{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001201 PyNumberMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001202
Victor Stinner71aea8e2016-08-19 16:59:55 +02001203 if (o == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001204 return null_error();
Victor Stinner71aea8e2016-08-19 16:59:55 +02001205 }
1206
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001207 m = o->ob_type->tp_as_number;
1208 if (m && m->nb_absolute)
1209 return m->nb_absolute(o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001210
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001211 return type_error("bad operand type for abs(): '%.200s'", o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001212}
1213
Serhiy Storchaka31a65542013-12-11 21:07:54 +02001214/* Return a Python int from the object item.
Serhiy Storchaka95949422013-08-27 19:40:23 +03001215 Raise TypeError if the result is not an int
Guido van Rossum98297ee2007-11-06 21:34:58 +00001216 or if the object cannot be interpreted as an index.
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00001217*/
1218PyObject *
Guido van Rossum38fff8c2006-03-07 18:50:55 +00001219PyNumber_Index(PyObject *item)
1220{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001221 PyObject *result = NULL;
Victor Stinner71aea8e2016-08-19 16:59:55 +02001222 if (item == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001223 return null_error();
Victor Stinner71aea8e2016-08-19 16:59:55 +02001224 }
1225
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001226 if (PyLong_Check(item)) {
1227 Py_INCREF(item);
1228 return item;
1229 }
Serhiy Storchaka31a65542013-12-11 21:07:54 +02001230 if (!PyIndex_Check(item)) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001231 PyErr_Format(PyExc_TypeError,
1232 "'%.200s' object cannot be interpreted "
1233 "as an integer", item->ob_type->tp_name);
Serhiy Storchaka31a65542013-12-11 21:07:54 +02001234 return NULL;
1235 }
1236 result = item->ob_type->tp_as_number->nb_index(item);
1237 if (!result || PyLong_CheckExact(result))
1238 return result;
1239 if (!PyLong_Check(result)) {
1240 PyErr_Format(PyExc_TypeError,
1241 "__index__ returned non-int (type %.200s)",
1242 result->ob_type->tp_name);
1243 Py_DECREF(result);
1244 return NULL;
1245 }
1246 /* Issue #17576: warn if 'result' not of exact type int. */
1247 if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
1248 "__index__ returned non-int (type %.200s). "
1249 "The ability to return an instance of a strict subclass of int "
1250 "is deprecated, and may be removed in a future version of Python.",
1251 result->ob_type->tp_name)) {
1252 Py_DECREF(result);
1253 return NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001254 }
1255 return result;
Guido van Rossum38fff8c2006-03-07 18:50:55 +00001256}
1257
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00001258/* Return an error on Overflow only if err is not NULL*/
1259
1260Py_ssize_t
1261PyNumber_AsSsize_t(PyObject *item, PyObject *err)
1262{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001263 Py_ssize_t result;
1264 PyObject *runerr;
1265 PyObject *value = PyNumber_Index(item);
1266 if (value == NULL)
1267 return -1;
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00001268
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001269 /* We're done if PyLong_AsSsize_t() returns without error. */
1270 result = PyLong_AsSsize_t(value);
1271 if (result != -1 || !(runerr = PyErr_Occurred()))
1272 goto finish;
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00001273
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001274 /* Error handling code -- only manage OverflowError differently */
1275 if (!PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError))
1276 goto finish;
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00001277
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001278 PyErr_Clear();
1279 /* If no error-handling desired then the default clipping
1280 is sufficient.
1281 */
1282 if (!err) {
1283 assert(PyLong_Check(value));
1284 /* Whether or not it is less than or equal to
1285 zero is determined by the sign of ob_size
1286 */
1287 if (_PyLong_Sign(value) < 0)
1288 result = PY_SSIZE_T_MIN;
1289 else
1290 result = PY_SSIZE_T_MAX;
1291 }
1292 else {
1293 /* Otherwise replace the error with caller's error object. */
1294 PyErr_Format(err,
1295 "cannot fit '%.200s' into an index-sized integer",
1296 item->ob_type->tp_name);
1297 }
Guido van Rossum98297ee2007-11-06 21:34:58 +00001298
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00001299 finish:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001300 Py_DECREF(value);
1301 return result;
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00001302}
1303
1304
Guido van Rossume15dee51995-07-18 14:12:02 +00001305PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001306PyNumber_Long(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001307{
Serhiy Storchaka54cd1962016-08-21 20:03:08 +03001308 PyObject *result;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001309 PyNumberMethods *m;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001310 PyObject *trunc_func;
Serhiy Storchaka4fdb6842015-02-03 01:21:08 +02001311 Py_buffer view;
Benjamin Peterson9fc9bf42012-03-20 23:26:41 -04001312 _Py_IDENTIFIER(__trunc__);
Christian Heimes15ebc882008-02-04 18:48:49 +00001313
Victor Stinner71aea8e2016-08-19 16:59:55 +02001314 if (o == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001315 return null_error();
Victor Stinner71aea8e2016-08-19 16:59:55 +02001316 }
1317
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001318 if (PyLong_CheckExact(o)) {
1319 Py_INCREF(o);
1320 return o;
1321 }
1322 m = o->ob_type->tp_as_number;
1323 if (m && m->nb_int) { /* This should include subclasses of int */
Serhiy Storchaka54cd1962016-08-21 20:03:08 +03001324 result = (PyObject *)_PyLong_FromNbInt(o);
1325 if (result != NULL && !PyLong_CheckExact(result)) {
1326 Py_SETREF(result, _PyLong_Copy((PyLongObject *)result));
1327 }
1328 return result;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001329 }
Benjamin Peterson1b1a8e72012-03-20 23:48:11 -04001330 trunc_func = _PyObject_LookupSpecial(o, &PyId___trunc__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001331 if (trunc_func) {
Serhiy Storchaka54cd1962016-08-21 20:03:08 +03001332 result = PyEval_CallObject(trunc_func, NULL);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001333 Py_DECREF(trunc_func);
Serhiy Storchaka54cd1962016-08-21 20:03:08 +03001334 if (result == NULL || PyLong_CheckExact(result)) {
1335 return result;
1336 }
1337 if (PyLong_Check(result)) {
1338 Py_SETREF(result, _PyLong_Copy((PyLongObject *)result));
1339 return result;
1340 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001341 /* __trunc__ is specified to return an Integral type,
Martin Panter7462b6492015-11-02 03:37:02 +00001342 but int() needs to return an int. */
Serhiy Storchaka54cd1962016-08-21 20:03:08 +03001343 m = result->ob_type->tp_as_number;
Serhiy Storchaka31a65542013-12-11 21:07:54 +02001344 if (m == NULL || m->nb_int == NULL) {
1345 PyErr_Format(
1346 PyExc_TypeError,
1347 "__trunc__ returned non-Integral (type %.200s)",
Serhiy Storchaka54cd1962016-08-21 20:03:08 +03001348 result->ob_type->tp_name);
1349 Py_DECREF(result);
Serhiy Storchaka31a65542013-12-11 21:07:54 +02001350 return NULL;
1351 }
Serhiy Storchaka54cd1962016-08-21 20:03:08 +03001352 Py_SETREF(result, (PyObject *)_PyLong_FromNbInt(result));
1353 if (result != NULL && !PyLong_CheckExact(result)) {
1354 Py_SETREF(result, _PyLong_Copy((PyLongObject *)result));
1355 }
1356 return result;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001357 }
Benjamin Peterson1b1a8e72012-03-20 23:48:11 -04001358 if (PyErr_Occurred())
1359 return NULL;
Christian Heimes15ebc882008-02-04 18:48:49 +00001360
Serhiy Storchaka4fdb6842015-02-03 01:21:08 +02001361 if (PyUnicode_Check(o))
1362 /* The below check is done in PyLong_FromUnicode(). */
1363 return PyLong_FromUnicodeObject(o, 10);
1364
Martin Pantereeb896c2015-11-07 02:32:21 +00001365 if (PyBytes_Check(o))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001366 /* need to do extra error checking that PyLong_FromString()
Serhiy Storchakaf6d0aee2013-08-03 20:55:06 +03001367 * doesn't do. In particular int('9\x005') must raise an
1368 * exception, not truncate at the null.
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001369 */
Martin Pantereeb896c2015-11-07 02:32:21 +00001370 return _PyLong_FromBytes(PyBytes_AS_STRING(o),
1371 PyBytes_GET_SIZE(o), 10);
1372
1373 if (PyByteArray_Check(o))
1374 return _PyLong_FromBytes(PyByteArray_AS_STRING(o),
1375 PyByteArray_GET_SIZE(o), 10);
1376
1377 if (PyObject_GetBuffer(o, &view, PyBUF_SIMPLE) == 0) {
Serhiy Storchaka54cd1962016-08-21 20:03:08 +03001378 PyObject *bytes;
Martin Pantereeb896c2015-11-07 02:32:21 +00001379
1380 /* Copy to NUL-terminated buffer. */
1381 bytes = PyBytes_FromStringAndSize((const char *)view.buf, view.len);
1382 if (bytes == NULL) {
1383 PyBuffer_Release(&view);
1384 return NULL;
1385 }
1386 result = _PyLong_FromBytes(PyBytes_AS_STRING(bytes),
1387 PyBytes_GET_SIZE(bytes), 10);
1388 Py_DECREF(bytes);
Serhiy Storchaka4fdb6842015-02-03 01:21:08 +02001389 PyBuffer_Release(&view);
1390 return result;
1391 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001392
Serhiy Storchaka4fdb6842015-02-03 01:21:08 +02001393 return type_error("int() argument must be a string, a bytes-like object "
1394 "or a number, not '%.200s'", o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001395}
1396
1397PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001398PyNumber_Float(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001399{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001400 PyNumberMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001401
Victor Stinner71aea8e2016-08-19 16:59:55 +02001402 if (o == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001403 return null_error();
Victor Stinner71aea8e2016-08-19 16:59:55 +02001404 }
1405
Serhiy Storchaka16931c32016-06-03 21:42:55 +03001406 if (PyFloat_CheckExact(o)) {
1407 Py_INCREF(o);
1408 return o;
1409 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001410 m = o->ob_type->tp_as_number;
1411 if (m && m->nb_float) { /* This should include subclasses of float */
1412 PyObject *res = m->nb_float(o);
Serhiy Storchaka16931c32016-06-03 21:42:55 +03001413 double val;
1414 if (!res || PyFloat_CheckExact(res)) {
1415 return res;
1416 }
1417 if (!PyFloat_Check(res)) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001418 PyErr_Format(PyExc_TypeError,
Serhiy Storchaka16931c32016-06-03 21:42:55 +03001419 "%.50s.__float__ returned non-float (type %.50s)",
1420 o->ob_type->tp_name, res->ob_type->tp_name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001421 Py_DECREF(res);
1422 return NULL;
1423 }
Serhiy Storchaka16931c32016-06-03 21:42:55 +03001424 /* Issue #26983: warn if 'res' not of exact type float. */
1425 if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
1426 "%.50s.__float__ returned non-float (type %.50s). "
1427 "The ability to return an instance of a strict subclass of float "
1428 "is deprecated, and may be removed in a future version of Python.",
1429 o->ob_type->tp_name, res->ob_type->tp_name)) {
1430 Py_DECREF(res);
1431 return NULL;
1432 }
1433 val = PyFloat_AS_DOUBLE(res);
1434 Py_DECREF(res);
1435 return PyFloat_FromDouble(val);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001436 }
1437 if (PyFloat_Check(o)) { /* A float subclass with nb_float == NULL */
Serhiy Storchaka16931c32016-06-03 21:42:55 +03001438 return PyFloat_FromDouble(PyFloat_AS_DOUBLE(o));
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001439 }
1440 return PyFloat_FromString(o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001441}
1442
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001443
1444PyObject *
1445PyNumber_ToBase(PyObject *n, int base)
1446{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001447 PyObject *res = NULL;
1448 PyObject *index = PyNumber_Index(n);
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001449
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001450 if (!index)
1451 return NULL;
1452 if (PyLong_Check(index))
1453 res = _PyLong_Format(index, base);
1454 else
1455 /* It should not be possible to get here, as
1456 PyNumber_Index already has a check for the same
1457 condition */
Serhiy Storchaka95949422013-08-27 19:40:23 +03001458 PyErr_SetString(PyExc_ValueError, "PyNumber_ToBase: index not int");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001459 Py_DECREF(index);
1460 return res;
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001461}
1462
1463
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001464/* Operations on sequences */
Guido van Rossume15dee51995-07-18 14:12:02 +00001465
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001466int
Fred Drake79912472000-07-09 04:06:11 +00001467PySequence_Check(PyObject *s)
Guido van Rossume15dee51995-07-18 14:12:02 +00001468{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001469 if (PyDict_Check(s))
1470 return 0;
1471 return s != NULL && s->ob_type->tp_as_sequence &&
1472 s->ob_type->tp_as_sequence->sq_item != NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +00001473}
1474
Martin v. Löwis18e16552006-02-15 17:27:45 +00001475Py_ssize_t
Jeremy Hylton6253f832000-07-12 12:56:19 +00001476PySequence_Size(PyObject *s)
Guido van Rossume15dee51995-07-18 14:12:02 +00001477{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001478 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001479
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001480 if (s == NULL) {
1481 null_error();
1482 return -1;
1483 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001484
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001485 m = s->ob_type->tp_as_sequence;
1486 if (m && m->sq_length)
1487 return m->sq_length(s);
Guido van Rossume15dee51995-07-18 14:12:02 +00001488
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001489 type_error("object of type '%.200s' has no len()", s);
1490 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +00001491}
1492
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +00001493#undef PySequence_Length
Martin v. Löwis18e16552006-02-15 17:27:45 +00001494Py_ssize_t
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +00001495PySequence_Length(PyObject *s)
1496{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001497 return PySequence_Size(s);
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +00001498}
1499#define PySequence_Length PySequence_Size
1500
Guido van Rossume15dee51995-07-18 14:12:02 +00001501PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001502PySequence_Concat(PyObject *s, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001503{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001504 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001505
Victor Stinner71aea8e2016-08-19 16:59:55 +02001506 if (s == NULL || o == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001507 return null_error();
Victor Stinner71aea8e2016-08-19 16:59:55 +02001508 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001509
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001510 m = s->ob_type->tp_as_sequence;
1511 if (m && m->sq_concat)
1512 return m->sq_concat(s, o);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001513
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001514 /* Instances of user classes defining an __add__() method only
1515 have an nb_add slot, not an sq_concat slot. So we fall back
1516 to nb_add if both arguments appear to be sequences. */
1517 if (PySequence_Check(s) && PySequence_Check(o)) {
1518 PyObject *result = binary_op1(s, o, NB_SLOT(nb_add));
1519 if (result != Py_NotImplemented)
1520 return result;
1521 Py_DECREF(result);
1522 }
1523 return type_error("'%.200s' object can't be concatenated", s);
Guido van Rossume15dee51995-07-18 14:12:02 +00001524}
1525
1526PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +00001527PySequence_Repeat(PyObject *o, Py_ssize_t count)
Guido van Rossume15dee51995-07-18 14:12:02 +00001528{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001529 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001530
Victor Stinner71aea8e2016-08-19 16:59:55 +02001531 if (o == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001532 return null_error();
Victor Stinner71aea8e2016-08-19 16:59:55 +02001533 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001534
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001535 m = o->ob_type->tp_as_sequence;
1536 if (m && m->sq_repeat)
1537 return m->sq_repeat(o, count);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001538
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001539 /* Instances of user classes defining a __mul__() method only
1540 have an nb_multiply slot, not an sq_repeat slot. so we fall back
1541 to nb_multiply if o appears to be a sequence. */
1542 if (PySequence_Check(o)) {
1543 PyObject *n, *result;
1544 n = PyLong_FromSsize_t(count);
1545 if (n == NULL)
1546 return NULL;
1547 result = binary_op1(o, n, NB_SLOT(nb_multiply));
1548 Py_DECREF(n);
1549 if (result != Py_NotImplemented)
1550 return result;
1551 Py_DECREF(result);
1552 }
1553 return type_error("'%.200s' object can't be repeated", o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001554}
1555
1556PyObject *
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001557PySequence_InPlaceConcat(PyObject *s, PyObject *o)
1558{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001559 PySequenceMethods *m;
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001560
Victor Stinner71aea8e2016-08-19 16:59:55 +02001561 if (s == NULL || o == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001562 return null_error();
Victor Stinner71aea8e2016-08-19 16:59:55 +02001563 }
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001564
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001565 m = s->ob_type->tp_as_sequence;
1566 if (m && m->sq_inplace_concat)
1567 return m->sq_inplace_concat(s, o);
1568 if (m && m->sq_concat)
1569 return m->sq_concat(s, o);
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001570
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001571 if (PySequence_Check(s) && PySequence_Check(o)) {
1572 PyObject *result = binary_iop1(s, o, NB_SLOT(nb_inplace_add),
1573 NB_SLOT(nb_add));
1574 if (result != Py_NotImplemented)
1575 return result;
1576 Py_DECREF(result);
1577 }
1578 return type_error("'%.200s' object can't be concatenated", s);
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001579}
1580
1581PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +00001582PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count)
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001583{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001584 PySequenceMethods *m;
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001585
Victor Stinner71aea8e2016-08-19 16:59:55 +02001586 if (o == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001587 return null_error();
Victor Stinner71aea8e2016-08-19 16:59:55 +02001588 }
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001589
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001590 m = o->ob_type->tp_as_sequence;
1591 if (m && m->sq_inplace_repeat)
1592 return m->sq_inplace_repeat(o, count);
1593 if (m && m->sq_repeat)
1594 return m->sq_repeat(o, count);
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001595
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001596 if (PySequence_Check(o)) {
1597 PyObject *n, *result;
1598 n = PyLong_FromSsize_t(count);
1599 if (n == NULL)
1600 return NULL;
1601 result = binary_iop1(o, n, NB_SLOT(nb_inplace_multiply),
1602 NB_SLOT(nb_multiply));
1603 Py_DECREF(n);
1604 if (result != Py_NotImplemented)
1605 return result;
1606 Py_DECREF(result);
1607 }
1608 return type_error("'%.200s' object can't be repeated", o);
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001609}
1610
1611PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +00001612PySequence_GetItem(PyObject *s, Py_ssize_t i)
Guido van Rossume15dee51995-07-18 14:12:02 +00001613{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001614 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001615
Victor Stinner71aea8e2016-08-19 16:59:55 +02001616 if (s == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001617 return null_error();
Victor Stinner71aea8e2016-08-19 16:59:55 +02001618 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001619
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001620 m = s->ob_type->tp_as_sequence;
1621 if (m && m->sq_item) {
1622 if (i < 0) {
1623 if (m->sq_length) {
1624 Py_ssize_t l = (*m->sq_length)(s);
Victor Stinnere20310f2015-11-05 13:56:58 +01001625 if (l < 0) {
1626 assert(PyErr_Occurred());
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001627 return NULL;
Victor Stinnere20310f2015-11-05 13:56:58 +01001628 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001629 i += l;
1630 }
1631 }
1632 return m->sq_item(s, i);
1633 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001634
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001635 return type_error("'%.200s' object does not support indexing", s);
Guido van Rossume15dee51995-07-18 14:12:02 +00001636}
1637
1638PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +00001639PySequence_GetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2)
Guido van Rossume15dee51995-07-18 14:12:02 +00001640{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001641 PyMappingMethods *mp;
Guido van Rossume15dee51995-07-18 14:12:02 +00001642
Victor Stinner71aea8e2016-08-19 16:59:55 +02001643 if (!s) {
1644 return null_error();
1645 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001646
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001647 mp = s->ob_type->tp_as_mapping;
Benjamin Peterson568867a2010-09-11 16:02:03 +00001648 if (mp && mp->mp_subscript) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001649 PyObject *res;
1650 PyObject *slice = _PySlice_FromIndices(i1, i2);
1651 if (!slice)
1652 return NULL;
1653 res = mp->mp_subscript(s, slice);
1654 Py_DECREF(slice);
1655 return res;
1656 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001657
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001658 return type_error("'%.200s' object is unsliceable", s);
Guido van Rossume15dee51995-07-18 14:12:02 +00001659}
1660
1661int
Martin v. Löwis18e16552006-02-15 17:27:45 +00001662PySequence_SetItem(PyObject *s, Py_ssize_t i, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001663{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001664 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001665
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001666 if (s == NULL) {
1667 null_error();
1668 return -1;
1669 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001670
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001671 m = s->ob_type->tp_as_sequence;
1672 if (m && m->sq_ass_item) {
1673 if (i < 0) {
1674 if (m->sq_length) {
1675 Py_ssize_t l = (*m->sq_length)(s);
1676 if (l < 0)
1677 return -1;
1678 i += l;
1679 }
1680 }
1681 return m->sq_ass_item(s, i, o);
1682 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001683
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001684 type_error("'%.200s' object does not support item assignment", s);
1685 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +00001686}
1687
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001688int
Martin v. Löwis18e16552006-02-15 17:27:45 +00001689PySequence_DelItem(PyObject *s, Py_ssize_t i)
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001690{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001691 PySequenceMethods *m;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001692
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001693 if (s == NULL) {
1694 null_error();
1695 return -1;
1696 }
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001697
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001698 m = s->ob_type->tp_as_sequence;
1699 if (m && m->sq_ass_item) {
1700 if (i < 0) {
1701 if (m->sq_length) {
1702 Py_ssize_t l = (*m->sq_length)(s);
1703 if (l < 0)
1704 return -1;
1705 i += l;
1706 }
1707 }
1708 return m->sq_ass_item(s, i, (PyObject *)NULL);
1709 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001710
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001711 type_error("'%.200s' object doesn't support item deletion", s);
1712 return -1;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001713}
1714
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001715int
Martin v. Löwis18e16552006-02-15 17:27:45 +00001716PySequence_SetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001717{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001718 PyMappingMethods *mp;
Guido van Rossume15dee51995-07-18 14:12:02 +00001719
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001720 if (s == NULL) {
1721 null_error();
1722 return -1;
1723 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001724
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001725 mp = s->ob_type->tp_as_mapping;
Benjamin Peterson568867a2010-09-11 16:02:03 +00001726 if (mp && mp->mp_ass_subscript) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001727 int res;
1728 PyObject *slice = _PySlice_FromIndices(i1, i2);
1729 if (!slice)
1730 return -1;
1731 res = mp->mp_ass_subscript(s, slice, o);
1732 Py_DECREF(slice);
1733 return res;
1734 }
Thomas Wouters1d75a792000-08-17 22:37:32 +00001735
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001736 type_error("'%.200s' object doesn't support slice assignment", s);
1737 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +00001738}
1739
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001740int
Martin v. Löwis18e16552006-02-15 17:27:45 +00001741PySequence_DelSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2)
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001742{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001743 PyMappingMethods *mp;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001744
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001745 if (s == NULL) {
1746 null_error();
1747 return -1;
1748 }
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001749
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001750 mp = s->ob_type->tp_as_mapping;
Benjamin Peterson568867a2010-09-11 16:02:03 +00001751 if (mp && mp->mp_ass_subscript) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001752 int res;
1753 PyObject *slice = _PySlice_FromIndices(i1, i2);
1754 if (!slice)
1755 return -1;
1756 res = mp->mp_ass_subscript(s, slice, NULL);
1757 Py_DECREF(slice);
1758 return res;
1759 }
1760 type_error("'%.200s' object doesn't support slice deletion", s);
1761 return -1;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001762}
1763
Guido van Rossume15dee51995-07-18 14:12:02 +00001764PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001765PySequence_Tuple(PyObject *v)
Guido van Rossume15dee51995-07-18 14:12:02 +00001766{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001767 PyObject *it; /* iter(v) */
1768 Py_ssize_t n; /* guess for result tuple size */
1769 PyObject *result = NULL;
1770 Py_ssize_t j;
Guido van Rossume15dee51995-07-18 14:12:02 +00001771
Victor Stinner71aea8e2016-08-19 16:59:55 +02001772 if (v == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001773 return null_error();
Victor Stinner71aea8e2016-08-19 16:59:55 +02001774 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001775
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001776 /* Special-case the common tuple and list cases, for efficiency. */
1777 if (PyTuple_CheckExact(v)) {
1778 /* Note that we can't know whether it's safe to return
1779 a tuple *subclass* instance as-is, hence the restriction
1780 to exact tuples here. In contrast, lists always make
1781 a copy, so there's no need for exactness below. */
1782 Py_INCREF(v);
1783 return v;
1784 }
Raymond Hettinger610a51f2015-05-17 14:45:58 -07001785 if (PyList_CheckExact(v))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001786 return PyList_AsTuple(v);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001787
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001788 /* Get iterator. */
1789 it = PyObject_GetIter(v);
1790 if (it == NULL)
1791 return NULL;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001792
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001793 /* Guess result size and allocate space. */
Armin Ronacheraa9a79d2012-10-06 14:03:24 +02001794 n = PyObject_LengthHint(v, 10);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001795 if (n == -1)
1796 goto Fail;
1797 result = PyTuple_New(n);
1798 if (result == NULL)
1799 goto Fail;
Tim Peters6912d4d2001-05-05 03:56:37 +00001800
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001801 /* Fill the tuple. */
1802 for (j = 0; ; ++j) {
1803 PyObject *item = PyIter_Next(it);
1804 if (item == NULL) {
1805 if (PyErr_Occurred())
1806 goto Fail;
1807 break;
1808 }
1809 if (j >= n) {
Martin Pantere8db8612016-07-25 02:30:05 +00001810 size_t newn = (size_t)n;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001811 /* The over-allocation strategy can grow a bit faster
1812 than for lists because unlike lists the
1813 over-allocation isn't permanent -- we reclaim
1814 the excess before the end of this routine.
1815 So, grow by ten and then add 25%.
1816 */
Martin Pantere8db8612016-07-25 02:30:05 +00001817 newn += 10u;
1818 newn += newn >> 2;
1819 if (newn > PY_SSIZE_T_MAX) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001820 /* Check for overflow */
1821 PyErr_NoMemory();
1822 Py_DECREF(item);
1823 goto Fail;
1824 }
Martin Pantere8db8612016-07-25 02:30:05 +00001825 n = (Py_ssize_t)newn;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001826 if (_PyTuple_Resize(&result, n) != 0) {
1827 Py_DECREF(item);
1828 goto Fail;
1829 }
1830 }
1831 PyTuple_SET_ITEM(result, j, item);
1832 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001833
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001834 /* Cut tuple back if guess was too large. */
1835 if (j < n &&
1836 _PyTuple_Resize(&result, j) != 0)
1837 goto Fail;
Tim Peters6912d4d2001-05-05 03:56:37 +00001838
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001839 Py_DECREF(it);
1840 return result;
Tim Peters6912d4d2001-05-05 03:56:37 +00001841
1842Fail:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001843 Py_XDECREF(result);
1844 Py_DECREF(it);
1845 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +00001846}
1847
Guido van Rossum3c5936a1996-12-05 21:51:24 +00001848PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001849PySequence_List(PyObject *v)
Guido van Rossum3c5936a1996-12-05 21:51:24 +00001850{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001851 PyObject *result; /* result list */
1852 PyObject *rv; /* return value from PyList_Extend */
Guido van Rossum4669fb41997-04-02 05:31:09 +00001853
Victor Stinner71aea8e2016-08-19 16:59:55 +02001854 if (v == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001855 return null_error();
Victor Stinner71aea8e2016-08-19 16:59:55 +02001856 }
Guido van Rossum5dba9e81998-07-10 18:03:50 +00001857
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001858 result = PyList_New(0);
1859 if (result == NULL)
1860 return NULL;
Tim Petersf553f892001-05-01 20:45:31 +00001861
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001862 rv = _PyList_Extend((PyListObject *)result, v);
1863 if (rv == NULL) {
1864 Py_DECREF(result);
1865 return NULL;
1866 }
1867 Py_DECREF(rv);
1868 return result;
Guido van Rossum3c5936a1996-12-05 21:51:24 +00001869}
1870
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001871PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001872PySequence_Fast(PyObject *v, const char *m)
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001873{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001874 PyObject *it;
Raymond Hettinger2fb70292004-01-11 23:26:51 +00001875
Victor Stinner71aea8e2016-08-19 16:59:55 +02001876 if (v == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001877 return null_error();
Victor Stinner71aea8e2016-08-19 16:59:55 +02001878 }
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001879
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001880 if (PyList_CheckExact(v) || PyTuple_CheckExact(v)) {
1881 Py_INCREF(v);
1882 return v;
1883 }
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001884
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001885 it = PyObject_GetIter(v);
1886 if (it == NULL) {
1887 if (PyErr_ExceptionMatches(PyExc_TypeError))
1888 PyErr_SetString(PyExc_TypeError, m);
1889 return NULL;
1890 }
Raymond Hettinger2fb70292004-01-11 23:26:51 +00001891
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001892 v = PySequence_List(it);
1893 Py_DECREF(it);
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001894
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001895 return v;
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001896}
1897
Tim Peters16a77ad2001-09-08 04:00:12 +00001898/* Iterate over seq. Result depends on the operation:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001899 PY_ITERSEARCH_COUNT: -1 if error, else # of times obj appears in seq.
1900 PY_ITERSEARCH_INDEX: 0-based index of first occurrence of obj in seq;
1901 set ValueError and return -1 if none found; also return -1 on error.
Tim Peters16a77ad2001-09-08 04:00:12 +00001902 Py_ITERSEARCH_CONTAINS: return 1 if obj in seq, else 0; -1 on error.
1903*/
Neal Norwitz1fc4b772006-03-04 18:49:58 +00001904Py_ssize_t
Tim Peters16a77ad2001-09-08 04:00:12 +00001905_PySequence_IterSearch(PyObject *seq, PyObject *obj, int operation)
Guido van Rossume15dee51995-07-18 14:12:02 +00001906{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001907 Py_ssize_t n;
1908 int wrapped; /* for PY_ITERSEARCH_INDEX, true iff n wrapped around */
1909 PyObject *it; /* iter(seq) */
Guido van Rossume15dee51995-07-18 14:12:02 +00001910
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001911 if (seq == NULL || obj == NULL) {
1912 null_error();
1913 return -1;
1914 }
Tim Peters75f8e352001-05-05 11:33:43 +00001915
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001916 it = PyObject_GetIter(seq);
1917 if (it == NULL) {
1918 type_error("argument of type '%.200s' is not iterable", seq);
1919 return -1;
1920 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001921
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001922 n = wrapped = 0;
1923 for (;;) {
1924 int cmp;
1925 PyObject *item = PyIter_Next(it);
1926 if (item == NULL) {
1927 if (PyErr_Occurred())
1928 goto Fail;
1929 break;
1930 }
Tim Peters16a77ad2001-09-08 04:00:12 +00001931
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001932 cmp = PyObject_RichCompareBool(obj, item, Py_EQ);
1933 Py_DECREF(item);
1934 if (cmp < 0)
1935 goto Fail;
1936 if (cmp > 0) {
1937 switch (operation) {
1938 case PY_ITERSEARCH_COUNT:
1939 if (n == PY_SSIZE_T_MAX) {
1940 PyErr_SetString(PyExc_OverflowError,
1941 "count exceeds C integer size");
1942 goto Fail;
1943 }
1944 ++n;
1945 break;
Tim Peters16a77ad2001-09-08 04:00:12 +00001946
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001947 case PY_ITERSEARCH_INDEX:
1948 if (wrapped) {
1949 PyErr_SetString(PyExc_OverflowError,
1950 "index exceeds C integer size");
1951 goto Fail;
1952 }
1953 goto Done;
Tim Peters16a77ad2001-09-08 04:00:12 +00001954
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001955 case PY_ITERSEARCH_CONTAINS:
1956 n = 1;
1957 goto Done;
Tim Peters16a77ad2001-09-08 04:00:12 +00001958
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001959 default:
1960 assert(!"unknown operation");
1961 }
1962 }
Tim Peters16a77ad2001-09-08 04:00:12 +00001963
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001964 if (operation == PY_ITERSEARCH_INDEX) {
1965 if (n == PY_SSIZE_T_MAX)
1966 wrapped = 1;
1967 ++n;
1968 }
1969 }
Tim Peters16a77ad2001-09-08 04:00:12 +00001970
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001971 if (operation != PY_ITERSEARCH_INDEX)
1972 goto Done;
Tim Peters16a77ad2001-09-08 04:00:12 +00001973
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001974 PyErr_SetString(PyExc_ValueError,
1975 "sequence.index(x): x not in sequence");
1976 /* fall into failure code */
Tim Peters16a77ad2001-09-08 04:00:12 +00001977Fail:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001978 n = -1;
1979 /* fall through */
Tim Peters16a77ad2001-09-08 04:00:12 +00001980Done:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001981 Py_DECREF(it);
1982 return n;
Tim Peters75f8e352001-05-05 11:33:43 +00001983
Guido van Rossume15dee51995-07-18 14:12:02 +00001984}
1985
Tim Peters16a77ad2001-09-08 04:00:12 +00001986/* Return # of times o appears in s. */
Neal Norwitz1fc4b772006-03-04 18:49:58 +00001987Py_ssize_t
Tim Peters16a77ad2001-09-08 04:00:12 +00001988PySequence_Count(PyObject *s, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001989{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001990 return _PySequence_IterSearch(s, o, PY_ITERSEARCH_COUNT);
Guido van Rossume15dee51995-07-18 14:12:02 +00001991}
1992
Tim Peterscb8d3682001-05-05 21:05:01 +00001993/* Return -1 if error; 1 if ob in seq; 0 if ob not in seq.
Tim Peters16a77ad2001-09-08 04:00:12 +00001994 * Use sq_contains if possible, else defer to _PySequence_IterSearch().
Tim Peterscb8d3682001-05-05 21:05:01 +00001995 */
1996int
1997PySequence_Contains(PyObject *seq, PyObject *ob)
1998{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001999 Py_ssize_t result;
2000 PySequenceMethods *sqm = seq->ob_type->tp_as_sequence;
2001 if (sqm != NULL && sqm->sq_contains != NULL)
2002 return (*sqm->sq_contains)(seq, ob);
2003 result = _PySequence_IterSearch(seq, ob, PY_ITERSEARCH_CONTAINS);
2004 return Py_SAFE_DOWNCAST(result, Py_ssize_t, int);
Tim Peterscb8d3682001-05-05 21:05:01 +00002005}
2006
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002007/* Backwards compatibility */
2008#undef PySequence_In
2009int
Fred Drake79912472000-07-09 04:06:11 +00002010PySequence_In(PyObject *w, PyObject *v)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002011{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002012 return PySequence_Contains(w, v);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002013}
2014
Neal Norwitz1fc4b772006-03-04 18:49:58 +00002015Py_ssize_t
Fred Drake79912472000-07-09 04:06:11 +00002016PySequence_Index(PyObject *s, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00002017{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002018 return _PySequence_IterSearch(s, o, PY_ITERSEARCH_INDEX);
Guido van Rossume15dee51995-07-18 14:12:02 +00002019}
2020
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002021/* Operations on mappings */
2022
2023int
Fred Drake79912472000-07-09 04:06:11 +00002024PyMapping_Check(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00002025{
Benjamin Peterson21992272011-12-28 12:01:31 -06002026 return o && o->ob_type->tp_as_mapping &&
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002027 o->ob_type->tp_as_mapping->mp_subscript;
Guido van Rossume15dee51995-07-18 14:12:02 +00002028}
2029
Martin v. Löwis18e16552006-02-15 17:27:45 +00002030Py_ssize_t
Jeremy Hylton6253f832000-07-12 12:56:19 +00002031PyMapping_Size(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00002032{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002033 PyMappingMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00002034
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002035 if (o == NULL) {
2036 null_error();
2037 return -1;
2038 }
Guido van Rossume15dee51995-07-18 14:12:02 +00002039
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002040 m = o->ob_type->tp_as_mapping;
2041 if (m && m->mp_length)
2042 return m->mp_length(o);
Guido van Rossume15dee51995-07-18 14:12:02 +00002043
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002044 type_error("object of type '%.200s' has no len()", o);
2045 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +00002046}
2047
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +00002048#undef PyMapping_Length
Martin v. Löwis18e16552006-02-15 17:27:45 +00002049Py_ssize_t
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +00002050PyMapping_Length(PyObject *o)
2051{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002052 return PyMapping_Size(o);
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +00002053}
2054#define PyMapping_Length PyMapping_Size
2055
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002056PyObject *
Serhiy Storchakac6792272013-10-19 21:03:34 +03002057PyMapping_GetItemString(PyObject *o, const char *key)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002058{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002059 PyObject *okey, *r;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002060
Victor Stinner71aea8e2016-08-19 16:59:55 +02002061 if (key == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002062 return null_error();
Victor Stinner71aea8e2016-08-19 16:59:55 +02002063 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002064
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002065 okey = PyUnicode_FromString(key);
2066 if (okey == NULL)
2067 return NULL;
2068 r = PyObject_GetItem(o, okey);
2069 Py_DECREF(okey);
2070 return r;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002071}
2072
2073int
Serhiy Storchakac6792272013-10-19 21:03:34 +03002074PyMapping_SetItemString(PyObject *o, const char *key, PyObject *value)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002075{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002076 PyObject *okey;
2077 int r;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002078
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002079 if (key == NULL) {
2080 null_error();
2081 return -1;
2082 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002083
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002084 okey = PyUnicode_FromString(key);
2085 if (okey == NULL)
2086 return -1;
2087 r = PyObject_SetItem(o, okey, value);
2088 Py_DECREF(okey);
2089 return r;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002090}
2091
2092int
Serhiy Storchakac6792272013-10-19 21:03:34 +03002093PyMapping_HasKeyString(PyObject *o, const char *key)
Guido van Rossume15dee51995-07-18 14:12:02 +00002094{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002095 PyObject *v;
Guido van Rossume15dee51995-07-18 14:12:02 +00002096
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002097 v = PyMapping_GetItemString(o, key);
2098 if (v) {
2099 Py_DECREF(v);
2100 return 1;
2101 }
2102 PyErr_Clear();
2103 return 0;
Guido van Rossume15dee51995-07-18 14:12:02 +00002104}
2105
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002106int
Fred Drake79912472000-07-09 04:06:11 +00002107PyMapping_HasKey(PyObject *o, PyObject *key)
Guido van Rossume15dee51995-07-18 14:12:02 +00002108{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002109 PyObject *v;
Guido van Rossume15dee51995-07-18 14:12:02 +00002110
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002111 v = PyObject_GetItem(o, key);
2112 if (v) {
2113 Py_DECREF(v);
2114 return 1;
2115 }
2116 PyErr_Clear();
2117 return 0;
Guido van Rossume15dee51995-07-18 14:12:02 +00002118}
2119
Guido van Rossumcc2b0162007-02-11 06:12:03 +00002120PyObject *
2121PyMapping_Keys(PyObject *o)
2122{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002123 PyObject *keys;
2124 PyObject *fast;
Martin v. Löwisbd928fe2011-10-14 10:20:37 +02002125 _Py_IDENTIFIER(keys);
Guido van Rossumcc2b0162007-02-11 06:12:03 +00002126
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002127 if (PyDict_CheckExact(o))
2128 return PyDict_Keys(o);
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002129 keys = _PyObject_CallMethodId(o, &PyId_keys, NULL);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002130 if (keys == NULL)
2131 return NULL;
2132 fast = PySequence_Fast(keys, "o.keys() are not iterable");
2133 Py_DECREF(keys);
2134 return fast;
Guido van Rossumcc2b0162007-02-11 06:12:03 +00002135}
2136
2137PyObject *
2138PyMapping_Items(PyObject *o)
2139{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002140 PyObject *items;
2141 PyObject *fast;
Martin v. Löwisbd928fe2011-10-14 10:20:37 +02002142 _Py_IDENTIFIER(items);
Guido van Rossumcc2b0162007-02-11 06:12:03 +00002143
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002144 if (PyDict_CheckExact(o))
2145 return PyDict_Items(o);
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002146 items = _PyObject_CallMethodId(o, &PyId_items, NULL);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002147 if (items == NULL)
2148 return NULL;
2149 fast = PySequence_Fast(items, "o.items() are not iterable");
2150 Py_DECREF(items);
2151 return fast;
Guido van Rossumcc2b0162007-02-11 06:12:03 +00002152}
2153
2154PyObject *
2155PyMapping_Values(PyObject *o)
2156{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002157 PyObject *values;
2158 PyObject *fast;
Martin v. Löwisbd928fe2011-10-14 10:20:37 +02002159 _Py_IDENTIFIER(values);
Guido van Rossumcc2b0162007-02-11 06:12:03 +00002160
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002161 if (PyDict_CheckExact(o))
2162 return PyDict_Values(o);
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002163 values = _PyObject_CallMethodId(o, &PyId_values, NULL);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002164 if (values == NULL)
2165 return NULL;
2166 fast = PySequence_Fast(values, "o.values() are not iterable");
2167 Py_DECREF(values);
2168 return fast;
Guido van Rossumcc2b0162007-02-11 06:12:03 +00002169}
2170
Guido van Rossum823649d2001-03-21 18:40:58 +00002171/* isinstance(), issubclass() */
2172
Benjamin Peterson9fc9bf42012-03-20 23:26:41 -04002173/* abstract_get_bases() has logically 4 return states:
Barry Warsawf16951c2002-04-23 22:45:44 +00002174 *
Barry Warsawf16951c2002-04-23 22:45:44 +00002175 * 1. getattr(cls, '__bases__') could raise an AttributeError
2176 * 2. getattr(cls, '__bases__') could raise some other exception
2177 * 3. getattr(cls, '__bases__') could return a tuple
2178 * 4. getattr(cls, '__bases__') could return something other than a tuple
2179 *
2180 * Only state #3 is a non-error state and only it returns a non-NULL object
2181 * (it returns the retrieved tuple).
2182 *
2183 * Any raised AttributeErrors are masked by clearing the exception and
2184 * returning NULL. If an object other than a tuple comes out of __bases__,
2185 * then again, the return value is NULL. So yes, these two situations
2186 * produce exactly the same results: NULL is returned and no error is set.
2187 *
2188 * If some exception other than AttributeError is raised, then NULL is also
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002189 * returned, but the exception is not cleared. That's because we want the
Barry Warsawf16951c2002-04-23 22:45:44 +00002190 * exception to be propagated along.
2191 *
2192 * Callers are expected to test for PyErr_Occurred() when the return value
2193 * is NULL to decide whether a valid exception should be propagated or not.
2194 * When there's no exception to propagate, it's customary for the caller to
2195 * set a TypeError.
2196 */
Neil Schemenauer6b471292001-10-18 03:18:43 +00002197static PyObject *
2198abstract_get_bases(PyObject *cls)
Guido van Rossum823649d2001-03-21 18:40:58 +00002199{
Benjamin Peterson9fc9bf42012-03-20 23:26:41 -04002200 _Py_IDENTIFIER(__bases__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002201 PyObject *bases;
Guido van Rossum823649d2001-03-21 18:40:58 +00002202
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002203 Py_ALLOW_RECURSION
Benjamin Peterson9fc9bf42012-03-20 23:26:41 -04002204 bases = _PyObject_GetAttrId(cls, &PyId___bases__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002205 Py_END_ALLOW_RECURSION
2206 if (bases == NULL) {
2207 if (PyErr_ExceptionMatches(PyExc_AttributeError))
2208 PyErr_Clear();
2209 return NULL;
2210 }
2211 if (!PyTuple_Check(bases)) {
2212 Py_DECREF(bases);
2213 return NULL;
2214 }
2215 return bases;
Neil Schemenauer6b471292001-10-18 03:18:43 +00002216}
2217
2218
2219static int
2220abstract_issubclass(PyObject *derived, PyObject *cls)
2221{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002222 PyObject *bases = NULL;
2223 Py_ssize_t i, n;
2224 int r = 0;
Neil Schemenauer6b471292001-10-18 03:18:43 +00002225
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002226 while (1) {
2227 if (derived == cls)
2228 return 1;
2229 bases = abstract_get_bases(derived);
2230 if (bases == NULL) {
2231 if (PyErr_Occurred())
2232 return -1;
2233 return 0;
2234 }
2235 n = PyTuple_GET_SIZE(bases);
2236 if (n == 0) {
2237 Py_DECREF(bases);
2238 return 0;
2239 }
2240 /* Avoid recursivity in the single inheritance case */
2241 if (n == 1) {
2242 derived = PyTuple_GET_ITEM(bases, 0);
2243 Py_DECREF(bases);
2244 continue;
2245 }
2246 for (i = 0; i < n; i++) {
2247 r = abstract_issubclass(PyTuple_GET_ITEM(bases, i), cls);
2248 if (r != 0)
2249 break;
2250 }
2251 Py_DECREF(bases);
2252 return r;
2253 }
Guido van Rossum823649d2001-03-21 18:40:58 +00002254}
2255
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00002256static int
2257check_class(PyObject *cls, const char *error)
2258{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002259 PyObject *bases = abstract_get_bases(cls);
2260 if (bases == NULL) {
2261 /* Do not mask errors. */
2262 if (!PyErr_Occurred())
2263 PyErr_SetString(PyExc_TypeError, error);
2264 return 0;
2265 }
2266 Py_DECREF(bases);
2267 return -1;
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00002268}
2269
Brett Cannon4f653312004-03-20 22:52:14 +00002270static int
Antoine Pitrouec569b72008-08-26 22:40:48 +00002271recursive_isinstance(PyObject *inst, PyObject *cls)
Guido van Rossum823649d2001-03-21 18:40:58 +00002272{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002273 PyObject *icls;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002274 int retval = 0;
Benjamin Peterson9fc9bf42012-03-20 23:26:41 -04002275 _Py_IDENTIFIER(__class__);
Guido van Rossum03bc7d32003-02-12 03:32:58 +00002276
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002277 if (PyType_Check(cls)) {
2278 retval = PyObject_TypeCheck(inst, (PyTypeObject *)cls);
2279 if (retval == 0) {
Benjamin Peterson9fc9bf42012-03-20 23:26:41 -04002280 PyObject *c = _PyObject_GetAttrId(inst, &PyId___class__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002281 if (c == NULL) {
Benjamin Peterson72288d42010-11-20 17:21:08 +00002282 if (PyErr_ExceptionMatches(PyExc_AttributeError))
R. David Murray6bb99892010-11-20 16:33:30 +00002283 PyErr_Clear();
Benjamin Peterson72288d42010-11-20 17:21:08 +00002284 else
R. David Murray6bb99892010-11-20 16:33:30 +00002285 retval = -1;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002286 }
2287 else {
2288 if (c != (PyObject *)(inst->ob_type) &&
2289 PyType_Check(c))
2290 retval = PyType_IsSubtype(
2291 (PyTypeObject *)c,
2292 (PyTypeObject *)cls);
2293 Py_DECREF(c);
2294 }
2295 }
2296 }
2297 else {
2298 if (!check_class(cls,
Benjamin Petersone893af52010-06-28 19:43:42 +00002299 "isinstance() arg 2 must be a type or tuple of types"))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002300 return -1;
Benjamin Peterson9fc9bf42012-03-20 23:26:41 -04002301 icls = _PyObject_GetAttrId(inst, &PyId___class__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002302 if (icls == NULL) {
Benjamin Peterson72288d42010-11-20 17:21:08 +00002303 if (PyErr_ExceptionMatches(PyExc_AttributeError))
R. David Murray6bb99892010-11-20 16:33:30 +00002304 PyErr_Clear();
Benjamin Peterson72288d42010-11-20 17:21:08 +00002305 else
R. David Murray6bb99892010-11-20 16:33:30 +00002306 retval = -1;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002307 }
2308 else {
2309 retval = abstract_issubclass(icls, cls);
2310 Py_DECREF(icls);
2311 }
2312 }
Guido van Rossum823649d2001-03-21 18:40:58 +00002313
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002314 return retval;
Guido van Rossum823649d2001-03-21 18:40:58 +00002315}
2316
2317int
Brett Cannon4f653312004-03-20 22:52:14 +00002318PyObject_IsInstance(PyObject *inst, PyObject *cls)
2319{
Benjamin Petersonce798522012-01-22 11:24:29 -05002320 _Py_IDENTIFIER(__instancecheck__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002321 PyObject *checker;
Christian Heimesd5e2b6f2008-03-19 21:50:51 +00002322
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002323 /* Quick test for an exact match */
2324 if (Py_TYPE(inst) == (PyTypeObject *)cls)
2325 return 1;
Christian Heimesd5e2b6f2008-03-19 21:50:51 +00002326
Georg Brandl72b8a802014-10-03 09:26:37 +02002327 /* We know what type's __instancecheck__ does. */
2328 if (PyType_CheckExact(cls)) {
2329 return recursive_isinstance(inst, cls);
2330 }
2331
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002332 if (PyTuple_Check(cls)) {
2333 Py_ssize_t i;
2334 Py_ssize_t n;
2335 int r = 0;
Antoine Pitrouec569b72008-08-26 22:40:48 +00002336
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002337 if (Py_EnterRecursiveCall(" in __instancecheck__"))
2338 return -1;
2339 n = PyTuple_GET_SIZE(cls);
2340 for (i = 0; i < n; ++i) {
2341 PyObject *item = PyTuple_GET_ITEM(cls, i);
2342 r = PyObject_IsInstance(inst, item);
2343 if (r != 0)
2344 /* either found it, or got an error */
2345 break;
2346 }
2347 Py_LeaveRecursiveCall();
2348 return r;
2349 }
Benjamin Peterson88fe5f92009-05-16 21:55:24 +00002350
Benjamin Petersonce798522012-01-22 11:24:29 -05002351 checker = _PyObject_LookupSpecial(cls, &PyId___instancecheck__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002352 if (checker != NULL) {
2353 PyObject *res;
2354 int ok = -1;
2355 if (Py_EnterRecursiveCall(" in __instancecheck__")) {
2356 Py_DECREF(checker);
2357 return ok;
2358 }
Victor Stinnerde4ae3d2016-12-04 22:59:09 +01002359 res = PyObject_CallFunctionObjArgs(checker, inst, NULL);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002360 Py_LeaveRecursiveCall();
2361 Py_DECREF(checker);
2362 if (res != NULL) {
2363 ok = PyObject_IsTrue(res);
2364 Py_DECREF(res);
2365 }
2366 return ok;
2367 }
2368 else if (PyErr_Occurred())
2369 return -1;
Georg Brandl72b8a802014-10-03 09:26:37 +02002370 /* Probably never reached anymore. */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002371 return recursive_isinstance(inst, cls);
Brett Cannon4f653312004-03-20 22:52:14 +00002372}
2373
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002374static int
Antoine Pitrouec569b72008-08-26 22:40:48 +00002375recursive_issubclass(PyObject *derived, PyObject *cls)
Guido van Rossum823649d2001-03-21 18:40:58 +00002376{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002377 if (PyType_Check(cls) && PyType_Check(derived)) {
2378 /* Fast path (non-recursive) */
2379 return PyType_IsSubtype((PyTypeObject *)derived, (PyTypeObject *)cls);
2380 }
2381 if (!check_class(derived,
2382 "issubclass() arg 1 must be a class"))
2383 return -1;
2384 if (!check_class(cls,
2385 "issubclass() arg 2 must be a class"
2386 " or tuple of classes"))
2387 return -1;
Guido van Rossum823649d2001-03-21 18:40:58 +00002388
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002389 return abstract_issubclass(derived, cls);
Guido van Rossum823649d2001-03-21 18:40:58 +00002390}
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002391
Brett Cannon4f653312004-03-20 22:52:14 +00002392int
2393PyObject_IsSubclass(PyObject *derived, PyObject *cls)
2394{
Benjamin Petersonce798522012-01-22 11:24:29 -05002395 _Py_IDENTIFIER(__subclasscheck__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002396 PyObject *checker;
Georg Brandldcfe8e42009-05-17 08:22:45 +00002397
Georg Brandl72b8a802014-10-03 09:26:37 +02002398 /* We know what type's __subclasscheck__ does. */
2399 if (PyType_CheckExact(cls)) {
2400 /* Quick test for an exact match */
2401 if (derived == cls)
2402 return 1;
2403 return recursive_issubclass(derived, cls);
2404 }
2405
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002406 if (PyTuple_Check(cls)) {
2407 Py_ssize_t i;
2408 Py_ssize_t n;
2409 int r = 0;
Antoine Pitrouec569b72008-08-26 22:40:48 +00002410
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002411 if (Py_EnterRecursiveCall(" in __subclasscheck__"))
2412 return -1;
2413 n = PyTuple_GET_SIZE(cls);
2414 for (i = 0; i < n; ++i) {
2415 PyObject *item = PyTuple_GET_ITEM(cls, i);
2416 r = PyObject_IsSubclass(derived, item);
2417 if (r != 0)
2418 /* either found it, or got an error */
2419 break;
2420 }
2421 Py_LeaveRecursiveCall();
2422 return r;
2423 }
Benjamin Peterson88fe5f92009-05-16 21:55:24 +00002424
Benjamin Petersonce798522012-01-22 11:24:29 -05002425 checker = _PyObject_LookupSpecial(cls, &PyId___subclasscheck__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002426 if (checker != NULL) {
2427 PyObject *res;
2428 int ok = -1;
2429 if (Py_EnterRecursiveCall(" in __subclasscheck__")) {
2430 Py_DECREF(checker);
2431 return ok;
2432 }
Victor Stinnerde4ae3d2016-12-04 22:59:09 +01002433 res = PyObject_CallFunctionObjArgs(checker, derived, NULL);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002434 Py_LeaveRecursiveCall();
2435 Py_DECREF(checker);
2436 if (res != NULL) {
2437 ok = PyObject_IsTrue(res);
2438 Py_DECREF(res);
2439 }
2440 return ok;
2441 }
2442 else if (PyErr_Occurred())
2443 return -1;
Georg Brandl72b8a802014-10-03 09:26:37 +02002444 /* Probably never reached anymore. */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002445 return recursive_issubclass(derived, cls);
Antoine Pitrouec569b72008-08-26 22:40:48 +00002446}
2447
2448int
2449_PyObject_RealIsInstance(PyObject *inst, PyObject *cls)
2450{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002451 return recursive_isinstance(inst, cls);
Antoine Pitrouec569b72008-08-26 22:40:48 +00002452}
2453
2454int
2455_PyObject_RealIsSubclass(PyObject *derived, PyObject *cls)
2456{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002457 return recursive_issubclass(derived, cls);
Brett Cannon4f653312004-03-20 22:52:14 +00002458}
2459
2460
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002461PyObject *
2462PyObject_GetIter(PyObject *o)
2463{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002464 PyTypeObject *t = o->ob_type;
Victor Stinner14e6d092016-12-09 17:08:59 +01002465 getiterfunc f;
2466
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002467 f = t->tp_iter;
2468 if (f == NULL) {
2469 if (PySequence_Check(o))
2470 return PySeqIter_New(o);
2471 return type_error("'%.200s' object is not iterable", o);
2472 }
2473 else {
2474 PyObject *res = (*f)(o);
2475 if (res != NULL && !PyIter_Check(res)) {
2476 PyErr_Format(PyExc_TypeError,
2477 "iter() returned non-iterator "
2478 "of type '%.100s'",
2479 res->ob_type->tp_name);
2480 Py_DECREF(res);
2481 res = NULL;
2482 }
2483 return res;
2484 }
Guido van Rossum213c7a62001-04-23 14:08:49 +00002485}
2486
Tim Petersf4848da2001-05-05 00:14:56 +00002487/* Return next item.
2488 * If an error occurs, return NULL. PyErr_Occurred() will be true.
2489 * If the iteration terminates normally, return NULL and clear the
2490 * PyExc_StopIteration exception (if it was set). PyErr_Occurred()
2491 * will be false.
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002492 * Else return the next object. PyErr_Occurred() will be false.
Tim Petersf4848da2001-05-05 00:14:56 +00002493 */
Guido van Rossum213c7a62001-04-23 14:08:49 +00002494PyObject *
2495PyIter_Next(PyObject *iter)
2496{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002497 PyObject *result;
2498 result = (*iter->ob_type->tp_iternext)(iter);
2499 if (result == NULL &&
2500 PyErr_Occurred() &&
2501 PyErr_ExceptionMatches(PyExc_StopIteration))
2502 PyErr_Clear();
2503 return result;
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002504}
Gregory P. Smithfb94c5f2010-03-14 06:49:55 +00002505
2506
2507/*
2508 * Flatten a sequence of bytes() objects into a C array of
2509 * NULL terminated string pointers with a NULL char* terminating the array.
2510 * (ie: an argv or env list)
2511 *
Victor Stinner0e2d3cf2013-07-07 17:22:41 +02002512 * Memory allocated for the returned list is allocated using PyMem_Malloc()
2513 * and MUST be freed by _Py_FreeCharPArray().
Gregory P. Smithfb94c5f2010-03-14 06:49:55 +00002514 */
2515char *const *
2516_PySequence_BytesToCharpArray(PyObject* self)
2517{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002518 char **array;
2519 Py_ssize_t i, argc;
2520 PyObject *item = NULL;
Victor Stinner0e2d3cf2013-07-07 17:22:41 +02002521 Py_ssize_t size;
Gregory P. Smithfb94c5f2010-03-14 06:49:55 +00002522
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002523 argc = PySequence_Size(self);
2524 if (argc == -1)
2525 return NULL;
Gregory P. Smithfb94c5f2010-03-14 06:49:55 +00002526
Stefan Krah7cacd2e2012-08-21 08:16:09 +02002527 assert(argc >= 0);
2528
2529 if ((size_t)argc > (PY_SSIZE_T_MAX-sizeof(char *)) / sizeof(char *)) {
2530 PyErr_NoMemory();
2531 return NULL;
2532 }
2533
Victor Stinner0e2d3cf2013-07-07 17:22:41 +02002534 array = PyMem_Malloc((argc + 1) * sizeof(char *));
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002535 if (array == NULL) {
2536 PyErr_NoMemory();
2537 return NULL;
2538 }
2539 for (i = 0; i < argc; ++i) {
2540 char *data;
2541 item = PySequence_GetItem(self, i);
Stefan Krahfd24f9e2012-08-20 11:04:24 +02002542 if (item == NULL) {
2543 /* NULL terminate before freeing. */
2544 array[i] = NULL;
2545 goto fail;
2546 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002547 data = PyBytes_AsString(item);
2548 if (data == NULL) {
2549 /* NULL terminate before freeing. */
2550 array[i] = NULL;
2551 goto fail;
2552 }
Victor Stinner0e2d3cf2013-07-07 17:22:41 +02002553 size = PyBytes_GET_SIZE(item) + 1;
2554 array[i] = PyMem_Malloc(size);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002555 if (!array[i]) {
2556 PyErr_NoMemory();
2557 goto fail;
2558 }
Victor Stinner0e2d3cf2013-07-07 17:22:41 +02002559 memcpy(array[i], data, size);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002560 Py_DECREF(item);
2561 }
2562 array[argc] = NULL;
Gregory P. Smithfb94c5f2010-03-14 06:49:55 +00002563
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002564 return array;
Gregory P. Smithfb94c5f2010-03-14 06:49:55 +00002565
2566fail:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002567 Py_XDECREF(item);
2568 _Py_FreeCharPArray(array);
2569 return NULL;
Gregory P. Smithfb94c5f2010-03-14 06:49:55 +00002570}
2571
2572
2573/* Free's a NULL terminated char** array of C strings. */
2574void
2575_Py_FreeCharPArray(char *const array[])
2576{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002577 Py_ssize_t i;
2578 for (i = 0; array[i] != NULL; ++i) {
Victor Stinner0e2d3cf2013-07-07 17:22:41 +02002579 PyMem_Free(array[i]);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002580 }
Victor Stinner0e2d3cf2013-07-07 17:22:41 +02002581 PyMem_Free((void*)array);
Gregory P. Smithfb94c5f2010-03-14 06:49:55 +00002582}