blob: 323c985b3ecb4f94c9cb634b21de6d67ab821684 [file] [log] [blame]
Guido van Rossume15dee51995-07-18 14:12:02 +00001/* Abstract Object Interface (many thanks to Jim Fulton) */
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002
Guido van Rossume15dee51995-07-18 14:12:02 +00003#include "Python.h"
Guido van Rossumfa0b6ab1998-05-22 15:23:36 +00004#include <ctype.h>
Neil Schemenauer5a1f0152001-01-04 01:39:06 +00005#include "structmember.h" /* we need the offsetof() macro from there */
Tim Peters64b5ce32001-09-10 20:52:51 +00006#include "longintrepr.h"
Neil Schemenauer5a1f0152001-01-04 01:39:06 +00007
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00008
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00009
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000010/* Shorthands to return certain errors */
Guido van Rossume15dee51995-07-18 14:12:02 +000011
12static PyObject *
Thomas Wouters0e3f5912006-08-11 14:57:12 +000013type_error(const char *msg, PyObject *obj)
Guido van Rossume15dee51995-07-18 14:12:02 +000014{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000015 PyErr_Format(PyExc_TypeError, msg, obj->ob_type->tp_name);
16 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +000017}
18
Guido van Rossum052b7e11996-11-11 15:08:19 +000019static PyObject *
Fred Drake79912472000-07-09 04:06:11 +000020null_error(void)
Guido van Rossume15dee51995-07-18 14:12:02 +000021{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000022 if (!PyErr_Occurred())
23 PyErr_SetString(PyExc_SystemError,
24 "null argument to internal routine");
25 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +000026}
27
Guido van Rossumcea1c8c1998-05-22 00:47:05 +000028/* Operations on any object */
29
Guido van Rossume15dee51995-07-18 14:12:02 +000030PyObject *
Fred Drake79912472000-07-09 04:06:11 +000031PyObject_Type(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +000032{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000033 PyObject *v;
Guido van Rossume15dee51995-07-18 14:12:02 +000034
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000035 if (o == NULL)
36 return null_error();
37 v = (PyObject *)o->ob_type;
38 Py_INCREF(v);
39 return v;
Guido van Rossume15dee51995-07-18 14:12:02 +000040}
41
Martin v. Löwis18e16552006-02-15 17:27:45 +000042Py_ssize_t
Jeremy Hylton6253f832000-07-12 12:56:19 +000043PyObject_Size(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +000044{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000045 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +000046
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000047 if (o == NULL) {
48 null_error();
49 return -1;
50 }
Guido van Rossume15dee51995-07-18 14:12:02 +000051
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000052 m = o->ob_type->tp_as_sequence;
53 if (m && m->sq_length)
54 return m->sq_length(o);
Guido van Rossume15dee51995-07-18 14:12:02 +000055
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000056 return PyMapping_Size(o);
Guido van Rossume15dee51995-07-18 14:12:02 +000057}
58
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +000059#undef PyObject_Length
Martin v. Löwis18e16552006-02-15 17:27:45 +000060Py_ssize_t
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +000061PyObject_Length(PyObject *o)
62{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000063 return PyObject_Size(o);
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +000064}
65#define PyObject_Length PyObject_Size
66
Armin Ronacheraa9a79d2012-10-06 14:03:24 +020067int
68_PyObject_HasLen(PyObject *o) {
69 return (Py_TYPE(o)->tp_as_sequence && Py_TYPE(o)->tp_as_sequence->sq_length) ||
70 (Py_TYPE(o)->tp_as_mapping && Py_TYPE(o)->tp_as_mapping->mp_length);
71}
Raymond Hettinger6b27cda2005-09-24 21:23:05 +000072
Christian Heimes255f53b2007-12-08 15:33:56 +000073/* The length hint function returns a non-negative value from o.__len__()
Armin Ronacher74b38b12012-10-07 10:29:32 +020074 or o.__length_hint__(). If those methods aren't found the defaultvalue is
75 returned. If one of the calls fails with an exception other than TypeError
76 this function returns -1.
Christian Heimes255f53b2007-12-08 15:33:56 +000077*/
78
79Py_ssize_t
Armin Ronacheraa9a79d2012-10-06 14:03:24 +020080PyObject_LengthHint(PyObject *o, Py_ssize_t defaultvalue)
Christian Heimes255f53b2007-12-08 15:33:56 +000081{
Christian Heimesb70e8a12012-10-06 17:16:39 +020082 PyObject *hint, *result;
Christian Heimes6314d162012-10-06 17:13:29 +020083 Py_ssize_t res;
Benjamin Petersonce798522012-01-22 11:24:29 -050084 _Py_IDENTIFIER(__length_hint__);
Serhiy Storchakaf740d462013-10-24 23:19:51 +030085 if (_PyObject_HasLen(o)) {
86 res = PyObject_Length(o);
87 if (res < 0 && PyErr_Occurred()) {
88 if (!PyErr_ExceptionMatches(PyExc_TypeError)) {
89 return -1;
90 }
91 PyErr_Clear();
Armin Ronacheraa9a79d2012-10-06 14:03:24 +020092 }
Serhiy Storchakaf740d462013-10-24 23:19:51 +030093 else {
94 return res;
95 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000096 }
Christian Heimes6314d162012-10-06 17:13:29 +020097 hint = _PyObject_LookupSpecial(o, &PyId___length_hint__);
Armin Ronacheraa9a79d2012-10-06 14:03:24 +020098 if (hint == NULL) {
99 if (PyErr_Occurred()) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000100 return -1;
Armin Ronacheraa9a79d2012-10-06 14:03:24 +0200101 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000102 return defaultvalue;
103 }
Christian Heimesb70e8a12012-10-06 17:16:39 +0200104 result = PyObject_CallFunctionObjArgs(hint, NULL);
Armin Ronacheraa9a79d2012-10-06 14:03:24 +0200105 Py_DECREF(hint);
106 if (result == NULL) {
107 if (PyErr_ExceptionMatches(PyExc_TypeError)) {
108 PyErr_Clear();
109 return defaultvalue;
110 }
111 return -1;
112 }
113 else if (result == Py_NotImplemented) {
114 Py_DECREF(result);
115 return defaultvalue;
116 }
117 if (!PyLong_Check(result)) {
Armin Ronacher74b38b12012-10-07 10:29:32 +0200118 PyErr_Format(PyExc_TypeError, "__length_hint__ must be an integer, not %.100s",
Armin Ronacheraa9a79d2012-10-06 14:03:24 +0200119 Py_TYPE(result)->tp_name);
120 Py_DECREF(result);
121 return -1;
122 }
Armin Ronacher74b38b12012-10-07 10:29:32 +0200123 res = PyLong_AsSsize_t(result);
Armin Ronacheraa9a79d2012-10-06 14:03:24 +0200124 Py_DECREF(result);
Armin Ronacher74b38b12012-10-07 10:29:32 +0200125 if (res < 0 && PyErr_Occurred()) {
Armin Ronacheraa9a79d2012-10-06 14:03:24 +0200126 return -1;
127 }
Armin Ronacher74b38b12012-10-07 10:29:32 +0200128 if (res < 0) {
Armin Ronacheraa9a79d2012-10-06 14:03:24 +0200129 PyErr_Format(PyExc_ValueError, "__length_hint__() should return >= 0");
130 return -1;
131 }
Armin Ronacher74b38b12012-10-07 10:29:32 +0200132 return res;
Raymond Hettinger6b27cda2005-09-24 21:23:05 +0000133}
134
Guido van Rossume15dee51995-07-18 14:12:02 +0000135PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000136PyObject_GetItem(PyObject *o, PyObject *key)
Guido van Rossume15dee51995-07-18 14:12:02 +0000137{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000138 PyMappingMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +0000139
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000140 if (o == NULL || key == NULL)
141 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +0000142
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000143 m = o->ob_type->tp_as_mapping;
144 if (m && m->mp_subscript)
145 return m->mp_subscript(o, key);
Guido van Rossume15dee51995-07-18 14:12:02 +0000146
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000147 if (o->ob_type->tp_as_sequence) {
148 if (PyIndex_Check(key)) {
149 Py_ssize_t key_value;
150 key_value = PyNumber_AsSsize_t(key, PyExc_IndexError);
151 if (key_value == -1 && PyErr_Occurred())
152 return NULL;
153 return PySequence_GetItem(o, key_value);
154 }
155 else if (o->ob_type->tp_as_sequence->sq_item)
156 return type_error("sequence index must "
157 "be integer, not '%.200s'", key);
158 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000159
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000160 return type_error("'%.200s' object is not subscriptable", o);
Guido van Rossume15dee51995-07-18 14:12:02 +0000161}
162
163int
Fred Drake79912472000-07-09 04:06:11 +0000164PyObject_SetItem(PyObject *o, PyObject *key, PyObject *value)
Guido van Rossume15dee51995-07-18 14:12:02 +0000165{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000166 PyMappingMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +0000167
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000168 if (o == NULL || key == NULL || value == NULL) {
169 null_error();
170 return -1;
171 }
172 m = o->ob_type->tp_as_mapping;
173 if (m && m->mp_ass_subscript)
174 return m->mp_ass_subscript(o, key, value);
Guido van Rossume15dee51995-07-18 14:12:02 +0000175
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000176 if (o->ob_type->tp_as_sequence) {
177 if (PyIndex_Check(key)) {
178 Py_ssize_t key_value;
179 key_value = PyNumber_AsSsize_t(key, PyExc_IndexError);
180 if (key_value == -1 && PyErr_Occurred())
181 return -1;
182 return PySequence_SetItem(o, key_value, value);
183 }
184 else if (o->ob_type->tp_as_sequence->sq_ass_item) {
185 type_error("sequence index must be "
186 "integer, not '%.200s'", key);
187 return -1;
188 }
189 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000190
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000191 type_error("'%.200s' object does not support item assignment", o);
192 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +0000193}
194
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000195int
Fred Drake79912472000-07-09 04:06:11 +0000196PyObject_DelItem(PyObject *o, PyObject *key)
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000197{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000198 PyMappingMethods *m;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000199
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000200 if (o == NULL || key == NULL) {
201 null_error();
202 return -1;
203 }
204 m = o->ob_type->tp_as_mapping;
205 if (m && m->mp_ass_subscript)
206 return m->mp_ass_subscript(o, key, (PyObject*)NULL);
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000207
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000208 if (o->ob_type->tp_as_sequence) {
209 if (PyIndex_Check(key)) {
210 Py_ssize_t key_value;
211 key_value = PyNumber_AsSsize_t(key, PyExc_IndexError);
212 if (key_value == -1 && PyErr_Occurred())
213 return -1;
214 return PySequence_DelItem(o, key_value);
215 }
216 else if (o->ob_type->tp_as_sequence->sq_ass_item) {
217 type_error("sequence index must be "
218 "integer, not '%.200s'", key);
219 return -1;
220 }
221 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000222
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000223 type_error("'%.200s' object does not support item deletion", o);
224 return -1;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +0000225}
226
Martin v. Löwisb0d71d02002-01-05 10:50:30 +0000227int
Serhiy Storchakac6792272013-10-19 21:03:34 +0300228PyObject_DelItemString(PyObject *o, const char *key)
Martin v. Löwisb0d71d02002-01-05 10:50:30 +0000229{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000230 PyObject *okey;
231 int ret;
Martin v. Löwisb0d71d02002-01-05 10:50:30 +0000232
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000233 if (o == NULL || key == NULL) {
234 null_error();
235 return -1;
236 }
237 okey = PyUnicode_FromString(key);
238 if (okey == NULL)
239 return -1;
240 ret = PyObject_DelItem(o, okey);
241 Py_DECREF(okey);
242 return ret;
Martin v. Löwisb0d71d02002-01-05 10:50:30 +0000243}
244
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000245/* We release the buffer right after use of this function which could
Guido van Rossum98297ee2007-11-06 21:34:58 +0000246 cause issues later on. Don't use these functions in new code.
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000247 */
Thomas Wouters73e5a5b2006-06-08 15:35:45 +0000248int
249PyObject_AsCharBuffer(PyObject *obj,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000250 const char **buffer,
251 Py_ssize_t *buffer_len)
Guido van Rossum4c08d552000-03-10 22:55:18 +0000252{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000253 PyBufferProcs *pb;
254 Py_buffer view;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000255
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000256 if (obj == NULL || buffer == NULL || buffer_len == NULL) {
257 null_error();
258 return -1;
259 }
260 pb = obj->ob_type->tp_as_buffer;
261 if (pb == NULL || pb->bf_getbuffer == NULL) {
262 PyErr_SetString(PyExc_TypeError,
R David Murray861470c2014-10-05 11:47:01 -0400263 "expected a bytes-like object");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000264 return -1;
265 }
266 if ((*pb->bf_getbuffer)(obj, &view, PyBUF_SIMPLE)) return -1;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000267
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000268 *buffer = view.buf;
269 *buffer_len = view.len;
270 if (pb->bf_releasebuffer != NULL)
271 (*pb->bf_releasebuffer)(obj, &view);
272 Py_XDECREF(view.obj);
273 return 0;
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000274}
Guido van Rossum4c08d552000-03-10 22:55:18 +0000275
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000276int
277PyObject_CheckReadBuffer(PyObject *obj)
278{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000279 PyBufferProcs *pb = obj->ob_type->tp_as_buffer;
280 Py_buffer view;
Jeremy Hylton89c3a222001-11-09 21:59:42 +0000281
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000282 if (pb == NULL ||
283 pb->bf_getbuffer == NULL)
284 return 0;
285 if ((*pb->bf_getbuffer)(obj, &view, PyBUF_SIMPLE) == -1) {
286 PyErr_Clear();
287 return 0;
288 }
289 PyBuffer_Release(&view);
290 return 1;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000291}
292
293int PyObject_AsReadBuffer(PyObject *obj,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000294 const void **buffer,
295 Py_ssize_t *buffer_len)
Guido van Rossum4c08d552000-03-10 22:55:18 +0000296{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000297 PyBufferProcs *pb;
298 Py_buffer view;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000299
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000300 if (obj == NULL || buffer == NULL || buffer_len == NULL) {
301 null_error();
302 return -1;
303 }
304 pb = obj->ob_type->tp_as_buffer;
305 if (pb == NULL ||
306 pb->bf_getbuffer == NULL) {
307 PyErr_SetString(PyExc_TypeError,
R David Murray861470c2014-10-05 11:47:01 -0400308 "expected a bytes-like object");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000309 return -1;
310 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000311
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000312 if ((*pb->bf_getbuffer)(obj, &view, PyBUF_SIMPLE)) return -1;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000313
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000314 *buffer = view.buf;
315 *buffer_len = view.len;
316 if (pb->bf_releasebuffer != NULL)
317 (*pb->bf_releasebuffer)(obj, &view);
318 Py_XDECREF(view.obj);
319 return 0;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000320}
321
322int PyObject_AsWriteBuffer(PyObject *obj,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000323 void **buffer,
324 Py_ssize_t *buffer_len)
Guido van Rossum4c08d552000-03-10 22:55:18 +0000325{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000326 PyBufferProcs *pb;
327 Py_buffer view;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000328
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000329 if (obj == NULL || buffer == NULL || buffer_len == NULL) {
330 null_error();
331 return -1;
332 }
333 pb = obj->ob_type->tp_as_buffer;
334 if (pb == NULL ||
335 pb->bf_getbuffer == NULL ||
336 ((*pb->bf_getbuffer)(obj, &view, PyBUF_WRITABLE) != 0)) {
337 PyErr_SetString(PyExc_TypeError,
R David Murray861470c2014-10-05 11:47:01 -0400338 "expected a writable bytes-like object");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000339 return -1;
340 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000341
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000342 *buffer = view.buf;
343 *buffer_len = view.len;
344 if (pb->bf_releasebuffer != NULL)
345 (*pb->bf_releasebuffer)(obj, &view);
346 Py_XDECREF(view.obj);
347 return 0;
Guido van Rossum4c08d552000-03-10 22:55:18 +0000348}
349
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000350/* Buffer C-API for Python 3.0 */
351
352int
Travis E. Oliphant8ae62b62007-09-23 02:00:13 +0000353PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000354{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000355 if (!PyObject_CheckBuffer(obj)) {
356 PyErr_Format(PyExc_TypeError,
R David Murray861470c2014-10-05 11:47:01 -0400357 "a bytes-like object is required, not '%.100s'",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000358 Py_TYPE(obj)->tp_name);
359 return -1;
360 }
361 return (*(obj->ob_type->tp_as_buffer->bf_getbuffer))(obj, view, flags);
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000362}
363
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000364static int
Stefan Krah9a2d99e2012-02-25 12:24:21 +0100365_IsFortranContiguous(const Py_buffer *view)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000366{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000367 Py_ssize_t sd, dim;
368 int i;
Guido van Rossum98297ee2007-11-06 21:34:58 +0000369
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000370 if (view->ndim == 0) return 1;
371 if (view->strides == NULL) return (view->ndim == 1);
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000372
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000373 sd = view->itemsize;
374 if (view->ndim == 1) return (view->shape[0] == 1 ||
375 sd == view->strides[0]);
376 for (i=0; i<view->ndim; i++) {
377 dim = view->shape[i];
378 if (dim == 0) return 1;
379 if (view->strides[i] != sd) return 0;
380 sd *= dim;
381 }
382 return 1;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000383}
384
385static int
Stefan Krah9a2d99e2012-02-25 12:24:21 +0100386_IsCContiguous(const Py_buffer *view)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000387{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000388 Py_ssize_t sd, dim;
389 int i;
Guido van Rossum98297ee2007-11-06 21:34:58 +0000390
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000391 if (view->ndim == 0) return 1;
392 if (view->strides == NULL) return 1;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000393
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000394 sd = view->itemsize;
395 if (view->ndim == 1) return (view->shape[0] == 1 ||
396 sd == view->strides[0]);
397 for (i=view->ndim-1; i>=0; i--) {
398 dim = view->shape[i];
399 if (dim == 0) return 1;
400 if (view->strides[i] != sd) return 0;
401 sd *= dim;
402 }
403 return 1;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000404}
405
406int
Stefan Krah9a2d99e2012-02-25 12:24:21 +0100407PyBuffer_IsContiguous(const Py_buffer *view, char order)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000408{
409
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000410 if (view->suboffsets != NULL) return 0;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000411
Stefan Krah9a2d99e2012-02-25 12:24:21 +0100412 if (order == 'C')
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000413 return _IsCContiguous(view);
Stefan Krah9a2d99e2012-02-25 12:24:21 +0100414 else if (order == 'F')
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000415 return _IsFortranContiguous(view);
Stefan Krah9a2d99e2012-02-25 12:24:21 +0100416 else if (order == 'A')
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000417 return (_IsCContiguous(view) || _IsFortranContiguous(view));
418 return 0;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000419}
420
421
Guido van Rossum98297ee2007-11-06 21:34:58 +0000422void*
Travis E. Oliphant8ae62b62007-09-23 02:00:13 +0000423PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000424{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000425 char* pointer;
426 int i;
427 pointer = (char *)view->buf;
428 for (i = 0; i < view->ndim; i++) {
429 pointer += view->strides[i]*indices[i];
430 if ((view->suboffsets != NULL) && (view->suboffsets[i] >= 0)) {
431 pointer = *((char**)pointer) + view->suboffsets[i];
432 }
433 }
434 return (void*)pointer;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000435}
436
437
Guido van Rossum98297ee2007-11-06 21:34:58 +0000438void
Antoine Pitrouf68c2a72010-09-01 12:58:21 +0000439_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 +0000440{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000441 int k;
Guido van Rossum98297ee2007-11-06 21:34:58 +0000442
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000443 for (k=0; k<nd; k++) {
444 if (index[k] < shape[k]-1) {
445 index[k]++;
446 break;
447 }
448 else {
449 index[k] = 0;
450 }
451 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000452}
453
Guido van Rossum98297ee2007-11-06 21:34:58 +0000454void
Antoine Pitrouf68c2a72010-09-01 12:58:21 +0000455_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 +0000456{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000457 int k;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000458
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000459 for (k=nd-1; k>=0; k--) {
460 if (index[k] < shape[k]-1) {
461 index[k]++;
462 break;
463 }
464 else {
465 index[k] = 0;
466 }
467 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000468}
469
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000470int
Travis E. Oliphant8ae62b62007-09-23 02:00:13 +0000471PyBuffer_FromContiguous(Py_buffer *view, void *buf, Py_ssize_t len, char fort)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000472{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000473 int k;
Antoine Pitrouf68c2a72010-09-01 12:58:21 +0000474 void (*addone)(int, Py_ssize_t *, const Py_ssize_t *);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000475 Py_ssize_t *indices, elements;
476 char *src, *ptr;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000477
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000478 if (len > view->len) {
479 len = view->len;
480 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000481
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000482 if (PyBuffer_IsContiguous(view, fort)) {
483 /* simplest copy is all that is needed */
484 memcpy(view->buf, buf, len);
485 return 0;
486 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000487
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000488 /* Otherwise a more elaborate scheme is needed */
Guido van Rossum98297ee2007-11-06 21:34:58 +0000489
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000490 /* XXX(nnorwitz): need to check for overflow! */
491 indices = (Py_ssize_t *)PyMem_Malloc(sizeof(Py_ssize_t)*(view->ndim));
492 if (indices == NULL) {
493 PyErr_NoMemory();
494 return -1;
495 }
496 for (k=0; k<view->ndim;k++) {
497 indices[k] = 0;
498 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000499
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000500 if (fort == 'F') {
Antoine Pitrouf68c2a72010-09-01 12:58:21 +0000501 addone = _Py_add_one_to_index_F;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000502 }
503 else {
Antoine Pitrouf68c2a72010-09-01 12:58:21 +0000504 addone = _Py_add_one_to_index_C;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000505 }
506 src = buf;
507 /* XXX : This is not going to be the fastest code in the world
508 several optimizations are possible.
509 */
510 elements = len / view->itemsize;
511 while (elements--) {
512 addone(view->ndim, indices, view->shape);
513 ptr = PyBuffer_GetPointer(view, indices);
514 memcpy(ptr, src, view->itemsize);
515 src += view->itemsize;
516 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000517
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000518 PyMem_Free(indices);
519 return 0;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000520}
521
Guido van Rossum98297ee2007-11-06 21:34:58 +0000522int PyObject_CopyData(PyObject *dest, PyObject *src)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000523{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000524 Py_buffer view_dest, view_src;
525 int k;
526 Py_ssize_t *indices, elements;
527 char *dptr, *sptr;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000528
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000529 if (!PyObject_CheckBuffer(dest) ||
530 !PyObject_CheckBuffer(src)) {
531 PyErr_SetString(PyExc_TypeError,
R David Murray861470c2014-10-05 11:47:01 -0400532 "both destination and source must be "\
533 "bytes-like objects");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000534 return -1;
535 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000536
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000537 if (PyObject_GetBuffer(dest, &view_dest, PyBUF_FULL) != 0) return -1;
538 if (PyObject_GetBuffer(src, &view_src, PyBUF_FULL_RO) != 0) {
539 PyBuffer_Release(&view_dest);
540 return -1;
541 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000542
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000543 if (view_dest.len < view_src.len) {
544 PyErr_SetString(PyExc_BufferError,
545 "destination is too small to receive data from source");
546 PyBuffer_Release(&view_dest);
547 PyBuffer_Release(&view_src);
548 return -1;
549 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000550
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000551 if ((PyBuffer_IsContiguous(&view_dest, 'C') &&
552 PyBuffer_IsContiguous(&view_src, 'C')) ||
553 (PyBuffer_IsContiguous(&view_dest, 'F') &&
554 PyBuffer_IsContiguous(&view_src, 'F'))) {
555 /* simplest copy is all that is needed */
556 memcpy(view_dest.buf, view_src.buf, view_src.len);
557 PyBuffer_Release(&view_dest);
558 PyBuffer_Release(&view_src);
559 return 0;
560 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000561
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000562 /* Otherwise a more elaborate copy scheme is needed */
Guido van Rossum98297ee2007-11-06 21:34:58 +0000563
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000564 /* XXX(nnorwitz): need to check for overflow! */
565 indices = (Py_ssize_t *)PyMem_Malloc(sizeof(Py_ssize_t)*view_src.ndim);
566 if (indices == NULL) {
567 PyErr_NoMemory();
568 PyBuffer_Release(&view_dest);
569 PyBuffer_Release(&view_src);
570 return -1;
571 }
572 for (k=0; k<view_src.ndim;k++) {
573 indices[k] = 0;
574 }
575 elements = 1;
576 for (k=0; k<view_src.ndim; k++) {
577 /* XXX(nnorwitz): can this overflow? */
578 elements *= view_src.shape[k];
579 }
580 while (elements--) {
Antoine Pitrouf68c2a72010-09-01 12:58:21 +0000581 _Py_add_one_to_index_C(view_src.ndim, indices, view_src.shape);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000582 dptr = PyBuffer_GetPointer(&view_dest, indices);
583 sptr = PyBuffer_GetPointer(&view_src, indices);
584 memcpy(dptr, sptr, view_src.itemsize);
585 }
586 PyMem_Free(indices);
587 PyBuffer_Release(&view_dest);
588 PyBuffer_Release(&view_src);
589 return 0;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000590}
591
592void
593PyBuffer_FillContiguousStrides(int nd, Py_ssize_t *shape,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000594 Py_ssize_t *strides, int itemsize,
595 char fort)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000596{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000597 int k;
598 Py_ssize_t sd;
Guido van Rossum98297ee2007-11-06 21:34:58 +0000599
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000600 sd = itemsize;
601 if (fort == 'F') {
602 for (k=0; k<nd; k++) {
603 strides[k] = sd;
604 sd *= shape[k];
605 }
606 }
607 else {
608 for (k=nd-1; k>=0; k--) {
609 strides[k] = sd;
610 sd *= shape[k];
611 }
612 }
613 return;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000614}
615
616int
Martin v. Löwis423be952008-08-13 15:53:07 +0000617PyBuffer_FillInfo(Py_buffer *view, PyObject *obj, void *buf, Py_ssize_t len,
Stefan Krah4e141742012-03-06 15:27:31 +0100618 int readonly, int flags)
Guido van Rossum98297ee2007-11-06 21:34:58 +0000619{
Stefan Krah9a2d99e2012-02-25 12:24:21 +0100620 if (view == NULL) return 0; /* XXX why not -1? */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000621 if (((flags & PyBUF_WRITABLE) == PyBUF_WRITABLE) &&
622 (readonly == 1)) {
623 PyErr_SetString(PyExc_BufferError,
624 "Object is not writable.");
625 return -1;
626 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000627
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000628 view->obj = obj;
629 if (obj)
630 Py_INCREF(obj);
631 view->buf = buf;
632 view->len = len;
633 view->readonly = readonly;
634 view->itemsize = 1;
635 view->format = NULL;
636 if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT)
637 view->format = "B";
638 view->ndim = 1;
639 view->shape = NULL;
640 if ((flags & PyBUF_ND) == PyBUF_ND)
641 view->shape = &(view->len);
642 view->strides = NULL;
643 if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES)
644 view->strides = &(view->itemsize);
645 view->suboffsets = NULL;
646 view->internal = NULL;
647 return 0;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000648}
649
Martin v. Löwis423be952008-08-13 15:53:07 +0000650void
651PyBuffer_Release(Py_buffer *view)
652{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000653 PyObject *obj = view->obj;
654 if (obj && Py_TYPE(obj)->tp_as_buffer && Py_TYPE(obj)->tp_as_buffer->bf_releasebuffer)
655 Py_TYPE(obj)->tp_as_buffer->bf_releasebuffer(obj, view);
656 Py_XDECREF(obj);
657 view->obj = NULL;
Martin v. Löwis423be952008-08-13 15:53:07 +0000658}
659
Eric Smith8fd3eba2008-02-17 19:48:00 +0000660PyObject *
661PyObject_Format(PyObject *obj, PyObject *format_spec)
662{
Eric Smith8fd3eba2008-02-17 19:48:00 +0000663 PyObject *meth;
664 PyObject *empty = NULL;
665 PyObject *result = NULL;
Benjamin Petersonce798522012-01-22 11:24:29 -0500666 _Py_IDENTIFIER(__format__);
Eric Smith8fd3eba2008-02-17 19:48:00 +0000667
668 /* If no format_spec is provided, use an empty string */
669 if (format_spec == NULL) {
Victor Stinner9d3b93b2011-11-22 02:27:30 +0100670 empty = PyUnicode_New(0, 0);
Benjamin Petersonda2cf042010-06-05 00:45:37 +0000671 format_spec = empty;
Eric Smith8fd3eba2008-02-17 19:48:00 +0000672 }
673
Eric Smith8fd3eba2008-02-17 19:48:00 +0000674 /* Find the (unbound!) __format__ method (a borrowed reference) */
Benjamin Petersonce798522012-01-22 11:24:29 -0500675 meth = _PyObject_LookupSpecial(obj, &PyId___format__);
Eric Smith8fd3eba2008-02-17 19:48:00 +0000676 if (meth == NULL) {
Benjamin Petersonda2cf042010-06-05 00:45:37 +0000677 if (!PyErr_Occurred())
678 PyErr_Format(PyExc_TypeError,
679 "Type %.100s doesn't define __format__",
680 Py_TYPE(obj)->tp_name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000681 goto done;
Eric Smith8fd3eba2008-02-17 19:48:00 +0000682 }
683
Benjamin Petersonda2cf042010-06-05 00:45:37 +0000684 /* And call it. */
685 result = PyObject_CallFunctionObjArgs(meth, format_spec, NULL);
Benjamin Peterson6f889ad32010-06-05 02:11:45 +0000686 Py_DECREF(meth);
Eric Smith8fd3eba2008-02-17 19:48:00 +0000687
688 if (result && !PyUnicode_Check(result)) {
Benjamin Petersonda2cf042010-06-05 00:45:37 +0000689 PyErr_SetString(PyExc_TypeError,
690 "__format__ method did not return string");
691 Py_DECREF(result);
692 result = NULL;
693 goto done;
Eric Smith8fd3eba2008-02-17 19:48:00 +0000694 }
695
696done:
697 Py_XDECREF(empty);
698 return result;
699}
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000700/* Operations on numbers */
701
702int
Fred Drake79912472000-07-09 04:06:11 +0000703PyNumber_Check(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +0000704{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000705 return o && o->ob_type->tp_as_number &&
706 (o->ob_type->tp_as_number->nb_int ||
707 o->ob_type->tp_as_number->nb_float);
Guido van Rossume15dee51995-07-18 14:12:02 +0000708}
709
Guido van Rossumcea1c8c1998-05-22 00:47:05 +0000710/* Binary operators */
Guido van Rossume15dee51995-07-18 14:12:02 +0000711
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000712#define NB_SLOT(x) offsetof(PyNumberMethods, x)
713#define NB_BINOP(nb_methods, slot) \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000714 (*(binaryfunc*)(& ((char*)nb_methods)[slot]))
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000715#define NB_TERNOP(nb_methods, slot) \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000716 (*(ternaryfunc*)(& ((char*)nb_methods)[slot]))
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000717
718/*
719 Calling scheme used for binary operations:
720
Neal Norwitz4886cc32006-08-21 17:06:07 +0000721 Order operations are tried until either a valid result or error:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000722 w.op(v,w)[*], v.op(v,w), w.op(v,w)
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000723
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000724 [*] only when v->ob_type != w->ob_type && w->ob_type is a subclass of
725 v->ob_type
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000726 */
727
728static PyObject *
729binary_op1(PyObject *v, PyObject *w, const int op_slot)
Guido van Rossume15dee51995-07-18 14:12:02 +0000730{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000731 PyObject *x;
732 binaryfunc slotv = NULL;
733 binaryfunc slotw = NULL;
Guido van Rossum4bb1e362001-09-28 23:49:48 +0000734
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000735 if (v->ob_type->tp_as_number != NULL)
736 slotv = NB_BINOP(v->ob_type->tp_as_number, op_slot);
737 if (w->ob_type != v->ob_type &&
738 w->ob_type->tp_as_number != NULL) {
739 slotw = NB_BINOP(w->ob_type->tp_as_number, op_slot);
740 if (slotw == slotv)
741 slotw = NULL;
742 }
743 if (slotv) {
744 if (slotw && PyType_IsSubtype(w->ob_type, v->ob_type)) {
745 x = slotw(v, w);
746 if (x != Py_NotImplemented)
747 return x;
748 Py_DECREF(x); /* can't do it */
749 slotw = NULL;
750 }
751 x = slotv(v, w);
752 if (x != Py_NotImplemented)
753 return x;
754 Py_DECREF(x); /* can't do it */
755 }
756 if (slotw) {
757 x = slotw(v, w);
758 if (x != Py_NotImplemented)
759 return x;
760 Py_DECREF(x); /* can't do it */
761 }
Brian Curtindfc80e32011-08-10 20:28:54 -0500762 Py_RETURN_NOTIMPLEMENTED;
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000763}
Guido van Rossum77660912002-04-16 16:32:50 +0000764
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000765static PyObject *
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000766binop_type_error(PyObject *v, PyObject *w, const char *op_name)
767{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000768 PyErr_Format(PyExc_TypeError,
769 "unsupported operand type(s) for %.100s: "
770 "'%.100s' and '%.100s'",
771 op_name,
772 v->ob_type->tp_name,
773 w->ob_type->tp_name);
774 return NULL;
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000775}
776
777static PyObject *
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000778binary_op(PyObject *v, PyObject *w, const int op_slot, const char *op_name)
779{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000780 PyObject *result = binary_op1(v, w, op_slot);
781 if (result == Py_NotImplemented) {
782 Py_DECREF(result);
783 return binop_type_error(v, w, op_name);
784 }
785 return result;
Guido van Rossume15dee51995-07-18 14:12:02 +0000786}
787
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000788
789/*
790 Calling scheme used for ternary operations:
791
Neal Norwitz4886cc32006-08-21 17:06:07 +0000792 Order operations are tried until either a valid result or error:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000793 v.op(v,w,z), w.op(v,w,z), z.op(v,w,z)
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000794 */
795
796static PyObject *
797ternary_op(PyObject *v,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000798 PyObject *w,
799 PyObject *z,
800 const int op_slot,
801 const char *op_name)
Guido van Rossume15dee51995-07-18 14:12:02 +0000802{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000803 PyNumberMethods *mv, *mw, *mz;
804 PyObject *x = NULL;
805 ternaryfunc slotv = NULL;
806 ternaryfunc slotw = NULL;
807 ternaryfunc slotz = NULL;
Guido van Rossum77660912002-04-16 16:32:50 +0000808
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000809 mv = v->ob_type->tp_as_number;
810 mw = w->ob_type->tp_as_number;
811 if (mv != NULL)
812 slotv = NB_TERNOP(mv, op_slot);
813 if (w->ob_type != v->ob_type &&
814 mw != NULL) {
815 slotw = NB_TERNOP(mw, op_slot);
816 if (slotw == slotv)
817 slotw = NULL;
818 }
819 if (slotv) {
820 if (slotw && PyType_IsSubtype(w->ob_type, v->ob_type)) {
821 x = slotw(v, w, z);
822 if (x != Py_NotImplemented)
823 return x;
824 Py_DECREF(x); /* can't do it */
825 slotw = NULL;
826 }
827 x = slotv(v, w, z);
828 if (x != Py_NotImplemented)
829 return x;
830 Py_DECREF(x); /* can't do it */
831 }
832 if (slotw) {
833 x = slotw(v, w, z);
834 if (x != Py_NotImplemented)
835 return x;
836 Py_DECREF(x); /* can't do it */
837 }
838 mz = z->ob_type->tp_as_number;
839 if (mz != NULL) {
840 slotz = NB_TERNOP(mz, op_slot);
841 if (slotz == slotv || slotz == slotw)
842 slotz = NULL;
843 if (slotz) {
844 x = slotz(v, w, z);
845 if (x != Py_NotImplemented)
846 return x;
847 Py_DECREF(x); /* can't do it */
848 }
849 }
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000850
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000851 if (z == Py_None)
852 PyErr_Format(
853 PyExc_TypeError,
854 "unsupported operand type(s) for ** or pow(): "
855 "'%.100s' and '%.100s'",
856 v->ob_type->tp_name,
857 w->ob_type->tp_name);
858 else
859 PyErr_Format(
860 PyExc_TypeError,
861 "unsupported operand type(s) for pow(): "
862 "'%.100s', '%.100s', '%.100s'",
863 v->ob_type->tp_name,
864 w->ob_type->tp_name,
865 z->ob_type->tp_name);
866 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +0000867}
868
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000869#define BINARY_FUNC(func, op, op_name) \
870 PyObject * \
871 func(PyObject *v, PyObject *w) { \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000872 return binary_op(v, w, NB_SLOT(op), op_name); \
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000873 }
Guido van Rossume15dee51995-07-18 14:12:02 +0000874
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000875BINARY_FUNC(PyNumber_Or, nb_or, "|")
876BINARY_FUNC(PyNumber_Xor, nb_xor, "^")
877BINARY_FUNC(PyNumber_And, nb_and, "&")
878BINARY_FUNC(PyNumber_Lshift, nb_lshift, "<<")
879BINARY_FUNC(PyNumber_Rshift, nb_rshift, ">>")
880BINARY_FUNC(PyNumber_Subtract, nb_subtract, "-")
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000881BINARY_FUNC(PyNumber_Divmod, nb_divmod, "divmod()")
Guido van Rossume15dee51995-07-18 14:12:02 +0000882
883PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000884PyNumber_Add(PyObject *v, PyObject *w)
Guido van Rossume15dee51995-07-18 14:12:02 +0000885{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000886 PyObject *result = binary_op1(v, w, NB_SLOT(nb_add));
887 if (result == Py_NotImplemented) {
888 PySequenceMethods *m = v->ob_type->tp_as_sequence;
889 Py_DECREF(result);
890 if (m && m->sq_concat) {
891 return (*m->sq_concat)(v, w);
892 }
893 result = binop_type_error(v, w, "+");
894 }
895 return result;
Guido van Rossume15dee51995-07-18 14:12:02 +0000896}
897
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000898static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000899sequence_repeat(ssizeargfunc repeatfunc, PyObject *seq, PyObject *n)
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000900{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000901 Py_ssize_t count;
902 if (PyIndex_Check(n)) {
903 count = PyNumber_AsSsize_t(n, PyExc_OverflowError);
904 if (count == -1 && PyErr_Occurred())
905 return NULL;
906 }
907 else {
908 return type_error("can't multiply sequence by "
909 "non-int of type '%.200s'", n);
910 }
911 return (*repeatfunc)(seq, count);
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000912}
913
914PyObject *
915PyNumber_Multiply(PyObject *v, PyObject *w)
916{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000917 PyObject *result = binary_op1(v, w, NB_SLOT(nb_multiply));
918 if (result == Py_NotImplemented) {
919 PySequenceMethods *mv = v->ob_type->tp_as_sequence;
920 PySequenceMethods *mw = w->ob_type->tp_as_sequence;
921 Py_DECREF(result);
922 if (mv && mv->sq_repeat) {
923 return sequence_repeat(mv->sq_repeat, v, w);
924 }
925 else if (mw && mw->sq_repeat) {
926 return sequence_repeat(mw->sq_repeat, w, v);
927 }
928 result = binop_type_error(v, w, "*");
929 }
930 return result;
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000931}
932
Guido van Rossume15dee51995-07-18 14:12:02 +0000933PyObject *
Benjamin Petersond51374e2014-04-09 23:55:56 -0400934PyNumber_MatrixMultiply(PyObject *v, PyObject *w)
935{
936 return binary_op(v, w, NB_SLOT(nb_matrix_multiply), "@");
937}
938
939PyObject *
Guido van Rossum4668b002001-08-08 05:00:18 +0000940PyNumber_FloorDivide(PyObject *v, PyObject *w)
941{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000942 return binary_op(v, w, NB_SLOT(nb_floor_divide), "//");
Guido van Rossum4668b002001-08-08 05:00:18 +0000943}
944
945PyObject *
946PyNumber_TrueDivide(PyObject *v, PyObject *w)
947{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000948 return binary_op(v, w, NB_SLOT(nb_true_divide), "/");
Guido van Rossum4668b002001-08-08 05:00:18 +0000949}
950
951PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000952PyNumber_Remainder(PyObject *v, PyObject *w)
Guido van Rossume15dee51995-07-18 14:12:02 +0000953{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000954 return binary_op(v, w, NB_SLOT(nb_remainder), "%");
Guido van Rossume15dee51995-07-18 14:12:02 +0000955}
956
957PyObject *
Fred Drake79912472000-07-09 04:06:11 +0000958PyNumber_Power(PyObject *v, PyObject *w, PyObject *z)
Guido van Rossume15dee51995-07-18 14:12:02 +0000959{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000960 return ternary_op(v, w, z, NB_SLOT(nb_power), "** or pow()");
Guido van Rossume15dee51995-07-18 14:12:02 +0000961}
962
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000963/* Binary in-place operators */
964
965/* The in-place operators are defined to fall back to the 'normal',
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000966 non in-place operations, if the in-place methods are not in place.
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000967
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000968 - If the left hand object has the appropriate struct members, and
969 they are filled, call the appropriate function and return the
970 result. No coercion is done on the arguments; the left-hand object
971 is the one the operation is performed on, and it's up to the
972 function to deal with the right-hand object.
Guido van Rossum77660912002-04-16 16:32:50 +0000973
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000974 - Otherwise, in-place modification is not supported. Handle it exactly as
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000975 a non in-place operation of the same kind.
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000976
977 */
978
Neil Schemenauer5a1f0152001-01-04 01:39:06 +0000979static PyObject *
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000980binary_iop1(PyObject *v, PyObject *w, const int iop_slot, const int op_slot)
Thomas Wouterse289e0b2000-08-24 20:08:19 +0000981{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000982 PyNumberMethods *mv = v->ob_type->tp_as_number;
983 if (mv != NULL) {
984 binaryfunc slot = NB_BINOP(mv, iop_slot);
985 if (slot) {
986 PyObject *x = (slot)(v, w);
987 if (x != Py_NotImplemented) {
988 return x;
989 }
990 Py_DECREF(x);
991 }
992 }
993 return binary_op1(v, w, op_slot);
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000994}
995
996static PyObject *
997binary_iop(PyObject *v, PyObject *w, const int iop_slot, const int op_slot,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000998 const char *op_name)
Neil Schemenauerd4b0fea2002-12-30 20:18:15 +0000999{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001000 PyObject *result = binary_iop1(v, w, iop_slot, op_slot);
1001 if (result == Py_NotImplemented) {
1002 Py_DECREF(result);
1003 return binop_type_error(v, w, op_name);
1004 }
1005 return result;
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001006}
1007
Neil Schemenauer5a1f0152001-01-04 01:39:06 +00001008#define INPLACE_BINOP(func, iop, op, op_name) \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001009 PyObject * \
1010 func(PyObject *v, PyObject *w) { \
1011 return binary_iop(v, w, NB_SLOT(iop), NB_SLOT(op), op_name); \
1012 }
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001013
Neil Schemenauer5a1f0152001-01-04 01:39:06 +00001014INPLACE_BINOP(PyNumber_InPlaceOr, nb_inplace_or, nb_or, "|=")
1015INPLACE_BINOP(PyNumber_InPlaceXor, nb_inplace_xor, nb_xor, "^=")
1016INPLACE_BINOP(PyNumber_InPlaceAnd, nb_inplace_and, nb_and, "&=")
1017INPLACE_BINOP(PyNumber_InPlaceLshift, nb_inplace_lshift, nb_lshift, "<<=")
1018INPLACE_BINOP(PyNumber_InPlaceRshift, nb_inplace_rshift, nb_rshift, ">>=")
1019INPLACE_BINOP(PyNumber_InPlaceSubtract, nb_inplace_subtract, nb_subtract, "-=")
Benjamin Petersond51374e2014-04-09 23:55:56 -04001020INPLACE_BINOP(PyNumber_InMatrixMultiply, nb_inplace_matrix_multiply, nb_matrix_multiply, "@=")
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001021
1022PyObject *
Guido van Rossum4668b002001-08-08 05:00:18 +00001023PyNumber_InPlaceFloorDivide(PyObject *v, PyObject *w)
1024{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001025 return binary_iop(v, w, NB_SLOT(nb_inplace_floor_divide),
1026 NB_SLOT(nb_floor_divide), "//=");
Guido van Rossum4668b002001-08-08 05:00:18 +00001027}
1028
1029PyObject *
1030PyNumber_InPlaceTrueDivide(PyObject *v, PyObject *w)
1031{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001032 return binary_iop(v, w, NB_SLOT(nb_inplace_true_divide),
1033 NB_SLOT(nb_true_divide), "/=");
Guido van Rossum4668b002001-08-08 05:00:18 +00001034}
1035
1036PyObject *
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001037PyNumber_InPlaceAdd(PyObject *v, PyObject *w)
1038{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001039 PyObject *result = binary_iop1(v, w, NB_SLOT(nb_inplace_add),
1040 NB_SLOT(nb_add));
1041 if (result == Py_NotImplemented) {
1042 PySequenceMethods *m = v->ob_type->tp_as_sequence;
1043 Py_DECREF(result);
1044 if (m != NULL) {
1045 binaryfunc f = NULL;
1046 f = m->sq_inplace_concat;
1047 if (f == NULL)
1048 f = m->sq_concat;
1049 if (f != NULL)
1050 return (*f)(v, w);
1051 }
1052 result = binop_type_error(v, w, "+=");
1053 }
1054 return result;
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001055}
1056
1057PyObject *
1058PyNumber_InPlaceMultiply(PyObject *v, PyObject *w)
1059{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001060 PyObject *result = binary_iop1(v, w, NB_SLOT(nb_inplace_multiply),
1061 NB_SLOT(nb_multiply));
1062 if (result == Py_NotImplemented) {
1063 ssizeargfunc f = NULL;
1064 PySequenceMethods *mv = v->ob_type->tp_as_sequence;
1065 PySequenceMethods *mw = w->ob_type->tp_as_sequence;
1066 Py_DECREF(result);
1067 if (mv != NULL) {
1068 f = mv->sq_inplace_repeat;
1069 if (f == NULL)
1070 f = mv->sq_repeat;
1071 if (f != NULL)
1072 return sequence_repeat(f, v, w);
1073 }
1074 else if (mw != NULL) {
1075 /* Note that the right hand operand should not be
1076 * mutated in this case so sq_inplace_repeat is not
1077 * used. */
1078 if (mw->sq_repeat)
1079 return sequence_repeat(mw->sq_repeat, w, v);
1080 }
1081 result = binop_type_error(v, w, "*=");
1082 }
1083 return result;
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001084}
1085
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001086PyObject *
Benjamin Petersond51374e2014-04-09 23:55:56 -04001087PyNumber_InPlaceMatrixMultiply(PyObject *v, PyObject *w)
1088{
1089 return binary_iop(v, w, NB_SLOT(nb_inplace_matrix_multiply),
1090 NB_SLOT(nb_matrix_multiply), "@=");
1091}
1092
1093PyObject *
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001094PyNumber_InPlaceRemainder(PyObject *v, PyObject *w)
1095{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001096 return binary_iop(v, w, NB_SLOT(nb_inplace_remainder),
1097 NB_SLOT(nb_remainder), "%=");
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001098}
1099
1100PyObject *
1101PyNumber_InPlacePower(PyObject *v, PyObject *w, PyObject *z)
1102{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001103 if (v->ob_type->tp_as_number &&
1104 v->ob_type->tp_as_number->nb_inplace_power != NULL) {
1105 return ternary_op(v, w, z, NB_SLOT(nb_inplace_power), "**=");
1106 }
1107 else {
1108 return ternary_op(v, w, z, NB_SLOT(nb_power), "**=");
1109 }
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001110}
1111
1112
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001113/* Unary operators and functions */
Guido van Rossume15dee51995-07-18 14:12:02 +00001114
1115PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001116PyNumber_Negative(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001117{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001118 PyNumberMethods *m;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001119
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001120 if (o == NULL)
1121 return null_error();
1122 m = o->ob_type->tp_as_number;
1123 if (m && m->nb_negative)
1124 return (*m->nb_negative)(o);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001125
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001126 return type_error("bad operand type for unary -: '%.200s'", o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001127}
1128
1129PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001130PyNumber_Positive(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001131{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001132 PyNumberMethods *m;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001133
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001134 if (o == NULL)
1135 return null_error();
1136 m = o->ob_type->tp_as_number;
1137 if (m && m->nb_positive)
1138 return (*m->nb_positive)(o);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001139
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001140 return type_error("bad operand type for unary +: '%.200s'", o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001141}
1142
1143PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001144PyNumber_Invert(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001145{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001146 PyNumberMethods *m;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001147
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001148 if (o == NULL)
1149 return null_error();
1150 m = o->ob_type->tp_as_number;
1151 if (m && m->nb_invert)
1152 return (*m->nb_invert)(o);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001153
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001154 return type_error("bad operand type for unary ~: '%.200s'", o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001155}
1156
1157PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001158PyNumber_Absolute(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001159{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001160 PyNumberMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001161
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001162 if (o == NULL)
1163 return null_error();
1164 m = o->ob_type->tp_as_number;
1165 if (m && m->nb_absolute)
1166 return m->nb_absolute(o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001167
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001168 return type_error("bad operand type for abs(): '%.200s'", o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001169}
1170
Serhiy Storchaka31a65542013-12-11 21:07:54 +02001171/* Return a Python int from the object item.
Serhiy Storchaka95949422013-08-27 19:40:23 +03001172 Raise TypeError if the result is not an int
Guido van Rossum98297ee2007-11-06 21:34:58 +00001173 or if the object cannot be interpreted as an index.
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00001174*/
1175PyObject *
Guido van Rossum38fff8c2006-03-07 18:50:55 +00001176PyNumber_Index(PyObject *item)
1177{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001178 PyObject *result = NULL;
1179 if (item == NULL)
1180 return null_error();
1181 if (PyLong_Check(item)) {
1182 Py_INCREF(item);
1183 return item;
1184 }
Serhiy Storchaka31a65542013-12-11 21:07:54 +02001185 if (!PyIndex_Check(item)) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001186 PyErr_Format(PyExc_TypeError,
1187 "'%.200s' object cannot be interpreted "
1188 "as an integer", item->ob_type->tp_name);
Serhiy Storchaka31a65542013-12-11 21:07:54 +02001189 return NULL;
1190 }
1191 result = item->ob_type->tp_as_number->nb_index(item);
1192 if (!result || PyLong_CheckExact(result))
1193 return result;
1194 if (!PyLong_Check(result)) {
1195 PyErr_Format(PyExc_TypeError,
1196 "__index__ returned non-int (type %.200s)",
1197 result->ob_type->tp_name);
1198 Py_DECREF(result);
1199 return NULL;
1200 }
1201 /* Issue #17576: warn if 'result' not of exact type int. */
1202 if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
1203 "__index__ returned non-int (type %.200s). "
1204 "The ability to return an instance of a strict subclass of int "
1205 "is deprecated, and may be removed in a future version of Python.",
1206 result->ob_type->tp_name)) {
1207 Py_DECREF(result);
1208 return NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001209 }
1210 return result;
Guido van Rossum38fff8c2006-03-07 18:50:55 +00001211}
1212
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00001213/* Return an error on Overflow only if err is not NULL*/
1214
1215Py_ssize_t
1216PyNumber_AsSsize_t(PyObject *item, PyObject *err)
1217{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001218 Py_ssize_t result;
1219 PyObject *runerr;
1220 PyObject *value = PyNumber_Index(item);
1221 if (value == NULL)
1222 return -1;
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00001223
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001224 /* We're done if PyLong_AsSsize_t() returns without error. */
1225 result = PyLong_AsSsize_t(value);
1226 if (result != -1 || !(runerr = PyErr_Occurred()))
1227 goto finish;
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00001228
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001229 /* Error handling code -- only manage OverflowError differently */
1230 if (!PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError))
1231 goto finish;
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00001232
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001233 PyErr_Clear();
1234 /* If no error-handling desired then the default clipping
1235 is sufficient.
1236 */
1237 if (!err) {
1238 assert(PyLong_Check(value));
1239 /* Whether or not it is less than or equal to
1240 zero is determined by the sign of ob_size
1241 */
1242 if (_PyLong_Sign(value) < 0)
1243 result = PY_SSIZE_T_MIN;
1244 else
1245 result = PY_SSIZE_T_MAX;
1246 }
1247 else {
1248 /* Otherwise replace the error with caller's error object. */
1249 PyErr_Format(err,
1250 "cannot fit '%.200s' into an index-sized integer",
1251 item->ob_type->tp_name);
1252 }
Guido van Rossum98297ee2007-11-06 21:34:58 +00001253
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00001254 finish:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001255 Py_DECREF(value);
1256 return result;
Thomas Wouters00ee7ba2006-08-21 19:07:27 +00001257}
1258
1259
Guido van Rossume15dee51995-07-18 14:12:02 +00001260PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001261PyNumber_Long(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001262{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001263 PyNumberMethods *m;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001264 PyObject *trunc_func;
1265 const char *buffer;
1266 Py_ssize_t buffer_len;
Benjamin Peterson9fc9bf42012-03-20 23:26:41 -04001267 _Py_IDENTIFIER(__trunc__);
Christian Heimes15ebc882008-02-04 18:48:49 +00001268
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001269 if (o == NULL)
1270 return null_error();
1271 if (PyLong_CheckExact(o)) {
1272 Py_INCREF(o);
1273 return o;
1274 }
1275 m = o->ob_type->tp_as_number;
1276 if (m && m->nb_int) { /* This should include subclasses of int */
Serhiy Storchaka31a65542013-12-11 21:07:54 +02001277 return (PyObject *)_PyLong_FromNbInt(o);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001278 }
Benjamin Peterson1b1a8e72012-03-20 23:48:11 -04001279 trunc_func = _PyObject_LookupSpecial(o, &PyId___trunc__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001280 if (trunc_func) {
1281 PyObject *truncated = PyEval_CallObject(trunc_func, NULL);
1282 PyObject *int_instance;
1283 Py_DECREF(trunc_func);
Serhiy Storchaka31a65542013-12-11 21:07:54 +02001284 if (truncated == NULL || PyLong_Check(truncated))
1285 return truncated;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001286 /* __trunc__ is specified to return an Integral type,
Benjamin Peterson520e8502012-03-21 14:51:14 -04001287 but int() needs to return a int. */
Serhiy Storchaka31a65542013-12-11 21:07:54 +02001288 m = truncated->ob_type->tp_as_number;
1289 if (m == NULL || m->nb_int == NULL) {
1290 PyErr_Format(
1291 PyExc_TypeError,
1292 "__trunc__ returned non-Integral (type %.200s)",
1293 truncated->ob_type->tp_name);
1294 Py_DECREF(truncated);
1295 return NULL;
1296 }
1297 int_instance = (PyObject *)_PyLong_FromNbInt(truncated);
1298 Py_DECREF(truncated);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001299 return int_instance;
1300 }
Benjamin Peterson1b1a8e72012-03-20 23:48:11 -04001301 if (PyErr_Occurred())
1302 return NULL;
Christian Heimes15ebc882008-02-04 18:48:49 +00001303
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001304 if (PyBytes_Check(o))
1305 /* need to do extra error checking that PyLong_FromString()
Serhiy Storchakaf6d0aee2013-08-03 20:55:06 +03001306 * doesn't do. In particular int('9\x005') must raise an
1307 * exception, not truncate at the null.
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001308 */
Serhiy Storchakaf6d0aee2013-08-03 20:55:06 +03001309 return _PyLong_FromBytes(PyBytes_AS_STRING(o),
1310 PyBytes_GET_SIZE(o), 10);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001311 if (PyUnicode_Check(o))
1312 /* The above check is done in PyLong_FromUnicode(). */
Martin v. Löwisd63a3b82011-09-28 07:41:54 +02001313 return PyLong_FromUnicodeObject(o, 10);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001314 if (!PyObject_AsCharBuffer(o, &buffer, &buffer_len))
Serhiy Storchakaf6d0aee2013-08-03 20:55:06 +03001315 return _PyLong_FromBytes(buffer, buffer_len, 10);
Guido van Rossume15dee51995-07-18 14:12:02 +00001316
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001317 return type_error("int() argument must be a string or a "
1318 "number, not '%.200s'", o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001319}
1320
1321PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001322PyNumber_Float(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001323{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001324 PyNumberMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001325
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001326 if (o == NULL)
1327 return null_error();
1328 m = o->ob_type->tp_as_number;
1329 if (m && m->nb_float) { /* This should include subclasses of float */
1330 PyObject *res = m->nb_float(o);
1331 if (res && !PyFloat_Check(res)) {
1332 PyErr_Format(PyExc_TypeError,
1333 "__float__ returned non-float (type %.200s)",
1334 res->ob_type->tp_name);
1335 Py_DECREF(res);
1336 return NULL;
1337 }
1338 return res;
1339 }
1340 if (PyFloat_Check(o)) { /* A float subclass with nb_float == NULL */
1341 PyFloatObject *po = (PyFloatObject *)o;
1342 return PyFloat_FromDouble(po->ob_fval);
1343 }
1344 return PyFloat_FromString(o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001345}
1346
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001347
1348PyObject *
1349PyNumber_ToBase(PyObject *n, int base)
1350{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001351 PyObject *res = NULL;
1352 PyObject *index = PyNumber_Index(n);
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001353
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001354 if (!index)
1355 return NULL;
1356 if (PyLong_Check(index))
1357 res = _PyLong_Format(index, base);
1358 else
1359 /* It should not be possible to get here, as
1360 PyNumber_Index already has a check for the same
1361 condition */
Serhiy Storchaka95949422013-08-27 19:40:23 +03001362 PyErr_SetString(PyExc_ValueError, "PyNumber_ToBase: index not int");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001363 Py_DECREF(index);
1364 return res;
Guido van Rossumcd16bf62007-06-13 18:07:49 +00001365}
1366
1367
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001368/* Operations on sequences */
Guido van Rossume15dee51995-07-18 14:12:02 +00001369
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001370int
Fred Drake79912472000-07-09 04:06:11 +00001371PySequence_Check(PyObject *s)
Guido van Rossume15dee51995-07-18 14:12:02 +00001372{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001373 if (PyDict_Check(s))
1374 return 0;
1375 return s != NULL && s->ob_type->tp_as_sequence &&
1376 s->ob_type->tp_as_sequence->sq_item != NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +00001377}
1378
Martin v. Löwis18e16552006-02-15 17:27:45 +00001379Py_ssize_t
Jeremy Hylton6253f832000-07-12 12:56:19 +00001380PySequence_Size(PyObject *s)
Guido van Rossume15dee51995-07-18 14:12:02 +00001381{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001382 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001383
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001384 if (s == NULL) {
1385 null_error();
1386 return -1;
1387 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001388
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001389 m = s->ob_type->tp_as_sequence;
1390 if (m && m->sq_length)
1391 return m->sq_length(s);
Guido van Rossume15dee51995-07-18 14:12:02 +00001392
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001393 type_error("object of type '%.200s' has no len()", s);
1394 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +00001395}
1396
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +00001397#undef PySequence_Length
Martin v. Löwis18e16552006-02-15 17:27:45 +00001398Py_ssize_t
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +00001399PySequence_Length(PyObject *s)
1400{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001401 return PySequence_Size(s);
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +00001402}
1403#define PySequence_Length PySequence_Size
1404
Guido van Rossume15dee51995-07-18 14:12:02 +00001405PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001406PySequence_Concat(PyObject *s, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001407{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001408 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001409
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001410 if (s == NULL || o == NULL)
1411 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001412
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001413 m = s->ob_type->tp_as_sequence;
1414 if (m && m->sq_concat)
1415 return m->sq_concat(s, o);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001416
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001417 /* Instances of user classes defining an __add__() method only
1418 have an nb_add slot, not an sq_concat slot. So we fall back
1419 to nb_add if both arguments appear to be sequences. */
1420 if (PySequence_Check(s) && PySequence_Check(o)) {
1421 PyObject *result = binary_op1(s, o, NB_SLOT(nb_add));
1422 if (result != Py_NotImplemented)
1423 return result;
1424 Py_DECREF(result);
1425 }
1426 return type_error("'%.200s' object can't be concatenated", s);
Guido van Rossume15dee51995-07-18 14:12:02 +00001427}
1428
1429PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +00001430PySequence_Repeat(PyObject *o, Py_ssize_t count)
Guido van Rossume15dee51995-07-18 14:12:02 +00001431{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001432 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001433
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001434 if (o == NULL)
1435 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001436
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001437 m = o->ob_type->tp_as_sequence;
1438 if (m && m->sq_repeat)
1439 return m->sq_repeat(o, count);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001440
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001441 /* Instances of user classes defining a __mul__() method only
1442 have an nb_multiply slot, not an sq_repeat slot. so we fall back
1443 to nb_multiply if o appears to be a sequence. */
1444 if (PySequence_Check(o)) {
1445 PyObject *n, *result;
1446 n = PyLong_FromSsize_t(count);
1447 if (n == NULL)
1448 return NULL;
1449 result = binary_op1(o, n, NB_SLOT(nb_multiply));
1450 Py_DECREF(n);
1451 if (result != Py_NotImplemented)
1452 return result;
1453 Py_DECREF(result);
1454 }
1455 return type_error("'%.200s' object can't be repeated", o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001456}
1457
1458PyObject *
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001459PySequence_InPlaceConcat(PyObject *s, PyObject *o)
1460{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001461 PySequenceMethods *m;
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001462
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001463 if (s == NULL || o == NULL)
1464 return null_error();
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001465
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001466 m = s->ob_type->tp_as_sequence;
1467 if (m && m->sq_inplace_concat)
1468 return m->sq_inplace_concat(s, o);
1469 if (m && m->sq_concat)
1470 return m->sq_concat(s, o);
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001471
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001472 if (PySequence_Check(s) && PySequence_Check(o)) {
1473 PyObject *result = binary_iop1(s, o, NB_SLOT(nb_inplace_add),
1474 NB_SLOT(nb_add));
1475 if (result != Py_NotImplemented)
1476 return result;
1477 Py_DECREF(result);
1478 }
1479 return type_error("'%.200s' object can't be concatenated", s);
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001480}
1481
1482PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +00001483PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count)
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001484{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001485 PySequenceMethods *m;
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001486
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001487 if (o == NULL)
1488 return null_error();
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001489
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001490 m = o->ob_type->tp_as_sequence;
1491 if (m && m->sq_inplace_repeat)
1492 return m->sq_inplace_repeat(o, count);
1493 if (m && m->sq_repeat)
1494 return m->sq_repeat(o, count);
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001495
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001496 if (PySequence_Check(o)) {
1497 PyObject *n, *result;
1498 n = PyLong_FromSsize_t(count);
1499 if (n == NULL)
1500 return NULL;
1501 result = binary_iop1(o, n, NB_SLOT(nb_inplace_multiply),
1502 NB_SLOT(nb_multiply));
1503 Py_DECREF(n);
1504 if (result != Py_NotImplemented)
1505 return result;
1506 Py_DECREF(result);
1507 }
1508 return type_error("'%.200s' object can't be repeated", o);
Thomas Wouterse289e0b2000-08-24 20:08:19 +00001509}
1510
1511PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +00001512PySequence_GetItem(PyObject *s, Py_ssize_t i)
Guido van Rossume15dee51995-07-18 14:12:02 +00001513{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001514 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001515
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001516 if (s == NULL)
1517 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001518
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001519 m = s->ob_type->tp_as_sequence;
1520 if (m && m->sq_item) {
1521 if (i < 0) {
1522 if (m->sq_length) {
1523 Py_ssize_t l = (*m->sq_length)(s);
1524 if (l < 0)
1525 return NULL;
1526 i += l;
1527 }
1528 }
1529 return m->sq_item(s, i);
1530 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001531
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001532 return type_error("'%.200s' object does not support indexing", s);
Guido van Rossume15dee51995-07-18 14:12:02 +00001533}
1534
1535PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +00001536PySequence_GetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2)
Guido van Rossume15dee51995-07-18 14:12:02 +00001537{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001538 PyMappingMethods *mp;
Guido van Rossume15dee51995-07-18 14:12:02 +00001539
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001540 if (!s) return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001541
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001542 mp = s->ob_type->tp_as_mapping;
Benjamin Peterson568867a2010-09-11 16:02:03 +00001543 if (mp && mp->mp_subscript) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001544 PyObject *res;
1545 PyObject *slice = _PySlice_FromIndices(i1, i2);
1546 if (!slice)
1547 return NULL;
1548 res = mp->mp_subscript(s, slice);
1549 Py_DECREF(slice);
1550 return res;
1551 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001552
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001553 return type_error("'%.200s' object is unsliceable", s);
Guido van Rossume15dee51995-07-18 14:12:02 +00001554}
1555
1556int
Martin v. Löwis18e16552006-02-15 17:27:45 +00001557PySequence_SetItem(PyObject *s, Py_ssize_t i, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001558{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001559 PySequenceMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001560
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001561 if (s == NULL) {
1562 null_error();
1563 return -1;
1564 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001565
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001566 m = s->ob_type->tp_as_sequence;
1567 if (m && m->sq_ass_item) {
1568 if (i < 0) {
1569 if (m->sq_length) {
1570 Py_ssize_t l = (*m->sq_length)(s);
1571 if (l < 0)
1572 return -1;
1573 i += l;
1574 }
1575 }
1576 return m->sq_ass_item(s, i, o);
1577 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001578
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001579 type_error("'%.200s' object does not support item assignment", s);
1580 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +00001581}
1582
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001583int
Martin v. Löwis18e16552006-02-15 17:27:45 +00001584PySequence_DelItem(PyObject *s, Py_ssize_t i)
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001585{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001586 PySequenceMethods *m;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001587
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001588 if (s == NULL) {
1589 null_error();
1590 return -1;
1591 }
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001592
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001593 m = s->ob_type->tp_as_sequence;
1594 if (m && m->sq_ass_item) {
1595 if (i < 0) {
1596 if (m->sq_length) {
1597 Py_ssize_t l = (*m->sq_length)(s);
1598 if (l < 0)
1599 return -1;
1600 i += l;
1601 }
1602 }
1603 return m->sq_ass_item(s, i, (PyObject *)NULL);
1604 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001605
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001606 type_error("'%.200s' object doesn't support item deletion", s);
1607 return -1;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001608}
1609
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001610int
Martin v. Löwis18e16552006-02-15 17:27:45 +00001611PySequence_SetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001612{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001613 PyMappingMethods *mp;
Guido van Rossume15dee51995-07-18 14:12:02 +00001614
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001615 if (s == NULL) {
1616 null_error();
1617 return -1;
1618 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001619
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001620 mp = s->ob_type->tp_as_mapping;
Benjamin Peterson568867a2010-09-11 16:02:03 +00001621 if (mp && mp->mp_ass_subscript) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001622 int res;
1623 PyObject *slice = _PySlice_FromIndices(i1, i2);
1624 if (!slice)
1625 return -1;
1626 res = mp->mp_ass_subscript(s, slice, o);
1627 Py_DECREF(slice);
1628 return res;
1629 }
Thomas Wouters1d75a792000-08-17 22:37:32 +00001630
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001631 type_error("'%.200s' object doesn't support slice assignment", s);
1632 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +00001633}
1634
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001635int
Martin v. Löwis18e16552006-02-15 17:27:45 +00001636PySequence_DelSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2)
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001637{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001638 PyMappingMethods *mp;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001639
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001640 if (s == NULL) {
1641 null_error();
1642 return -1;
1643 }
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001644
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001645 mp = s->ob_type->tp_as_mapping;
Benjamin Peterson568867a2010-09-11 16:02:03 +00001646 if (mp && mp->mp_ass_subscript) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001647 int res;
1648 PyObject *slice = _PySlice_FromIndices(i1, i2);
1649 if (!slice)
1650 return -1;
1651 res = mp->mp_ass_subscript(s, slice, NULL);
1652 Py_DECREF(slice);
1653 return res;
1654 }
1655 type_error("'%.200s' object doesn't support slice deletion", s);
1656 return -1;
Guido van Rossum6cdc6f41996-08-21 17:41:54 +00001657}
1658
Guido van Rossume15dee51995-07-18 14:12:02 +00001659PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001660PySequence_Tuple(PyObject *v)
Guido van Rossume15dee51995-07-18 14:12:02 +00001661{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001662 PyObject *it; /* iter(v) */
1663 Py_ssize_t n; /* guess for result tuple size */
1664 PyObject *result = NULL;
1665 Py_ssize_t j;
Guido van Rossume15dee51995-07-18 14:12:02 +00001666
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001667 if (v == NULL)
1668 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00001669
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001670 /* Special-case the common tuple and list cases, for efficiency. */
1671 if (PyTuple_CheckExact(v)) {
1672 /* Note that we can't know whether it's safe to return
1673 a tuple *subclass* instance as-is, hence the restriction
1674 to exact tuples here. In contrast, lists always make
1675 a copy, so there's no need for exactness below. */
1676 Py_INCREF(v);
1677 return v;
1678 }
1679 if (PyList_Check(v))
1680 return PyList_AsTuple(v);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001681
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001682 /* Get iterator. */
1683 it = PyObject_GetIter(v);
1684 if (it == NULL)
1685 return NULL;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001686
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001687 /* Guess result size and allocate space. */
Armin Ronacheraa9a79d2012-10-06 14:03:24 +02001688 n = PyObject_LengthHint(v, 10);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001689 if (n == -1)
1690 goto Fail;
1691 result = PyTuple_New(n);
1692 if (result == NULL)
1693 goto Fail;
Tim Peters6912d4d2001-05-05 03:56:37 +00001694
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001695 /* Fill the tuple. */
1696 for (j = 0; ; ++j) {
1697 PyObject *item = PyIter_Next(it);
1698 if (item == NULL) {
1699 if (PyErr_Occurred())
1700 goto Fail;
1701 break;
1702 }
1703 if (j >= n) {
1704 Py_ssize_t oldn = n;
1705 /* The over-allocation strategy can grow a bit faster
1706 than for lists because unlike lists the
1707 over-allocation isn't permanent -- we reclaim
1708 the excess before the end of this routine.
1709 So, grow by ten and then add 25%.
1710 */
1711 n += 10;
1712 n += n >> 2;
1713 if (n < oldn) {
1714 /* Check for overflow */
1715 PyErr_NoMemory();
1716 Py_DECREF(item);
1717 goto Fail;
1718 }
1719 if (_PyTuple_Resize(&result, n) != 0) {
1720 Py_DECREF(item);
1721 goto Fail;
1722 }
1723 }
1724 PyTuple_SET_ITEM(result, j, item);
1725 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001726
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001727 /* Cut tuple back if guess was too large. */
1728 if (j < n &&
1729 _PyTuple_Resize(&result, j) != 0)
1730 goto Fail;
Tim Peters6912d4d2001-05-05 03:56:37 +00001731
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001732 Py_DECREF(it);
1733 return result;
Tim Peters6912d4d2001-05-05 03:56:37 +00001734
1735Fail:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001736 Py_XDECREF(result);
1737 Py_DECREF(it);
1738 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +00001739}
1740
Guido van Rossum3c5936a1996-12-05 21:51:24 +00001741PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001742PySequence_List(PyObject *v)
Guido van Rossum3c5936a1996-12-05 21:51:24 +00001743{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001744 PyObject *result; /* result list */
1745 PyObject *rv; /* return value from PyList_Extend */
Guido van Rossum4669fb41997-04-02 05:31:09 +00001746
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001747 if (v == NULL)
1748 return null_error();
Guido van Rossum5dba9e81998-07-10 18:03:50 +00001749
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001750 result = PyList_New(0);
1751 if (result == NULL)
1752 return NULL;
Tim Petersf553f892001-05-01 20:45:31 +00001753
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001754 rv = _PyList_Extend((PyListObject *)result, v);
1755 if (rv == NULL) {
1756 Py_DECREF(result);
1757 return NULL;
1758 }
1759 Py_DECREF(rv);
1760 return result;
Guido van Rossum3c5936a1996-12-05 21:51:24 +00001761}
1762
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001763PyObject *
Fred Drake79912472000-07-09 04:06:11 +00001764PySequence_Fast(PyObject *v, const char *m)
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001765{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001766 PyObject *it;
Raymond Hettinger2fb70292004-01-11 23:26:51 +00001767
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001768 if (v == NULL)
1769 return null_error();
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001770
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001771 if (PyList_CheckExact(v) || PyTuple_CheckExact(v)) {
1772 Py_INCREF(v);
1773 return v;
1774 }
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001775
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001776 it = PyObject_GetIter(v);
1777 if (it == NULL) {
1778 if (PyErr_ExceptionMatches(PyExc_TypeError))
1779 PyErr_SetString(PyExc_TypeError, m);
1780 return NULL;
1781 }
Raymond Hettinger2fb70292004-01-11 23:26:51 +00001782
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001783 v = PySequence_List(it);
1784 Py_DECREF(it);
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001785
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001786 return v;
Andrew M. Kuchling74042d62000-06-18 18:43:14 +00001787}
1788
Tim Peters16a77ad2001-09-08 04:00:12 +00001789/* Iterate over seq. Result depends on the operation:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001790 PY_ITERSEARCH_COUNT: -1 if error, else # of times obj appears in seq.
1791 PY_ITERSEARCH_INDEX: 0-based index of first occurrence of obj in seq;
1792 set ValueError and return -1 if none found; also return -1 on error.
Tim Peters16a77ad2001-09-08 04:00:12 +00001793 Py_ITERSEARCH_CONTAINS: return 1 if obj in seq, else 0; -1 on error.
1794*/
Neal Norwitz1fc4b772006-03-04 18:49:58 +00001795Py_ssize_t
Tim Peters16a77ad2001-09-08 04:00:12 +00001796_PySequence_IterSearch(PyObject *seq, PyObject *obj, int operation)
Guido van Rossume15dee51995-07-18 14:12:02 +00001797{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001798 Py_ssize_t n;
1799 int wrapped; /* for PY_ITERSEARCH_INDEX, true iff n wrapped around */
1800 PyObject *it; /* iter(seq) */
Guido van Rossume15dee51995-07-18 14:12:02 +00001801
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001802 if (seq == NULL || obj == NULL) {
1803 null_error();
1804 return -1;
1805 }
Tim Peters75f8e352001-05-05 11:33:43 +00001806
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001807 it = PyObject_GetIter(seq);
1808 if (it == NULL) {
1809 type_error("argument of type '%.200s' is not iterable", seq);
1810 return -1;
1811 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001812
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001813 n = wrapped = 0;
1814 for (;;) {
1815 int cmp;
1816 PyObject *item = PyIter_Next(it);
1817 if (item == NULL) {
1818 if (PyErr_Occurred())
1819 goto Fail;
1820 break;
1821 }
Tim Peters16a77ad2001-09-08 04:00:12 +00001822
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001823 cmp = PyObject_RichCompareBool(obj, item, Py_EQ);
1824 Py_DECREF(item);
1825 if (cmp < 0)
1826 goto Fail;
1827 if (cmp > 0) {
1828 switch (operation) {
1829 case PY_ITERSEARCH_COUNT:
1830 if (n == PY_SSIZE_T_MAX) {
1831 PyErr_SetString(PyExc_OverflowError,
1832 "count exceeds C integer size");
1833 goto Fail;
1834 }
1835 ++n;
1836 break;
Tim Peters16a77ad2001-09-08 04:00:12 +00001837
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001838 case PY_ITERSEARCH_INDEX:
1839 if (wrapped) {
1840 PyErr_SetString(PyExc_OverflowError,
1841 "index exceeds C integer size");
1842 goto Fail;
1843 }
1844 goto Done;
Tim Peters16a77ad2001-09-08 04:00:12 +00001845
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001846 case PY_ITERSEARCH_CONTAINS:
1847 n = 1;
1848 goto Done;
Tim Peters16a77ad2001-09-08 04:00:12 +00001849
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001850 default:
1851 assert(!"unknown operation");
1852 }
1853 }
Tim Peters16a77ad2001-09-08 04:00:12 +00001854
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001855 if (operation == PY_ITERSEARCH_INDEX) {
1856 if (n == PY_SSIZE_T_MAX)
1857 wrapped = 1;
1858 ++n;
1859 }
1860 }
Tim Peters16a77ad2001-09-08 04:00:12 +00001861
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001862 if (operation != PY_ITERSEARCH_INDEX)
1863 goto Done;
Tim Peters16a77ad2001-09-08 04:00:12 +00001864
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001865 PyErr_SetString(PyExc_ValueError,
1866 "sequence.index(x): x not in sequence");
1867 /* fall into failure code */
Tim Peters16a77ad2001-09-08 04:00:12 +00001868Fail:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001869 n = -1;
1870 /* fall through */
Tim Peters16a77ad2001-09-08 04:00:12 +00001871Done:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001872 Py_DECREF(it);
1873 return n;
Tim Peters75f8e352001-05-05 11:33:43 +00001874
Guido van Rossume15dee51995-07-18 14:12:02 +00001875}
1876
Tim Peters16a77ad2001-09-08 04:00:12 +00001877/* Return # of times o appears in s. */
Neal Norwitz1fc4b772006-03-04 18:49:58 +00001878Py_ssize_t
Tim Peters16a77ad2001-09-08 04:00:12 +00001879PySequence_Count(PyObject *s, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001880{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001881 return _PySequence_IterSearch(s, o, PY_ITERSEARCH_COUNT);
Guido van Rossume15dee51995-07-18 14:12:02 +00001882}
1883
Tim Peterscb8d3682001-05-05 21:05:01 +00001884/* Return -1 if error; 1 if ob in seq; 0 if ob not in seq.
Tim Peters16a77ad2001-09-08 04:00:12 +00001885 * Use sq_contains if possible, else defer to _PySequence_IterSearch().
Tim Peterscb8d3682001-05-05 21:05:01 +00001886 */
1887int
1888PySequence_Contains(PyObject *seq, PyObject *ob)
1889{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001890 Py_ssize_t result;
1891 PySequenceMethods *sqm = seq->ob_type->tp_as_sequence;
1892 if (sqm != NULL && sqm->sq_contains != NULL)
1893 return (*sqm->sq_contains)(seq, ob);
1894 result = _PySequence_IterSearch(seq, ob, PY_ITERSEARCH_CONTAINS);
1895 return Py_SAFE_DOWNCAST(result, Py_ssize_t, int);
Tim Peterscb8d3682001-05-05 21:05:01 +00001896}
1897
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001898/* Backwards compatibility */
1899#undef PySequence_In
1900int
Fred Drake79912472000-07-09 04:06:11 +00001901PySequence_In(PyObject *w, PyObject *v)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001902{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001903 return PySequence_Contains(w, v);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001904}
1905
Neal Norwitz1fc4b772006-03-04 18:49:58 +00001906Py_ssize_t
Fred Drake79912472000-07-09 04:06:11 +00001907PySequence_Index(PyObject *s, PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001908{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001909 return _PySequence_IterSearch(s, o, PY_ITERSEARCH_INDEX);
Guido van Rossume15dee51995-07-18 14:12:02 +00001910}
1911
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001912/* Operations on mappings */
1913
1914int
Fred Drake79912472000-07-09 04:06:11 +00001915PyMapping_Check(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001916{
Benjamin Peterson21992272011-12-28 12:01:31 -06001917 return o && o->ob_type->tp_as_mapping &&
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001918 o->ob_type->tp_as_mapping->mp_subscript;
Guido van Rossume15dee51995-07-18 14:12:02 +00001919}
1920
Martin v. Löwis18e16552006-02-15 17:27:45 +00001921Py_ssize_t
Jeremy Hylton6253f832000-07-12 12:56:19 +00001922PyMapping_Size(PyObject *o)
Guido van Rossume15dee51995-07-18 14:12:02 +00001923{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001924 PyMappingMethods *m;
Guido van Rossume15dee51995-07-18 14:12:02 +00001925
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001926 if (o == NULL) {
1927 null_error();
1928 return -1;
1929 }
Guido van Rossume15dee51995-07-18 14:12:02 +00001930
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001931 m = o->ob_type->tp_as_mapping;
1932 if (m && m->mp_length)
1933 return m->mp_length(o);
Guido van Rossume15dee51995-07-18 14:12:02 +00001934
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001935 type_error("object of type '%.200s' has no len()", o);
1936 return -1;
Guido van Rossume15dee51995-07-18 14:12:02 +00001937}
1938
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +00001939#undef PyMapping_Length
Martin v. Löwis18e16552006-02-15 17:27:45 +00001940Py_ssize_t
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +00001941PyMapping_Length(PyObject *o)
1942{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001943 return PyMapping_Size(o);
Marc-André Lemburgcf5f3582000-07-17 09:22:55 +00001944}
1945#define PyMapping_Length PyMapping_Size
1946
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001947PyObject *
Serhiy Storchakac6792272013-10-19 21:03:34 +03001948PyMapping_GetItemString(PyObject *o, const char *key)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001949{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001950 PyObject *okey, *r;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001951
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001952 if (key == NULL)
1953 return null_error();
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001954
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001955 okey = PyUnicode_FromString(key);
1956 if (okey == NULL)
1957 return NULL;
1958 r = PyObject_GetItem(o, okey);
1959 Py_DECREF(okey);
1960 return r;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001961}
1962
1963int
Serhiy Storchakac6792272013-10-19 21:03:34 +03001964PyMapping_SetItemString(PyObject *o, const char *key, PyObject *value)
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001965{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001966 PyObject *okey;
1967 int r;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001968
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001969 if (key == NULL) {
1970 null_error();
1971 return -1;
1972 }
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001973
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001974 okey = PyUnicode_FromString(key);
1975 if (okey == NULL)
1976 return -1;
1977 r = PyObject_SetItem(o, okey, value);
1978 Py_DECREF(okey);
1979 return r;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001980}
1981
1982int
Serhiy Storchakac6792272013-10-19 21:03:34 +03001983PyMapping_HasKeyString(PyObject *o, const char *key)
Guido van Rossume15dee51995-07-18 14:12:02 +00001984{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001985 PyObject *v;
Guido van Rossume15dee51995-07-18 14:12:02 +00001986
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001987 v = PyMapping_GetItemString(o, key);
1988 if (v) {
1989 Py_DECREF(v);
1990 return 1;
1991 }
1992 PyErr_Clear();
1993 return 0;
Guido van Rossume15dee51995-07-18 14:12:02 +00001994}
1995
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00001996int
Fred Drake79912472000-07-09 04:06:11 +00001997PyMapping_HasKey(PyObject *o, PyObject *key)
Guido van Rossume15dee51995-07-18 14:12:02 +00001998{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001999 PyObject *v;
Guido van Rossume15dee51995-07-18 14:12:02 +00002000
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002001 v = PyObject_GetItem(o, key);
2002 if (v) {
2003 Py_DECREF(v);
2004 return 1;
2005 }
2006 PyErr_Clear();
2007 return 0;
Guido van Rossume15dee51995-07-18 14:12:02 +00002008}
2009
Guido van Rossumcc2b0162007-02-11 06:12:03 +00002010PyObject *
2011PyMapping_Keys(PyObject *o)
2012{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002013 PyObject *keys;
2014 PyObject *fast;
Martin v. Löwisbd928fe2011-10-14 10:20:37 +02002015 _Py_IDENTIFIER(keys);
Guido van Rossumcc2b0162007-02-11 06:12:03 +00002016
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002017 if (PyDict_CheckExact(o))
2018 return PyDict_Keys(o);
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002019 keys = _PyObject_CallMethodId(o, &PyId_keys, NULL);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002020 if (keys == NULL)
2021 return NULL;
2022 fast = PySequence_Fast(keys, "o.keys() are not iterable");
2023 Py_DECREF(keys);
2024 return fast;
Guido van Rossumcc2b0162007-02-11 06:12:03 +00002025}
2026
2027PyObject *
2028PyMapping_Items(PyObject *o)
2029{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002030 PyObject *items;
2031 PyObject *fast;
Martin v. Löwisbd928fe2011-10-14 10:20:37 +02002032 _Py_IDENTIFIER(items);
Guido van Rossumcc2b0162007-02-11 06:12:03 +00002033
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002034 if (PyDict_CheckExact(o))
2035 return PyDict_Items(o);
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002036 items = _PyObject_CallMethodId(o, &PyId_items, NULL);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002037 if (items == NULL)
2038 return NULL;
2039 fast = PySequence_Fast(items, "o.items() are not iterable");
2040 Py_DECREF(items);
2041 return fast;
Guido van Rossumcc2b0162007-02-11 06:12:03 +00002042}
2043
2044PyObject *
2045PyMapping_Values(PyObject *o)
2046{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002047 PyObject *values;
2048 PyObject *fast;
Martin v. Löwisbd928fe2011-10-14 10:20:37 +02002049 _Py_IDENTIFIER(values);
Guido van Rossumcc2b0162007-02-11 06:12:03 +00002050
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002051 if (PyDict_CheckExact(o))
2052 return PyDict_Values(o);
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002053 values = _PyObject_CallMethodId(o, &PyId_values, NULL);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002054 if (values == NULL)
2055 return NULL;
2056 fast = PySequence_Fast(values, "o.values() are not iterable");
2057 Py_DECREF(values);
2058 return fast;
Guido van Rossumcc2b0162007-02-11 06:12:03 +00002059}
2060
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002061/* Operations on callable objects */
2062
2063/* XXX PyCallable_Check() is in object.c */
2064
Guido van Rossume15dee51995-07-18 14:12:02 +00002065PyObject *
Fred Drake79912472000-07-09 04:06:11 +00002066PyObject_CallObject(PyObject *o, PyObject *a)
Guido van Rossume15dee51995-07-18 14:12:02 +00002067{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002068 return PyEval_CallObjectWithKeywords(o, a, NULL);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002069}
Guido van Rossume15dee51995-07-18 14:12:02 +00002070
2071PyObject *
Tim Peters6d6c1a32001-08-02 04:15:00 +00002072PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw)
2073{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002074 ternaryfunc call;
Tim Peters6d6c1a32001-08-02 04:15:00 +00002075
Victor Stinner8f4ec8d2014-09-05 01:10:29 +02002076 /* PyObject_Call() must not be called with an exception set,
2077 because it may clear it (directly or indirectly) and so the
2078 caller looses its exception */
2079 assert(!PyErr_Occurred());
2080
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002081 if ((call = func->ob_type->tp_call) != NULL) {
2082 PyObject *result;
2083 if (Py_EnterRecursiveCall(" while calling a Python object"))
2084 return NULL;
2085 result = (*call)(func, arg, kw);
2086 Py_LeaveRecursiveCall();
Victor Stinner3de58692013-07-15 17:50:07 +02002087#ifdef NDEBUG
2088 if (result == NULL && !PyErr_Occurred()) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002089 PyErr_SetString(
2090 PyExc_SystemError,
2091 "NULL result without error in PyObject_Call");
Victor Stinner3de58692013-07-15 17:50:07 +02002092 }
2093#else
Victor Stinner4ac9c002013-12-19 13:47:35 +01002094 assert((result != NULL && !PyErr_Occurred())
2095 || (result == NULL && PyErr_Occurred()));
Victor Stinner3de58692013-07-15 17:50:07 +02002096#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002097 return result;
2098 }
2099 PyErr_Format(PyExc_TypeError, "'%.200s' object is not callable",
2100 func->ob_type->tp_name);
2101 return NULL;
Tim Peters6d6c1a32001-08-02 04:15:00 +00002102}
2103
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002104static PyObject*
2105call_function_tail(PyObject *callable, PyObject *args)
2106{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002107 PyObject *retval;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002108
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002109 if (args == NULL)
2110 return NULL;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002111
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002112 if (!PyTuple_Check(args)) {
2113 PyObject *a;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002114
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002115 a = PyTuple_New(1);
2116 if (a == NULL) {
2117 Py_DECREF(args);
2118 return NULL;
2119 }
2120 PyTuple_SET_ITEM(a, 0, args);
2121 args = a;
2122 }
2123 retval = PyObject_Call(callable, args, NULL);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002124
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002125 Py_DECREF(args);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002126
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002127 return retval;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002128}
2129
Tim Peters6d6c1a32001-08-02 04:15:00 +00002130PyObject *
Serhiy Storchaka1cfebc72013-05-29 18:50:54 +03002131PyObject_CallFunction(PyObject *callable, const char *format, ...)
Guido van Rossume15dee51995-07-18 14:12:02 +00002132{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002133 va_list va;
2134 PyObject *args;
Guido van Rossume15dee51995-07-18 14:12:02 +00002135
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002136 if (callable == NULL)
2137 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00002138
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002139 if (format && *format) {
2140 va_start(va, format);
2141 args = Py_VaBuildValue(format, va);
2142 va_end(va);
2143 }
2144 else
2145 args = PyTuple_New(0);
Victor Stinner0b0c8672013-10-29 19:29:52 +01002146 if (args == NULL)
2147 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +00002148
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002149 return call_function_tail(callable, args);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002150}
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002151
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002152PyObject *
Serhiy Storchaka1cfebc72013-05-29 18:50:54 +03002153_PyObject_CallFunction_SizeT(PyObject *callable, const char *format, ...)
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002154{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002155 va_list va;
2156 PyObject *args;
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002157
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002158 if (callable == NULL)
2159 return null_error();
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002160
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002161 if (format && *format) {
2162 va_start(va, format);
2163 args = _Py_VaBuildValue_SizeT(format, va);
2164 va_end(va);
2165 }
2166 else
2167 args = PyTuple_New(0);
Guido van Rossumcea1c8c1998-05-22 00:47:05 +00002168
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002169 return call_function_tail(callable, args);
Guido van Rossume15dee51995-07-18 14:12:02 +00002170}
2171
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002172static PyObject*
Serhiy Storchaka1cfebc72013-05-29 18:50:54 +03002173callmethod(PyObject* func, const char *format, va_list va, int is_size_t)
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002174{
2175 PyObject *retval = NULL;
2176 PyObject *args;
2177
2178 if (!PyCallable_Check(func)) {
2179 type_error("attribute of type '%.200s' is not callable", func);
2180 goto exit;
2181 }
2182
2183 if (format && *format) {
2184 if (is_size_t)
2185 args = _Py_VaBuildValue_SizeT(format, va);
2186 else
2187 args = Py_VaBuildValue(format, va);
2188 }
2189 else
2190 args = PyTuple_New(0);
2191
2192 retval = call_function_tail(func, args);
2193
2194 exit:
2195 /* args gets consumed in call_function_tail */
2196 Py_XDECREF(func);
2197
2198 return retval;
2199}
2200
Guido van Rossume15dee51995-07-18 14:12:02 +00002201PyObject *
Serhiy Storchaka1cfebc72013-05-29 18:50:54 +03002202PyObject_CallMethod(PyObject *o, const char *name, const char *format, ...)
Guido van Rossume15dee51995-07-18 14:12:02 +00002203{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002204 va_list va;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002205 PyObject *func = NULL;
2206 PyObject *retval = NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +00002207
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002208 if (o == NULL || name == NULL)
2209 return null_error();
Guido van Rossume15dee51995-07-18 14:12:02 +00002210
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002211 func = PyObject_GetAttrString(o, name);
Benjamin Peterson1791c222014-06-26 23:29:13 -07002212 if (func == NULL)
2213 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +00002214
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002215 va_start(va, format);
2216 retval = callmethod(func, format, va, 0);
2217 va_end(va);
2218 return retval;
2219}
2220
2221PyObject *
Serhiy Storchaka1cfebc72013-05-29 18:50:54 +03002222_PyObject_CallMethodId(PyObject *o, _Py_Identifier *name,
2223 const char *format, ...)
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002224{
2225 va_list va;
2226 PyObject *func = NULL;
2227 PyObject *retval = NULL;
2228
2229 if (o == NULL || name == NULL)
2230 return null_error();
2231
2232 func = _PyObject_GetAttrId(o, name);
Benjamin Peterson1791c222014-06-26 23:29:13 -07002233 if (func == NULL)
2234 return NULL;
Guido van Rossume15dee51995-07-18 14:12:02 +00002235
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002236 va_start(va, format);
2237 retval = callmethod(func, format, va, 0);
2238 va_end(va);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002239 return retval;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002240}
2241
2242PyObject *
Serhiy Storchaka1cfebc72013-05-29 18:50:54 +03002243_PyObject_CallMethod_SizeT(PyObject *o, const char *name,
2244 const char *format, ...)
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002245{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002246 va_list va;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002247 PyObject *func = NULL;
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002248 PyObject *retval;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002249
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002250 if (o == NULL || name == NULL)
2251 return null_error();
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002252
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002253 func = PyObject_GetAttrString(o, name);
Benjamin Peterson1791c222014-06-26 23:29:13 -07002254 if (func == NULL)
2255 return NULL;
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002256 va_start(va, format);
2257 retval = callmethod(func, format, va, 1);
2258 va_end(va);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002259 return retval;
Guido van Rossume15dee51995-07-18 14:12:02 +00002260}
Guido van Rossum823649d2001-03-21 18:40:58 +00002261
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002262PyObject *
Serhiy Storchaka1cfebc72013-05-29 18:50:54 +03002263_PyObject_CallMethodId_SizeT(PyObject *o, _Py_Identifier *name,
2264 const char *format, ...)
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002265{
2266 va_list va;
2267 PyObject *func = NULL;
2268 PyObject *retval;
2269
2270 if (o == NULL || name == NULL)
2271 return null_error();
2272
2273 func = _PyObject_GetAttrId(o, name);
2274 if (func == NULL) {
Martin v. Löwisafe55bb2011-10-09 10:38:36 +02002275 return NULL;
2276 }
2277 va_start(va, format);
2278 retval = callmethod(func, format, va, 1);
2279 va_end(va);
2280 return retval;
2281}
Guido van Rossum823649d2001-03-21 18:40:58 +00002282
Fred Drakeb421b8c2001-10-26 16:21:32 +00002283static PyObject *
Fred Drakeb0c079e2001-10-28 02:39:03 +00002284objargs_mktuple(va_list va)
Fred Drakeb421b8c2001-10-26 16:21:32 +00002285{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002286 int i, n = 0;
2287 va_list countva;
2288 PyObject *result, *tmp;
Fred Drakeb421b8c2001-10-26 16:21:32 +00002289
Alexander Belopolskyf0f45142010-08-11 17:31:17 +00002290 Py_VA_COPY(countva, va);
Fred Drakeb421b8c2001-10-26 16:21:32 +00002291
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002292 while (((PyObject *)va_arg(countva, PyObject *)) != NULL)
2293 ++n;
2294 result = PyTuple_New(n);
2295 if (result != NULL && n > 0) {
2296 for (i = 0; i < n; ++i) {
2297 tmp = (PyObject *)va_arg(va, PyObject *);
2298 PyTuple_SET_ITEM(result, i, tmp);
2299 Py_INCREF(tmp);
2300 }
2301 }
2302 return result;
Fred Drakeb421b8c2001-10-26 16:21:32 +00002303}
2304
2305PyObject *
Fred Drakeb0c079e2001-10-28 02:39:03 +00002306PyObject_CallMethodObjArgs(PyObject *callable, PyObject *name, ...)
Fred Drakeb421b8c2001-10-26 16:21:32 +00002307{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002308 PyObject *args, *tmp;
2309 va_list vargs;
Fred Drakeb421b8c2001-10-26 16:21:32 +00002310
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002311 if (callable == NULL || name == NULL)
2312 return null_error();
Fred Drakeb421b8c2001-10-26 16:21:32 +00002313
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002314 callable = PyObject_GetAttr(callable, name);
2315 if (callable == NULL)
2316 return NULL;
Fred Drakeb421b8c2001-10-26 16:21:32 +00002317
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002318 /* count the args */
2319 va_start(vargs, name);
2320 args = objargs_mktuple(vargs);
2321 va_end(vargs);
2322 if (args == NULL) {
2323 Py_DECREF(callable);
2324 return NULL;
2325 }
2326 tmp = PyObject_Call(callable, args, NULL);
2327 Py_DECREF(args);
2328 Py_DECREF(callable);
Fred Drakeb421b8c2001-10-26 16:21:32 +00002329
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002330 return tmp;
Fred Drakeb421b8c2001-10-26 16:21:32 +00002331}
2332
2333PyObject *
Alexandre Vassalotti865eaa12013-05-02 10:44:04 -07002334_PyObject_CallMethodIdObjArgs(PyObject *callable,
Brett Cannonfd074152012-04-14 14:10:13 -04002335 struct _Py_Identifier *name, ...)
2336{
2337 PyObject *args, *tmp;
2338 va_list vargs;
2339
2340 if (callable == NULL || name == NULL)
2341 return null_error();
2342
2343 callable = _PyObject_GetAttrId(callable, name);
2344 if (callable == NULL)
2345 return NULL;
2346
2347 /* count the args */
2348 va_start(vargs, name);
2349 args = objargs_mktuple(vargs);
2350 va_end(vargs);
2351 if (args == NULL) {
2352 Py_DECREF(callable);
2353 return NULL;
2354 }
2355 tmp = PyObject_Call(callable, args, NULL);
2356 Py_DECREF(args);
2357 Py_DECREF(callable);
2358
2359 return tmp;
2360}
2361
2362PyObject *
Fred Drakeb0c079e2001-10-28 02:39:03 +00002363PyObject_CallFunctionObjArgs(PyObject *callable, ...)
Fred Drakeb421b8c2001-10-26 16:21:32 +00002364{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002365 PyObject *args, *tmp;
2366 va_list vargs;
Fred Drakeb421b8c2001-10-26 16:21:32 +00002367
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002368 if (callable == NULL)
2369 return null_error();
Fred Drakeb421b8c2001-10-26 16:21:32 +00002370
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002371 /* count the args */
2372 va_start(vargs, callable);
2373 args = objargs_mktuple(vargs);
2374 va_end(vargs);
2375 if (args == NULL)
2376 return NULL;
2377 tmp = PyObject_Call(callable, args, NULL);
2378 Py_DECREF(args);
Fred Drakeb421b8c2001-10-26 16:21:32 +00002379
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002380 return tmp;
Fred Drakeb421b8c2001-10-26 16:21:32 +00002381}
2382
2383
Guido van Rossum823649d2001-03-21 18:40:58 +00002384/* isinstance(), issubclass() */
2385
Benjamin Peterson9fc9bf42012-03-20 23:26:41 -04002386/* abstract_get_bases() has logically 4 return states:
Barry Warsawf16951c2002-04-23 22:45:44 +00002387 *
Barry Warsawf16951c2002-04-23 22:45:44 +00002388 * 1. getattr(cls, '__bases__') could raise an AttributeError
2389 * 2. getattr(cls, '__bases__') could raise some other exception
2390 * 3. getattr(cls, '__bases__') could return a tuple
2391 * 4. getattr(cls, '__bases__') could return something other than a tuple
2392 *
2393 * Only state #3 is a non-error state and only it returns a non-NULL object
2394 * (it returns the retrieved tuple).
2395 *
2396 * Any raised AttributeErrors are masked by clearing the exception and
2397 * returning NULL. If an object other than a tuple comes out of __bases__,
2398 * then again, the return value is NULL. So yes, these two situations
2399 * produce exactly the same results: NULL is returned and no error is set.
2400 *
2401 * If some exception other than AttributeError is raised, then NULL is also
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002402 * returned, but the exception is not cleared. That's because we want the
Barry Warsawf16951c2002-04-23 22:45:44 +00002403 * exception to be propagated along.
2404 *
2405 * Callers are expected to test for PyErr_Occurred() when the return value
2406 * is NULL to decide whether a valid exception should be propagated or not.
2407 * When there's no exception to propagate, it's customary for the caller to
2408 * set a TypeError.
2409 */
Neil Schemenauer6b471292001-10-18 03:18:43 +00002410static PyObject *
2411abstract_get_bases(PyObject *cls)
Guido van Rossum823649d2001-03-21 18:40:58 +00002412{
Benjamin Peterson9fc9bf42012-03-20 23:26:41 -04002413 _Py_IDENTIFIER(__bases__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002414 PyObject *bases;
Guido van Rossum823649d2001-03-21 18:40:58 +00002415
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002416 Py_ALLOW_RECURSION
Benjamin Peterson9fc9bf42012-03-20 23:26:41 -04002417 bases = _PyObject_GetAttrId(cls, &PyId___bases__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002418 Py_END_ALLOW_RECURSION
2419 if (bases == NULL) {
2420 if (PyErr_ExceptionMatches(PyExc_AttributeError))
2421 PyErr_Clear();
2422 return NULL;
2423 }
2424 if (!PyTuple_Check(bases)) {
2425 Py_DECREF(bases);
2426 return NULL;
2427 }
2428 return bases;
Neil Schemenauer6b471292001-10-18 03:18:43 +00002429}
2430
2431
2432static int
2433abstract_issubclass(PyObject *derived, PyObject *cls)
2434{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002435 PyObject *bases = NULL;
2436 Py_ssize_t i, n;
2437 int r = 0;
Neil Schemenauer6b471292001-10-18 03:18:43 +00002438
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002439 while (1) {
2440 if (derived == cls)
2441 return 1;
2442 bases = abstract_get_bases(derived);
2443 if (bases == NULL) {
2444 if (PyErr_Occurred())
2445 return -1;
2446 return 0;
2447 }
2448 n = PyTuple_GET_SIZE(bases);
2449 if (n == 0) {
2450 Py_DECREF(bases);
2451 return 0;
2452 }
2453 /* Avoid recursivity in the single inheritance case */
2454 if (n == 1) {
2455 derived = PyTuple_GET_ITEM(bases, 0);
2456 Py_DECREF(bases);
2457 continue;
2458 }
2459 for (i = 0; i < n; i++) {
2460 r = abstract_issubclass(PyTuple_GET_ITEM(bases, i), cls);
2461 if (r != 0)
2462 break;
2463 }
2464 Py_DECREF(bases);
2465 return r;
2466 }
Guido van Rossum823649d2001-03-21 18:40:58 +00002467}
2468
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00002469static int
2470check_class(PyObject *cls, const char *error)
2471{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002472 PyObject *bases = abstract_get_bases(cls);
2473 if (bases == NULL) {
2474 /* Do not mask errors. */
2475 if (!PyErr_Occurred())
2476 PyErr_SetString(PyExc_TypeError, error);
2477 return 0;
2478 }
2479 Py_DECREF(bases);
2480 return -1;
Walter Dörwaldd9a6ad32002-12-12 16:41:44 +00002481}
2482
Brett Cannon4f653312004-03-20 22:52:14 +00002483static int
Antoine Pitrouec569b72008-08-26 22:40:48 +00002484recursive_isinstance(PyObject *inst, PyObject *cls)
Guido van Rossum823649d2001-03-21 18:40:58 +00002485{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002486 PyObject *icls;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002487 int retval = 0;
Benjamin Peterson9fc9bf42012-03-20 23:26:41 -04002488 _Py_IDENTIFIER(__class__);
Guido van Rossum03bc7d32003-02-12 03:32:58 +00002489
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002490 if (PyType_Check(cls)) {
2491 retval = PyObject_TypeCheck(inst, (PyTypeObject *)cls);
2492 if (retval == 0) {
Benjamin Peterson9fc9bf42012-03-20 23:26:41 -04002493 PyObject *c = _PyObject_GetAttrId(inst, &PyId___class__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002494 if (c == NULL) {
Benjamin Peterson72288d42010-11-20 17:21:08 +00002495 if (PyErr_ExceptionMatches(PyExc_AttributeError))
R. David Murray6bb99892010-11-20 16:33:30 +00002496 PyErr_Clear();
Benjamin Peterson72288d42010-11-20 17:21:08 +00002497 else
R. David Murray6bb99892010-11-20 16:33:30 +00002498 retval = -1;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002499 }
2500 else {
2501 if (c != (PyObject *)(inst->ob_type) &&
2502 PyType_Check(c))
2503 retval = PyType_IsSubtype(
2504 (PyTypeObject *)c,
2505 (PyTypeObject *)cls);
2506 Py_DECREF(c);
2507 }
2508 }
2509 }
2510 else {
2511 if (!check_class(cls,
Benjamin Petersone893af52010-06-28 19:43:42 +00002512 "isinstance() arg 2 must be a type or tuple of types"))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002513 return -1;
Benjamin Peterson9fc9bf42012-03-20 23:26:41 -04002514 icls = _PyObject_GetAttrId(inst, &PyId___class__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002515 if (icls == NULL) {
Benjamin Peterson72288d42010-11-20 17:21:08 +00002516 if (PyErr_ExceptionMatches(PyExc_AttributeError))
R. David Murray6bb99892010-11-20 16:33:30 +00002517 PyErr_Clear();
Benjamin Peterson72288d42010-11-20 17:21:08 +00002518 else
R. David Murray6bb99892010-11-20 16:33:30 +00002519 retval = -1;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002520 }
2521 else {
2522 retval = abstract_issubclass(icls, cls);
2523 Py_DECREF(icls);
2524 }
2525 }
Guido van Rossum823649d2001-03-21 18:40:58 +00002526
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002527 return retval;
Guido van Rossum823649d2001-03-21 18:40:58 +00002528}
2529
2530int
Brett Cannon4f653312004-03-20 22:52:14 +00002531PyObject_IsInstance(PyObject *inst, PyObject *cls)
2532{
Benjamin Petersonce798522012-01-22 11:24:29 -05002533 _Py_IDENTIFIER(__instancecheck__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002534 PyObject *checker;
Christian Heimesd5e2b6f2008-03-19 21:50:51 +00002535
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002536 /* Quick test for an exact match */
2537 if (Py_TYPE(inst) == (PyTypeObject *)cls)
2538 return 1;
Christian Heimesd5e2b6f2008-03-19 21:50:51 +00002539
Georg Brandl72b8a802014-10-03 09:26:37 +02002540 /* We know what type's __instancecheck__ does. */
2541 if (PyType_CheckExact(cls)) {
2542 return recursive_isinstance(inst, cls);
2543 }
2544
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002545 if (PyTuple_Check(cls)) {
2546 Py_ssize_t i;
2547 Py_ssize_t n;
2548 int r = 0;
Antoine Pitrouec569b72008-08-26 22:40:48 +00002549
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002550 if (Py_EnterRecursiveCall(" in __instancecheck__"))
2551 return -1;
2552 n = PyTuple_GET_SIZE(cls);
2553 for (i = 0; i < n; ++i) {
2554 PyObject *item = PyTuple_GET_ITEM(cls, i);
2555 r = PyObject_IsInstance(inst, item);
2556 if (r != 0)
2557 /* either found it, or got an error */
2558 break;
2559 }
2560 Py_LeaveRecursiveCall();
2561 return r;
2562 }
Benjamin Peterson88fe5f92009-05-16 21:55:24 +00002563
Benjamin Petersonce798522012-01-22 11:24:29 -05002564 checker = _PyObject_LookupSpecial(cls, &PyId___instancecheck__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002565 if (checker != NULL) {
2566 PyObject *res;
2567 int ok = -1;
2568 if (Py_EnterRecursiveCall(" in __instancecheck__")) {
2569 Py_DECREF(checker);
2570 return ok;
2571 }
2572 res = PyObject_CallFunctionObjArgs(checker, inst, NULL);
2573 Py_LeaveRecursiveCall();
2574 Py_DECREF(checker);
2575 if (res != NULL) {
2576 ok = PyObject_IsTrue(res);
2577 Py_DECREF(res);
2578 }
2579 return ok;
2580 }
2581 else if (PyErr_Occurred())
2582 return -1;
Georg Brandl72b8a802014-10-03 09:26:37 +02002583 /* Probably never reached anymore. */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002584 return recursive_isinstance(inst, cls);
Brett Cannon4f653312004-03-20 22:52:14 +00002585}
2586
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002587static int
Antoine Pitrouec569b72008-08-26 22:40:48 +00002588recursive_issubclass(PyObject *derived, PyObject *cls)
Guido van Rossum823649d2001-03-21 18:40:58 +00002589{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002590 if (PyType_Check(cls) && PyType_Check(derived)) {
2591 /* Fast path (non-recursive) */
2592 return PyType_IsSubtype((PyTypeObject *)derived, (PyTypeObject *)cls);
2593 }
2594 if (!check_class(derived,
2595 "issubclass() arg 1 must be a class"))
2596 return -1;
2597 if (!check_class(cls,
2598 "issubclass() arg 2 must be a class"
2599 " or tuple of classes"))
2600 return -1;
Guido van Rossum823649d2001-03-21 18:40:58 +00002601
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002602 return abstract_issubclass(derived, cls);
Guido van Rossum823649d2001-03-21 18:40:58 +00002603}
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002604
Brett Cannon4f653312004-03-20 22:52:14 +00002605int
2606PyObject_IsSubclass(PyObject *derived, PyObject *cls)
2607{
Benjamin Petersonce798522012-01-22 11:24:29 -05002608 _Py_IDENTIFIER(__subclasscheck__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002609 PyObject *checker;
Georg Brandldcfe8e42009-05-17 08:22:45 +00002610
Georg Brandl72b8a802014-10-03 09:26:37 +02002611 /* We know what type's __subclasscheck__ does. */
2612 if (PyType_CheckExact(cls)) {
2613 /* Quick test for an exact match */
2614 if (derived == cls)
2615 return 1;
2616 return recursive_issubclass(derived, cls);
2617 }
2618
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002619 if (PyTuple_Check(cls)) {
2620 Py_ssize_t i;
2621 Py_ssize_t n;
2622 int r = 0;
Antoine Pitrouec569b72008-08-26 22:40:48 +00002623
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002624 if (Py_EnterRecursiveCall(" in __subclasscheck__"))
2625 return -1;
2626 n = PyTuple_GET_SIZE(cls);
2627 for (i = 0; i < n; ++i) {
2628 PyObject *item = PyTuple_GET_ITEM(cls, i);
2629 r = PyObject_IsSubclass(derived, item);
2630 if (r != 0)
2631 /* either found it, or got an error */
2632 break;
2633 }
2634 Py_LeaveRecursiveCall();
2635 return r;
2636 }
Benjamin Peterson88fe5f92009-05-16 21:55:24 +00002637
Benjamin Petersonce798522012-01-22 11:24:29 -05002638 checker = _PyObject_LookupSpecial(cls, &PyId___subclasscheck__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002639 if (checker != NULL) {
2640 PyObject *res;
2641 int ok = -1;
2642 if (Py_EnterRecursiveCall(" in __subclasscheck__")) {
2643 Py_DECREF(checker);
2644 return ok;
2645 }
2646 res = PyObject_CallFunctionObjArgs(checker, derived, NULL);
2647 Py_LeaveRecursiveCall();
2648 Py_DECREF(checker);
2649 if (res != NULL) {
2650 ok = PyObject_IsTrue(res);
2651 Py_DECREF(res);
2652 }
2653 return ok;
2654 }
2655 else if (PyErr_Occurred())
2656 return -1;
Georg Brandl72b8a802014-10-03 09:26:37 +02002657 /* Probably never reached anymore. */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002658 return recursive_issubclass(derived, cls);
Antoine Pitrouec569b72008-08-26 22:40:48 +00002659}
2660
2661int
2662_PyObject_RealIsInstance(PyObject *inst, PyObject *cls)
2663{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002664 return recursive_isinstance(inst, cls);
Antoine Pitrouec569b72008-08-26 22:40:48 +00002665}
2666
2667int
2668_PyObject_RealIsSubclass(PyObject *derived, PyObject *cls)
2669{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002670 return recursive_issubclass(derived, cls);
Brett Cannon4f653312004-03-20 22:52:14 +00002671}
2672
2673
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002674PyObject *
2675PyObject_GetIter(PyObject *o)
2676{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002677 PyTypeObject *t = o->ob_type;
2678 getiterfunc f = NULL;
2679 f = t->tp_iter;
2680 if (f == NULL) {
2681 if (PySequence_Check(o))
2682 return PySeqIter_New(o);
2683 return type_error("'%.200s' object is not iterable", o);
2684 }
2685 else {
2686 PyObject *res = (*f)(o);
2687 if (res != NULL && !PyIter_Check(res)) {
2688 PyErr_Format(PyExc_TypeError,
2689 "iter() returned non-iterator "
2690 "of type '%.100s'",
2691 res->ob_type->tp_name);
2692 Py_DECREF(res);
2693 res = NULL;
2694 }
2695 return res;
2696 }
Guido van Rossum213c7a62001-04-23 14:08:49 +00002697}
2698
Tim Petersf4848da2001-05-05 00:14:56 +00002699/* Return next item.
2700 * If an error occurs, return NULL. PyErr_Occurred() will be true.
2701 * If the iteration terminates normally, return NULL and clear the
2702 * PyExc_StopIteration exception (if it was set). PyErr_Occurred()
2703 * will be false.
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002704 * Else return the next object. PyErr_Occurred() will be false.
Tim Petersf4848da2001-05-05 00:14:56 +00002705 */
Guido van Rossum213c7a62001-04-23 14:08:49 +00002706PyObject *
2707PyIter_Next(PyObject *iter)
2708{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002709 PyObject *result;
2710 result = (*iter->ob_type->tp_iternext)(iter);
2711 if (result == NULL &&
2712 PyErr_Occurred() &&
2713 PyErr_ExceptionMatches(PyExc_StopIteration))
2714 PyErr_Clear();
2715 return result;
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002716}
Gregory P. Smithfb94c5f2010-03-14 06:49:55 +00002717
2718
2719/*
2720 * Flatten a sequence of bytes() objects into a C array of
2721 * NULL terminated string pointers with a NULL char* terminating the array.
2722 * (ie: an argv or env list)
2723 *
Victor Stinner0e2d3cf2013-07-07 17:22:41 +02002724 * Memory allocated for the returned list is allocated using PyMem_Malloc()
2725 * and MUST be freed by _Py_FreeCharPArray().
Gregory P. Smithfb94c5f2010-03-14 06:49:55 +00002726 */
2727char *const *
2728_PySequence_BytesToCharpArray(PyObject* self)
2729{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002730 char **array;
2731 Py_ssize_t i, argc;
2732 PyObject *item = NULL;
Victor Stinner0e2d3cf2013-07-07 17:22:41 +02002733 Py_ssize_t size;
Gregory P. Smithfb94c5f2010-03-14 06:49:55 +00002734
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002735 argc = PySequence_Size(self);
2736 if (argc == -1)
2737 return NULL;
Gregory P. Smithfb94c5f2010-03-14 06:49:55 +00002738
Stefan Krah7cacd2e2012-08-21 08:16:09 +02002739 assert(argc >= 0);
2740
2741 if ((size_t)argc > (PY_SSIZE_T_MAX-sizeof(char *)) / sizeof(char *)) {
2742 PyErr_NoMemory();
2743 return NULL;
2744 }
2745
Victor Stinner0e2d3cf2013-07-07 17:22:41 +02002746 array = PyMem_Malloc((argc + 1) * sizeof(char *));
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002747 if (array == NULL) {
2748 PyErr_NoMemory();
2749 return NULL;
2750 }
2751 for (i = 0; i < argc; ++i) {
2752 char *data;
2753 item = PySequence_GetItem(self, i);
Stefan Krahfd24f9e2012-08-20 11:04:24 +02002754 if (item == NULL) {
2755 /* NULL terminate before freeing. */
2756 array[i] = NULL;
2757 goto fail;
2758 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002759 data = PyBytes_AsString(item);
2760 if (data == NULL) {
2761 /* NULL terminate before freeing. */
2762 array[i] = NULL;
2763 goto fail;
2764 }
Victor Stinner0e2d3cf2013-07-07 17:22:41 +02002765 size = PyBytes_GET_SIZE(item) + 1;
2766 array[i] = PyMem_Malloc(size);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002767 if (!array[i]) {
2768 PyErr_NoMemory();
2769 goto fail;
2770 }
Victor Stinner0e2d3cf2013-07-07 17:22:41 +02002771 memcpy(array[i], data, size);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002772 Py_DECREF(item);
2773 }
2774 array[argc] = NULL;
Gregory P. Smithfb94c5f2010-03-14 06:49:55 +00002775
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002776 return array;
Gregory P. Smithfb94c5f2010-03-14 06:49:55 +00002777
2778fail:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002779 Py_XDECREF(item);
2780 _Py_FreeCharPArray(array);
2781 return NULL;
Gregory P. Smithfb94c5f2010-03-14 06:49:55 +00002782}
2783
2784
2785/* Free's a NULL terminated char** array of C strings. */
2786void
2787_Py_FreeCharPArray(char *const array[])
2788{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002789 Py_ssize_t i;
2790 for (i = 0; array[i] != NULL; ++i) {
Victor Stinner0e2d3cf2013-07-07 17:22:41 +02002791 PyMem_Free(array[i]);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002792 }
Victor Stinner0e2d3cf2013-07-07 17:22:41 +02002793 PyMem_Free((void*)array);
Gregory P. Smithfb94c5f2010-03-14 06:49:55 +00002794}