Branch data Line data Source code
1 : : /* Abstract Object Interface (many thanks to Jim Fulton) */
2 : :
3 : : #include "Python.h"
4 : : #include "pycore_abstract.h" // _PyIndex_Check()
5 : : #include "pycore_call.h" // _PyObject_CallNoArgs()
6 : : #include "pycore_ceval.h" // _Py_EnterRecursiveCallTstate()
7 : : #include "pycore_object.h" // _Py_CheckSlotResult()
8 : : #include "pycore_pyerrors.h" // _PyErr_Occurred()
9 : : #include "pycore_pystate.h" // _PyThreadState_GET()
10 : : #include "pycore_unionobject.h" // _PyUnion_Check()
11 : : #include <ctype.h>
12 : : #include <stddef.h> // offsetof()
13 : :
14 : :
15 : :
16 : : /* Shorthands to return certain errors */
17 : :
18 : : static PyObject *
19 : 89336 : type_error(const char *msg, PyObject *obj)
20 : : {
21 : 89336 : PyErr_Format(PyExc_TypeError, msg, Py_TYPE(obj)->tp_name);
22 : 89336 : return NULL;
23 : : }
24 : :
25 : : static PyObject *
26 : 0 : null_error(void)
27 : : {
28 : 0 : PyThreadState *tstate = _PyThreadState_GET();
29 [ # # ]: 0 : if (!_PyErr_Occurred(tstate)) {
30 : 0 : _PyErr_SetString(tstate, PyExc_SystemError,
31 : : "null argument to internal routine");
32 : : }
33 : 0 : return NULL;
34 : : }
35 : :
36 : : /* Operations on any object */
37 : :
38 : : PyObject *
39 : 26827 : PyObject_Type(PyObject *o)
40 : : {
41 : : PyObject *v;
42 : :
43 [ - + ]: 26827 : if (o == NULL) {
44 : 0 : return null_error();
45 : : }
46 : :
47 : 26827 : v = (PyObject *)Py_TYPE(o);
48 : 26827 : Py_INCREF(v);
49 : 26827 : return v;
50 : : }
51 : :
52 : : Py_ssize_t
53 : 32240355 : PyObject_Size(PyObject *o)
54 : : {
55 [ - + ]: 32240355 : if (o == NULL) {
56 : 0 : null_error();
57 : 0 : return -1;
58 : : }
59 : :
60 : 32240355 : PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
61 [ + + + + ]: 32240355 : if (m && m->sq_length) {
62 : 31030903 : Py_ssize_t len = m->sq_length(o);
63 : : assert(_Py_CheckSlotResult(o, "__len__", len >= 0));
64 : 31030903 : return len;
65 : : }
66 : :
67 : 1209452 : return PyMapping_Size(o);
68 : : }
69 : :
70 : : #undef PyObject_Length
71 : : Py_ssize_t
72 : 0 : PyObject_Length(PyObject *o)
73 : : {
74 : 0 : return PyObject_Size(o);
75 : : }
76 : : #define PyObject_Length PyObject_Size
77 : :
78 : : int
79 : 1761252 : _PyObject_HasLen(PyObject *o) {
80 [ + + + + ]: 3274856 : return (Py_TYPE(o)->tp_as_sequence && Py_TYPE(o)->tp_as_sequence->sq_length) ||
81 [ + + + + ]: 1513604 : (Py_TYPE(o)->tp_as_mapping && Py_TYPE(o)->tp_as_mapping->mp_length);
82 : : }
83 : :
84 : : /* The length hint function returns a non-negative value from o.__len__()
85 : : or o.__length_hint__(). If those methods aren't found the defaultvalue is
86 : : returned. If one of the calls fails with an exception other than TypeError
87 : : this function returns -1.
88 : : */
89 : :
90 : : Py_ssize_t
91 : 1751842 : PyObject_LengthHint(PyObject *o, Py_ssize_t defaultvalue)
92 : : {
93 : : PyObject *hint, *result;
94 : : Py_ssize_t res;
95 [ + + ]: 1751842 : if (_PyObject_HasLen(o)) {
96 : 372516 : res = PyObject_Length(o);
97 [ + + ]: 372516 : if (res < 0) {
98 : 5 : PyThreadState *tstate = _PyThreadState_GET();
99 : : assert(_PyErr_Occurred(tstate));
100 [ + + ]: 5 : if (!_PyErr_ExceptionMatches(tstate, PyExc_TypeError)) {
101 : 3 : return -1;
102 : : }
103 : 2 : _PyErr_Clear(tstate);
104 : : }
105 : : else {
106 : 372511 : return res;
107 : : }
108 : : }
109 : 1379328 : hint = _PyObject_LookupSpecial(o, &_Py_ID(__length_hint__));
110 [ + + ]: 1379328 : if (hint == NULL) {
111 [ + + ]: 962767 : if (PyErr_Occurred()) {
112 : 1 : return -1;
113 : : }
114 : 962766 : return defaultvalue;
115 : : }
116 : 416561 : result = _PyObject_CallNoArgs(hint);
117 : 416561 : Py_DECREF(hint);
118 [ + + ]: 416561 : if (result == NULL) {
119 : 7 : PyThreadState *tstate = _PyThreadState_GET();
120 [ + + ]: 7 : if (_PyErr_ExceptionMatches(tstate, PyExc_TypeError)) {
121 : 2 : _PyErr_Clear(tstate);
122 : 2 : return defaultvalue;
123 : : }
124 : 5 : return -1;
125 : : }
126 [ + + ]: 416554 : else if (result == Py_NotImplemented) {
127 : 49 : Py_DECREF(result);
128 : 49 : return defaultvalue;
129 : : }
130 [ + + ]: 416505 : if (!PyLong_Check(result)) {
131 : 1 : PyErr_Format(PyExc_TypeError, "__length_hint__ must be an integer, not %.100s",
132 : 1 : Py_TYPE(result)->tp_name);
133 : 1 : Py_DECREF(result);
134 : 1 : return -1;
135 : : }
136 : 416504 : res = PyLong_AsSsize_t(result);
137 : 416504 : Py_DECREF(result);
138 [ + + - + ]: 416504 : if (res < 0 && PyErr_Occurred()) {
139 : 0 : return -1;
140 : : }
141 [ + + ]: 416504 : if (res < 0) {
142 : 1 : PyErr_Format(PyExc_ValueError, "__length_hint__() should return >= 0");
143 : 1 : return -1;
144 : : }
145 : 416503 : return res;
146 : : }
147 : :
148 : : PyObject *
149 : 130694002 : PyObject_GetItem(PyObject *o, PyObject *key)
150 : : {
151 [ + - - + ]: 130694002 : if (o == NULL || key == NULL) {
152 : 0 : return null_error();
153 : : }
154 : :
155 : 130694002 : PyMappingMethods *m = Py_TYPE(o)->tp_as_mapping;
156 [ + + + + ]: 130694002 : if (m && m->mp_subscript) {
157 : 130558404 : PyObject *item = m->mp_subscript(o, key);
158 : : assert(_Py_CheckSlotResult(o, "__getitem__", item != NULL));
159 : 130558404 : return item;
160 : : }
161 : :
162 : 135598 : PySequenceMethods *ms = Py_TYPE(o)->tp_as_sequence;
163 [ + + + + ]: 135598 : if (ms && ms->sq_item) {
164 [ + - ]: 106586 : if (_PyIndex_Check(key)) {
165 : : Py_ssize_t key_value;
166 : 106586 : key_value = PyNumber_AsSsize_t(key, PyExc_IndexError);
167 [ + + - + ]: 106586 : if (key_value == -1 && PyErr_Occurred())
168 : 0 : return NULL;
169 : 106586 : return PySequence_GetItem(o, key_value);
170 : : }
171 : : else {
172 : 0 : return type_error("sequence index must "
173 : : "be integer, not '%.200s'", key);
174 : : }
175 : : }
176 : :
177 [ + + ]: 29012 : if (PyType_Check(o)) {
178 : : PyObject *meth, *result;
179 : :
180 : : // Special case type[int], but disallow other types so str[int] fails
181 [ + + ]: 27332 : if ((PyTypeObject*)o == &PyType_Type) {
182 : 1382 : return Py_GenericAlias(o, key);
183 : : }
184 : :
185 [ - + ]: 25950 : if (_PyObject_LookupAttr(o, &_Py_ID(__class_getitem__), &meth) < 0) {
186 : 0 : return NULL;
187 : : }
188 [ + + + + ]: 25950 : if (meth && meth != Py_None) {
189 : 25941 : result = PyObject_CallOneArg(meth, key);
190 : 25941 : Py_DECREF(meth);
191 : 25941 : return result;
192 : : }
193 : 9 : Py_XDECREF(meth);
194 : 9 : PyErr_Format(PyExc_TypeError, "type '%.200s' is not subscriptable",
195 : : ((PyTypeObject *)o)->tp_name);
196 : 9 : return NULL;
197 : : }
198 : :
199 : 1680 : return type_error("'%.200s' object is not subscriptable", o);
200 : : }
201 : :
202 : : int
203 : 10712809 : PyObject_SetItem(PyObject *o, PyObject *key, PyObject *value)
204 : : {
205 [ + - + - : 10712809 : if (o == NULL || key == NULL || value == NULL) {
- + ]
206 : 0 : null_error();
207 : 0 : return -1;
208 : : }
209 : :
210 : 10712809 : PyMappingMethods *m = Py_TYPE(o)->tp_as_mapping;
211 [ + + + + ]: 10712809 : if (m && m->mp_ass_subscript) {
212 : 10707720 : int res = m->mp_ass_subscript(o, key, value);
213 : : assert(_Py_CheckSlotResult(o, "__setitem__", res >= 0));
214 : 10707720 : return res;
215 : : }
216 : :
217 [ + - ]: 5089 : if (Py_TYPE(o)->tp_as_sequence) {
218 [ + + ]: 5089 : if (_PyIndex_Check(key)) {
219 : : Py_ssize_t key_value;
220 : 5030 : key_value = PyNumber_AsSsize_t(key, PyExc_IndexError);
221 [ - + - - ]: 5030 : if (key_value == -1 && PyErr_Occurred())
222 : 0 : return -1;
223 : 5030 : return PySequence_SetItem(o, key_value, value);
224 : : }
225 [ + + ]: 59 : else if (Py_TYPE(o)->tp_as_sequence->sq_ass_item) {
226 : 2 : type_error("sequence index must be "
227 : : "integer, not '%.200s'", key);
228 : 2 : return -1;
229 : : }
230 : : }
231 : :
232 : 57 : type_error("'%.200s' object does not support item assignment", o);
233 : 57 : return -1;
234 : : }
235 : :
236 : : int
237 : 1852898 : PyObject_DelItem(PyObject *o, PyObject *key)
238 : : {
239 [ + - - + ]: 1852898 : if (o == NULL || key == NULL) {
240 : 0 : null_error();
241 : 0 : return -1;
242 : : }
243 : :
244 : 1852898 : PyMappingMethods *m = Py_TYPE(o)->tp_as_mapping;
245 [ + + + + ]: 1852898 : if (m && m->mp_ass_subscript) {
246 : 1849345 : int res = m->mp_ass_subscript(o, key, (PyObject*)NULL);
247 : : assert(_Py_CheckSlotResult(o, "__delitem__", res >= 0));
248 : 1849345 : return res;
249 : : }
250 : :
251 [ + - ]: 3553 : if (Py_TYPE(o)->tp_as_sequence) {
252 [ + + ]: 3553 : if (_PyIndex_Check(key)) {
253 : : Py_ssize_t key_value;
254 : 3548 : key_value = PyNumber_AsSsize_t(key, PyExc_IndexError);
255 [ + + - + ]: 3548 : if (key_value == -1 && PyErr_Occurred())
256 : 0 : return -1;
257 : 3548 : return PySequence_DelItem(o, key_value);
258 : : }
259 [ - + ]: 5 : else if (Py_TYPE(o)->tp_as_sequence->sq_ass_item) {
260 : 0 : type_error("sequence index must be "
261 : : "integer, not '%.200s'", key);
262 : 0 : return -1;
263 : : }
264 : : }
265 : :
266 : 5 : type_error("'%.200s' object does not support item deletion", o);
267 : 5 : return -1;
268 : : }
269 : :
270 : : int
271 : 0 : PyObject_DelItemString(PyObject *o, const char *key)
272 : : {
273 : : PyObject *okey;
274 : : int ret;
275 : :
276 [ # # # # ]: 0 : if (o == NULL || key == NULL) {
277 : 0 : null_error();
278 : 0 : return -1;
279 : : }
280 : 0 : okey = PyUnicode_FromString(key);
281 [ # # ]: 0 : if (okey == NULL)
282 : 0 : return -1;
283 : 0 : ret = PyObject_DelItem(o, okey);
284 : 0 : Py_DECREF(okey);
285 : 0 : return ret;
286 : : }
287 : :
288 : :
289 : : /* Return 1 if the getbuffer function is available, otherwise return 0. */
290 : : int
291 : 7227290 : PyObject_CheckBuffer(PyObject *obj)
292 : : {
293 : 7227290 : PyBufferProcs *tp_as_buffer = Py_TYPE(obj)->tp_as_buffer;
294 [ + + + + ]: 7227290 : return (tp_as_buffer != NULL && tp_as_buffer->bf_getbuffer != NULL);
295 : : }
296 : :
297 : :
298 : : /* We release the buffer right after use of this function which could
299 : : cause issues later on. Don't use these functions in new code.
300 : : */
301 : : int
302 : 0 : PyObject_CheckReadBuffer(PyObject *obj)
303 : : {
304 : 0 : PyBufferProcs *pb = Py_TYPE(obj)->tp_as_buffer;
305 : : Py_buffer view;
306 : :
307 [ # # ]: 0 : if (pb == NULL ||
308 [ # # ]: 0 : pb->bf_getbuffer == NULL)
309 : 0 : return 0;
310 [ # # ]: 0 : if ((*pb->bf_getbuffer)(obj, &view, PyBUF_SIMPLE) == -1) {
311 : 0 : PyErr_Clear();
312 : 0 : return 0;
313 : : }
314 : 0 : PyBuffer_Release(&view);
315 : 0 : return 1;
316 : : }
317 : :
318 : : static int
319 : 0 : as_read_buffer(PyObject *obj, const void **buffer, Py_ssize_t *buffer_len)
320 : : {
321 : : Py_buffer view;
322 : :
323 [ # # # # : 0 : if (obj == NULL || buffer == NULL || buffer_len == NULL) {
# # ]
324 : 0 : null_error();
325 : 0 : return -1;
326 : : }
327 [ # # ]: 0 : if (PyObject_GetBuffer(obj, &view, PyBUF_SIMPLE) != 0)
328 : 0 : return -1;
329 : :
330 : 0 : *buffer = view.buf;
331 : 0 : *buffer_len = view.len;
332 : 0 : PyBuffer_Release(&view);
333 : 0 : return 0;
334 : : }
335 : :
336 : : int
337 : 0 : PyObject_AsCharBuffer(PyObject *obj,
338 : : const char **buffer,
339 : : Py_ssize_t *buffer_len)
340 : : {
341 : 0 : return as_read_buffer(obj, (const void **)buffer, buffer_len);
342 : : }
343 : :
344 : 0 : int PyObject_AsReadBuffer(PyObject *obj,
345 : : const void **buffer,
346 : : Py_ssize_t *buffer_len)
347 : : {
348 : 0 : return as_read_buffer(obj, buffer, buffer_len);
349 : : }
350 : :
351 : 0 : int PyObject_AsWriteBuffer(PyObject *obj,
352 : : void **buffer,
353 : : Py_ssize_t *buffer_len)
354 : : {
355 : : PyBufferProcs *pb;
356 : : Py_buffer view;
357 : :
358 [ # # # # : 0 : if (obj == NULL || buffer == NULL || buffer_len == NULL) {
# # ]
359 : 0 : null_error();
360 : 0 : return -1;
361 : : }
362 : 0 : pb = Py_TYPE(obj)->tp_as_buffer;
363 [ # # ]: 0 : if (pb == NULL ||
364 [ # # # # ]: 0 : pb->bf_getbuffer == NULL ||
365 : 0 : ((*pb->bf_getbuffer)(obj, &view, PyBUF_WRITABLE) != 0)) {
366 : 0 : PyErr_SetString(PyExc_TypeError,
367 : : "expected a writable bytes-like object");
368 : 0 : return -1;
369 : : }
370 : :
371 : 0 : *buffer = view.buf;
372 : 0 : *buffer_len = view.len;
373 : 0 : PyBuffer_Release(&view);
374 : 0 : return 0;
375 : : }
376 : :
377 : : /* Buffer C-API for Python 3.0 */
378 : :
379 : : int
380 : 25891554 : PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags)
381 : : {
382 : 25891554 : PyBufferProcs *pb = Py_TYPE(obj)->tp_as_buffer;
383 : :
384 [ + + + + ]: 25891554 : if (pb == NULL || pb->bf_getbuffer == NULL) {
385 : 23471 : PyErr_Format(PyExc_TypeError,
386 : : "a bytes-like object is required, not '%.100s'",
387 : 23471 : Py_TYPE(obj)->tp_name);
388 : 23471 : return -1;
389 : : }
390 : 25868083 : int res = (*pb->bf_getbuffer)(obj, view, flags);
391 : : assert(_Py_CheckSlotResult(obj, "getbuffer", res >= 0));
392 : 25868083 : return res;
393 : : }
394 : :
395 : : static int
396 : 999226 : _IsFortranContiguous(const Py_buffer *view)
397 : : {
398 : : Py_ssize_t sd, dim;
399 : : int i;
400 : :
401 : : /* 1) len = product(shape) * itemsize
402 : : 2) itemsize > 0
403 : : 3) len = 0 <==> exists i: shape[i] = 0 */
404 [ + + ]: 999226 : if (view->len == 0) return 1;
405 [ + + ]: 998882 : if (view->strides == NULL) { /* C-contiguous by definition */
406 : : /* Trivially F-contiguous */
407 [ + + ]: 6863 : if (view->ndim <= 1) return 1;
408 : :
409 : : /* ndim > 1 implies shape != NULL */
410 : : assert(view->shape != NULL);
411 : :
412 : : /* Effectively 1-d */
413 : 982 : sd = 0;
414 [ + + ]: 3610 : for (i=0; i<view->ndim; i++) {
415 [ + + ]: 2628 : if (view->shape[i] > 1) sd += 1;
416 : : }
417 : 982 : return sd <= 1;
418 : : }
419 : :
420 : : /* strides != NULL implies both of these */
421 : : assert(view->ndim > 0);
422 : : assert(view->shape != NULL);
423 : :
424 : 992019 : sd = view->itemsize;
425 [ + + ]: 2012309 : for (i=0; i<view->ndim; i++) {
426 : 1485041 : dim = view->shape[i];
427 [ + + + + ]: 1485041 : if (dim > 1 && view->strides[i] != sd) {
428 : 464751 : return 0;
429 : : }
430 : 1020290 : sd *= dim;
431 : : }
432 : 527268 : return 1;
433 : : }
434 : :
435 : : static int
436 : 12510566 : _IsCContiguous(const Py_buffer *view)
437 : : {
438 : : Py_ssize_t sd, dim;
439 : : int i;
440 : :
441 : : /* 1) len = product(shape) * itemsize
442 : : 2) itemsize > 0
443 : : 3) len = 0 <==> exists i: shape[i] = 0 */
444 [ + + ]: 12510566 : if (view->len == 0) return 1;
445 [ + + ]: 12197664 : if (view->strides == NULL) return 1; /* C-contiguous by definition */
446 : :
447 : : /* strides != NULL implies both of these */
448 : : assert(view->ndim > 0);
449 : : assert(view->shape != NULL);
450 : :
451 : 1323536 : sd = view->itemsize;
452 [ + + ]: 2839300 : for (i=view->ndim-1; i>=0; i--) {
453 : 1977334 : dim = view->shape[i];
454 [ + + + + ]: 1977334 : if (dim > 1 && view->strides[i] != sd) {
455 : 461570 : return 0;
456 : : }
457 : 1515764 : sd *= dim;
458 : : }
459 : 861966 : return 1;
460 : : }
461 : :
462 : : int
463 : 13939922 : PyBuffer_IsContiguous(const Py_buffer *view, char order)
464 : : {
465 : :
466 [ + + ]: 13939922 : if (view->suboffsets != NULL) return 0;
467 : :
468 [ + + ]: 13461693 : if (order == 'C')
469 : 12429832 : return _IsCContiguous(view);
470 [ + + ]: 1031861 : else if (order == 'F')
471 : 951127 : return _IsFortranContiguous(view);
472 [ + - ]: 80734 : else if (order == 'A')
473 [ + + + + ]: 80734 : return (_IsCContiguous(view) || _IsFortranContiguous(view));
474 : 0 : return 0;
475 : : }
476 : :
477 : :
478 : : void*
479 : 89035 : PyBuffer_GetPointer(const Py_buffer *view, const Py_ssize_t *indices)
480 : : {
481 : : char* pointer;
482 : : int i;
483 : 89035 : pointer = (char *)view->buf;
484 [ + + ]: 246968 : for (i = 0; i < view->ndim; i++) {
485 : 157933 : pointer += view->strides[i]*indices[i];
486 [ + + + + ]: 157933 : if ((view->suboffsets != NULL) && (view->suboffsets[i] >= 0)) {
487 : 26553 : pointer = *((char**)pointer) + view->suboffsets[i];
488 : : }
489 : : }
490 : 89035 : return (void*)pointer;
491 : : }
492 : :
493 : :
494 : : void
495 : 0 : _Py_add_one_to_index_F(int nd, Py_ssize_t *index, const Py_ssize_t *shape)
496 : : {
497 : : int k;
498 : :
499 [ # # ]: 0 : for (k=0; k<nd; k++) {
500 [ # # ]: 0 : if (index[k] < shape[k]-1) {
501 : 0 : index[k]++;
502 : 0 : break;
503 : : }
504 : : else {
505 : 0 : index[k] = 0;
506 : : }
507 : : }
508 : 0 : }
509 : :
510 : : void
511 : 10 : _Py_add_one_to_index_C(int nd, Py_ssize_t *index, const Py_ssize_t *shape)
512 : : {
513 : : int k;
514 : :
515 [ + + ]: 12 : for (k=nd-1; k>=0; k--) {
516 [ + + ]: 10 : if (index[k] < shape[k]-1) {
517 : 8 : index[k]++;
518 : 8 : break;
519 : : }
520 : : else {
521 : 2 : index[k] = 0;
522 : : }
523 : : }
524 : 10 : }
525 : :
526 : : Py_ssize_t
527 : 3 : PyBuffer_SizeFromFormat(const char *format)
528 : : {
529 : 3 : PyObject *calcsize = NULL;
530 : 3 : PyObject *res = NULL;
531 : 3 : PyObject *fmt = NULL;
532 : 3 : Py_ssize_t itemsize = -1;
533 : :
534 : 3 : calcsize = _PyImport_GetModuleAttrString("struct", "calcsize");
535 [ - + ]: 3 : if (calcsize == NULL) {
536 : 0 : goto done;
537 : : }
538 : :
539 : 3 : fmt = PyUnicode_FromString(format);
540 [ - + ]: 3 : if (fmt == NULL) {
541 : 0 : goto done;
542 : : }
543 : :
544 : 3 : res = PyObject_CallFunctionObjArgs(calcsize, fmt, NULL);
545 [ - + ]: 3 : if (res == NULL) {
546 : 0 : goto done;
547 : : }
548 : :
549 : 3 : itemsize = PyLong_AsSsize_t(res);
550 [ + - ]: 3 : if (itemsize < 0) {
551 : 0 : goto done;
552 : : }
553 : :
554 : 3 : done:
555 : 3 : Py_XDECREF(calcsize);
556 : 3 : Py_XDECREF(fmt);
557 : 3 : Py_XDECREF(res);
558 : 3 : return itemsize;
559 : : }
560 : :
561 : : int
562 : 2 : PyBuffer_FromContiguous(const Py_buffer *view, const void *buf, Py_ssize_t len, char fort)
563 : : {
564 : : int k;
565 : : void (*addone)(int, Py_ssize_t *, const Py_ssize_t *);
566 : : Py_ssize_t *indices, elements;
567 : : char *ptr;
568 : : const char *src;
569 : :
570 [ - + ]: 2 : if (len > view->len) {
571 : 0 : len = view->len;
572 : : }
573 : :
574 [ - + ]: 2 : if (PyBuffer_IsContiguous(view, fort)) {
575 : : /* simplest copy is all that is needed */
576 : 0 : memcpy(view->buf, buf, len);
577 : 0 : return 0;
578 : : }
579 : :
580 : : /* Otherwise a more elaborate scheme is needed */
581 : :
582 : : /* view->ndim <= 64 */
583 : 2 : indices = (Py_ssize_t *)PyMem_Malloc(sizeof(Py_ssize_t)*(view->ndim));
584 [ - + ]: 2 : if (indices == NULL) {
585 : : PyErr_NoMemory();
586 : 0 : return -1;
587 : : }
588 [ + + ]: 4 : for (k=0; k<view->ndim;k++) {
589 : 2 : indices[k] = 0;
590 : : }
591 : :
592 [ - + ]: 2 : if (fort == 'F') {
593 : 0 : addone = _Py_add_one_to_index_F;
594 : : }
595 : : else {
596 : 2 : addone = _Py_add_one_to_index_C;
597 : : }
598 : 2 : src = buf;
599 : : /* XXX : This is not going to be the fastest code in the world
600 : : several optimizations are possible.
601 : : */
602 : 2 : elements = len / view->itemsize;
603 [ + + ]: 12 : while (elements--) {
604 : 10 : ptr = PyBuffer_GetPointer(view, indices);
605 : 10 : memcpy(ptr, src, view->itemsize);
606 : 10 : src += view->itemsize;
607 : 10 : addone(view->ndim, indices, view->shape);
608 : : }
609 : :
610 : 2 : PyMem_Free(indices);
611 : 2 : return 0;
612 : : }
613 : :
614 : 0 : int PyObject_CopyData(PyObject *dest, PyObject *src)
615 : : {
616 : : Py_buffer view_dest, view_src;
617 : : int k;
618 : : Py_ssize_t *indices, elements;
619 : : char *dptr, *sptr;
620 : :
621 [ # # # # ]: 0 : if (!PyObject_CheckBuffer(dest) ||
622 : 0 : !PyObject_CheckBuffer(src)) {
623 : 0 : PyErr_SetString(PyExc_TypeError,
624 : : "both destination and source must be "\
625 : : "bytes-like objects");
626 : 0 : return -1;
627 : : }
628 : :
629 [ # # ]: 0 : if (PyObject_GetBuffer(dest, &view_dest, PyBUF_FULL) != 0) return -1;
630 [ # # ]: 0 : if (PyObject_GetBuffer(src, &view_src, PyBUF_FULL_RO) != 0) {
631 : 0 : PyBuffer_Release(&view_dest);
632 : 0 : return -1;
633 : : }
634 : :
635 [ # # ]: 0 : if (view_dest.len < view_src.len) {
636 : 0 : PyErr_SetString(PyExc_BufferError,
637 : : "destination is too small to receive data from source");
638 : 0 : PyBuffer_Release(&view_dest);
639 : 0 : PyBuffer_Release(&view_src);
640 : 0 : return -1;
641 : : }
642 : :
643 [ # # # # ]: 0 : if ((PyBuffer_IsContiguous(&view_dest, 'C') &&
644 [ # # ]: 0 : PyBuffer_IsContiguous(&view_src, 'C')) ||
645 [ # # ]: 0 : (PyBuffer_IsContiguous(&view_dest, 'F') &&
646 : 0 : PyBuffer_IsContiguous(&view_src, 'F'))) {
647 : : /* simplest copy is all that is needed */
648 : 0 : memcpy(view_dest.buf, view_src.buf, view_src.len);
649 : 0 : PyBuffer_Release(&view_dest);
650 : 0 : PyBuffer_Release(&view_src);
651 : 0 : return 0;
652 : : }
653 : :
654 : : /* Otherwise a more elaborate copy scheme is needed */
655 : :
656 : : /* XXX(nnorwitz): need to check for overflow! */
657 : 0 : indices = (Py_ssize_t *)PyMem_Malloc(sizeof(Py_ssize_t)*view_src.ndim);
658 [ # # ]: 0 : if (indices == NULL) {
659 : : PyErr_NoMemory();
660 : 0 : PyBuffer_Release(&view_dest);
661 : 0 : PyBuffer_Release(&view_src);
662 : 0 : return -1;
663 : : }
664 [ # # ]: 0 : for (k=0; k<view_src.ndim;k++) {
665 : 0 : indices[k] = 0;
666 : : }
667 : 0 : elements = 1;
668 [ # # ]: 0 : for (k=0; k<view_src.ndim; k++) {
669 : : /* XXX(nnorwitz): can this overflow? */
670 : 0 : elements *= view_src.shape[k];
671 : : }
672 [ # # ]: 0 : while (elements--) {
673 : 0 : _Py_add_one_to_index_C(view_src.ndim, indices, view_src.shape);
674 : 0 : dptr = PyBuffer_GetPointer(&view_dest, indices);
675 : 0 : sptr = PyBuffer_GetPointer(&view_src, indices);
676 : 0 : memcpy(dptr, sptr, view_src.itemsize);
677 : : }
678 : 0 : PyMem_Free(indices);
679 : 0 : PyBuffer_Release(&view_dest);
680 : 0 : PyBuffer_Release(&view_src);
681 : 0 : return 0;
682 : : }
683 : :
684 : : void
685 : 0 : PyBuffer_FillContiguousStrides(int nd, Py_ssize_t *shape,
686 : : Py_ssize_t *strides, int itemsize,
687 : : char fort)
688 : : {
689 : : int k;
690 : : Py_ssize_t sd;
691 : :
692 : 0 : sd = itemsize;
693 [ # # ]: 0 : if (fort == 'F') {
694 [ # # ]: 0 : for (k=0; k<nd; k++) {
695 : 0 : strides[k] = sd;
696 : 0 : sd *= shape[k];
697 : : }
698 : : }
699 : : else {
700 [ # # ]: 0 : for (k=nd-1; k>=0; k--) {
701 : 0 : strides[k] = sd;
702 : 0 : sd *= shape[k];
703 : : }
704 : : }
705 : 0 : return;
706 : : }
707 : :
708 : : int
709 : 21699652 : PyBuffer_FillInfo(Py_buffer *view, PyObject *obj, void *buf, Py_ssize_t len,
710 : : int readonly, int flags)
711 : : {
712 [ + + ]: 21699652 : if (view == NULL) {
713 : 1 : PyErr_SetString(PyExc_BufferError,
714 : : "PyBuffer_FillInfo: view==NULL argument is obsolete");
715 : 1 : return -1;
716 : : }
717 : :
718 [ + + + + ]: 21699651 : if (((flags & PyBUF_WRITABLE) == PyBUF_WRITABLE) &&
719 : : (readonly == 1)) {
720 : 16 : PyErr_SetString(PyExc_BufferError,
721 : : "Object is not writable.");
722 : 16 : return -1;
723 : : }
724 : :
725 : 21699635 : view->obj = obj;
726 [ + + ]: 21699635 : if (obj)
727 : 20627591 : Py_INCREF(obj);
728 : 21699635 : view->buf = buf;
729 : 21699635 : view->len = len;
730 : 21699635 : view->readonly = readonly;
731 : 21699635 : view->itemsize = 1;
732 : 21699635 : view->format = NULL;
733 [ + + ]: 21699635 : if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT)
734 : 936213 : view->format = "B";
735 : 21699635 : view->ndim = 1;
736 : 21699635 : view->shape = NULL;
737 [ + + ]: 21699635 : if ((flags & PyBUF_ND) == PyBUF_ND)
738 : 5394279 : view->shape = &(view->len);
739 : 21699635 : view->strides = NULL;
740 [ + + ]: 21699635 : if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES)
741 : 936213 : view->strides = &(view->itemsize);
742 : 21699635 : view->suboffsets = NULL;
743 : 21699635 : view->internal = NULL;
744 : 21699635 : return 0;
745 : : }
746 : :
747 : : void
748 : 28578553 : PyBuffer_Release(Py_buffer *view)
749 : : {
750 : 28578553 : PyObject *obj = view->obj;
751 : : PyBufferProcs *pb;
752 [ + + ]: 28578553 : if (obj == NULL)
753 : 1437978 : return;
754 : 27140575 : pb = Py_TYPE(obj)->tp_as_buffer;
755 [ + + + + ]: 27140575 : if (pb && pb->bf_releasebuffer) {
756 : 6820473 : pb->bf_releasebuffer(obj, view);
757 : : }
758 : 27140575 : view->obj = NULL;
759 : 27140575 : Py_DECREF(obj);
760 : : }
761 : :
762 : : PyObject *
763 : 4024727 : PyObject_Format(PyObject *obj, PyObject *format_spec)
764 : : {
765 : : PyObject *meth;
766 : 4024727 : PyObject *empty = NULL;
767 : 4024727 : PyObject *result = NULL;
768 : :
769 [ + + - + ]: 4024727 : if (format_spec != NULL && !PyUnicode_Check(format_spec)) {
770 : 0 : PyErr_Format(PyExc_SystemError,
771 : : "Format specifier must be a string, not %.200s",
772 : 0 : Py_TYPE(format_spec)->tp_name);
773 : 0 : return NULL;
774 : : }
775 : :
776 : : /* Fast path for common types. */
777 [ + + + + ]: 4024727 : if (format_spec == NULL || PyUnicode_GET_LENGTH(format_spec) == 0) {
778 [ + + ]: 364726 : if (PyUnicode_CheckExact(obj)) {
779 : 216 : Py_INCREF(obj);
780 : 216 : return obj;
781 : : }
782 [ + + ]: 364510 : if (PyLong_CheckExact(obj)) {
783 : 348679 : return PyObject_Str(obj);
784 : : }
785 : : }
786 : :
787 : : /* If no format_spec is provided, use an empty string */
788 [ + + ]: 3675832 : if (format_spec == NULL) {
789 : 14967 : empty = PyUnicode_New(0, 0);
790 : 14967 : format_spec = empty;
791 : : }
792 : :
793 : : /* Find the (unbound!) __format__ method */
794 : 3675832 : meth = _PyObject_LookupSpecial(obj, &_Py_ID(__format__));
795 [ + + ]: 3675832 : if (meth == NULL) {
796 : 1 : PyThreadState *tstate = _PyThreadState_GET();
797 [ - + ]: 1 : if (!_PyErr_Occurred(tstate)) {
798 : 0 : _PyErr_Format(tstate, PyExc_TypeError,
799 : : "Type %.100s doesn't define __format__",
800 : 0 : Py_TYPE(obj)->tp_name);
801 : : }
802 : 1 : goto done;
803 : : }
804 : :
805 : : /* And call it. */
806 : 3675831 : result = PyObject_CallOneArg(meth, format_spec);
807 : 3675831 : Py_DECREF(meth);
808 : :
809 [ + + + + ]: 3675831 : if (result && !PyUnicode_Check(result)) {
810 : 1 : PyErr_Format(PyExc_TypeError,
811 : : "__format__ must return a str, not %.200s",
812 : 1 : Py_TYPE(result)->tp_name);
813 : 1 : Py_DECREF(result);
814 : 1 : result = NULL;
815 : 1 : goto done;
816 : : }
817 : :
818 : 3675830 : done:
819 : 3675832 : Py_XDECREF(empty);
820 : 3675832 : return result;
821 : : }
822 : : /* Operations on numbers */
823 : :
824 : : int
825 : 1385851 : PyNumber_Check(PyObject *o)
826 : : {
827 [ - + ]: 1385851 : if (o == NULL)
828 : 0 : return 0;
829 : 1385851 : PyNumberMethods *nb = Py_TYPE(o)->tp_as_number;
830 [ + + + + : 1385851 : return nb && (nb->nb_index || nb->nb_int || nb->nb_float || PyComplex_Check(o));
+ + + - +
+ ]
831 : : }
832 : :
833 : : /* Binary operators */
834 : :
835 : : #define NB_SLOT(x) offsetof(PyNumberMethods, x)
836 : : #define NB_BINOP(nb_methods, slot) \
837 : : (*(binaryfunc*)(& ((char*)nb_methods)[slot]))
838 : : #define NB_TERNOP(nb_methods, slot) \
839 : : (*(ternaryfunc*)(& ((char*)nb_methods)[slot]))
840 : :
841 : : /*
842 : : Calling scheme used for binary operations:
843 : :
844 : : Order operations are tried until either a valid result or error:
845 : : w.op(v,w)[*], v.op(v,w), w.op(v,w)
846 : :
847 : : [*] only when Py_TYPE(v) != Py_TYPE(w) && Py_TYPE(w) is a subclass of
848 : : Py_TYPE(v)
849 : : */
850 : :
851 : : static PyObject *
852 : 60126009 : binary_op1(PyObject *v, PyObject *w, const int op_slot
853 : : #ifndef NDEBUG
854 : : , const char *op_name
855 : : #endif
856 : : )
857 : : {
858 : : binaryfunc slotv;
859 [ + + ]: 60126009 : if (Py_TYPE(v)->tp_as_number != NULL) {
860 : 59206634 : slotv = NB_BINOP(Py_TYPE(v)->tp_as_number, op_slot);
861 : : }
862 : : else {
863 : 919375 : slotv = NULL;
864 : : }
865 : :
866 : : binaryfunc slotw;
867 [ + + + + ]: 60126009 : if (!Py_IS_TYPE(w, Py_TYPE(v)) && Py_TYPE(w)->tp_as_number != NULL) {
868 : 6097196 : slotw = NB_BINOP(Py_TYPE(w)->tp_as_number, op_slot);
869 [ + + ]: 6097196 : if (slotw == slotv) {
870 : 1030811 : slotw = NULL;
871 : : }
872 : : }
873 : : else {
874 : 54028813 : slotw = NULL;
875 : : }
876 : :
877 [ + + ]: 60126009 : if (slotv) {
878 : : PyObject *x;
879 [ + + + + ]: 52540679 : if (slotw && PyType_IsSubtype(Py_TYPE(w), Py_TYPE(v))) {
880 : 265723 : x = slotw(v, w);
881 [ + - ]: 265723 : if (x != Py_NotImplemented)
882 : 265723 : return x;
883 : 0 : Py_DECREF(x); /* can't do it */
884 : 0 : slotw = NULL;
885 : : }
886 : 52274956 : x = slotv(v, w);
887 : : assert(_Py_CheckSlotResult(v, op_name, x != NULL));
888 [ + + ]: 52274956 : if (x != Py_NotImplemented) {
889 : 50706833 : return x;
890 : : }
891 : 1568123 : Py_DECREF(x); /* can't do it */
892 : : }
893 [ + + ]: 9153453 : if (slotw) {
894 : 3251103 : PyObject *x = slotw(v, w);
895 : : assert(_Py_CheckSlotResult(w, op_name, x != NULL));
896 [ + + ]: 3251103 : if (x != Py_NotImplemented) {
897 : 1476837 : return x;
898 : : }
899 : 1774266 : Py_DECREF(x); /* can't do it */
900 : : }
901 : 7676616 : Py_RETURN_NOTIMPLEMENTED;
902 : : }
903 : :
904 : : #ifdef NDEBUG
905 : : # define BINARY_OP1(v, w, op_slot, op_name) binary_op1(v, w, op_slot)
906 : : #else
907 : : # define BINARY_OP1(v, w, op_slot, op_name) binary_op1(v, w, op_slot, op_name)
908 : : #endif
909 : :
910 : : static PyObject *
911 : 691 : binop_type_error(PyObject *v, PyObject *w, const char *op_name)
912 : : {
913 : 691 : PyErr_Format(PyExc_TypeError,
914 : : "unsupported operand type(s) for %.100s: "
915 : : "'%.100s' and '%.100s'",
916 : : op_name,
917 : 691 : Py_TYPE(v)->tp_name,
918 : 691 : Py_TYPE(w)->tp_name);
919 : 691 : return NULL;
920 : : }
921 : :
922 : : static PyObject *
923 : 30067171 : binary_op(PyObject *v, PyObject *w, const int op_slot, const char *op_name)
924 : : {
925 : 30067171 : PyObject *result = BINARY_OP1(v, w, op_slot, op_name);
926 [ + + ]: 30067171 : if (result == Py_NotImplemented) {
927 : 304 : Py_DECREF(result);
928 : :
929 [ + + + + ]: 325 : if (op_slot == NB_SLOT(nb_rshift) &&
930 : 21 : PyCFunction_CheckExact(v) &&
931 [ + + ]: 3 : strcmp(((PyCFunctionObject *)v)->m_ml->ml_name, "print") == 0)
932 : : {
933 : 2 : PyErr_Format(PyExc_TypeError,
934 : : "unsupported operand type(s) for %.100s: "
935 : : "'%.100s' and '%.100s'. Did you mean \"print(<message>, "
936 : : "file=<output_stream>)\"?",
937 : : op_name,
938 : 2 : Py_TYPE(v)->tp_name,
939 : 2 : Py_TYPE(w)->tp_name);
940 : 2 : return NULL;
941 : : }
942 : 302 : return binop_type_error(v, w, op_name);
943 : : }
944 : 30066867 : return result;
945 : : }
946 : :
947 : :
948 : : /*
949 : : Calling scheme used for ternary operations:
950 : :
951 : : Order operations are tried until either a valid result or error:
952 : : v.op(v,w,z), w.op(v,w,z), z.op(v,w,z)
953 : : */
954 : :
955 : : static PyObject *
956 : 1825286 : ternary_op(PyObject *v,
957 : : PyObject *w,
958 : : PyObject *z,
959 : : const int op_slot,
960 : : const char *op_name
961 : : )
962 : : {
963 : 1825286 : PyNumberMethods *mv = Py_TYPE(v)->tp_as_number;
964 : 1825286 : PyNumberMethods *mw = Py_TYPE(w)->tp_as_number;
965 : :
966 : : ternaryfunc slotv;
967 [ + + ]: 1825286 : if (mv != NULL) {
968 : 1825285 : slotv = NB_TERNOP(mv, op_slot);
969 : : }
970 : : else {
971 : 1 : slotv = NULL;
972 : : }
973 : :
974 : : ternaryfunc slotw;
975 [ + + + - ]: 1825286 : if (!Py_IS_TYPE(w, Py_TYPE(v)) && mw != NULL) {
976 : 358458 : slotw = NB_TERNOP(mw, op_slot);
977 [ + + ]: 358458 : if (slotw == slotv) {
978 : 16 : slotw = NULL;
979 : : }
980 : : }
981 : : else {
982 : 1466828 : slotw = NULL;
983 : : }
984 : :
985 [ + + ]: 1825286 : if (slotv) {
986 : : PyObject *x;
987 [ + + + + ]: 1825276 : if (slotw && PyType_IsSubtype(Py_TYPE(w), Py_TYPE(v))) {
988 : 1 : x = slotw(v, w, z);
989 [ + - ]: 1 : if (x != Py_NotImplemented) {
990 : 1 : return x;
991 : : }
992 : 0 : Py_DECREF(x); /* can't do it */
993 : 0 : slotw = NULL;
994 : : }
995 : 1825275 : x = slotv(v, w, z);
996 : : assert(_Py_CheckSlotResult(v, op_name, x != NULL));
997 [ + + ]: 1825275 : if (x != Py_NotImplemented) {
998 : 1825141 : return x;
999 : : }
1000 : 134 : Py_DECREF(x); /* can't do it */
1001 : : }
1002 [ + + ]: 144 : if (slotw) {
1003 : 139 : PyObject *x = slotw(v, w, z);
1004 : : assert(_Py_CheckSlotResult(w, op_name, x != NULL));
1005 [ + + ]: 139 : if (x != Py_NotImplemented) {
1006 : 128 : return x;
1007 : : }
1008 : 11 : Py_DECREF(x); /* can't do it */
1009 : : }
1010 : :
1011 : 16 : PyNumberMethods *mz = Py_TYPE(z)->tp_as_number;
1012 [ + - ]: 16 : if (mz != NULL) {
1013 : 16 : ternaryfunc slotz = NB_TERNOP(mz, op_slot);
1014 [ + + + + ]: 16 : if (slotz == slotv || slotz == slotw) {
1015 : 10 : slotz = NULL;
1016 : : }
1017 [ + + ]: 16 : if (slotz) {
1018 : 1 : PyObject *x = slotz(v, w, z);
1019 : : assert(_Py_CheckSlotResult(z, op_name, x != NULL));
1020 [ + - ]: 1 : if (x != Py_NotImplemented) {
1021 : 1 : return x;
1022 : : }
1023 : 0 : Py_DECREF(x); /* can't do it */
1024 : : }
1025 : : }
1026 : :
1027 [ + + ]: 15 : if (z == Py_None) {
1028 : 13 : PyErr_Format(
1029 : : PyExc_TypeError,
1030 : : "unsupported operand type(s) for %.100s: "
1031 : : "'%.100s' and '%.100s'",
1032 : : op_name,
1033 : 13 : Py_TYPE(v)->tp_name,
1034 : 13 : Py_TYPE(w)->tp_name);
1035 : : }
1036 : : else {
1037 : 2 : PyErr_Format(
1038 : : PyExc_TypeError,
1039 : : "unsupported operand type(s) for %.100s: "
1040 : : "'%.100s', '%.100s', '%.100s'",
1041 : : op_name,
1042 : 2 : Py_TYPE(v)->tp_name,
1043 : 2 : Py_TYPE(w)->tp_name,
1044 : 2 : Py_TYPE(z)->tp_name);
1045 : : }
1046 : 15 : return NULL;
1047 : : }
1048 : :
1049 : : #define BINARY_FUNC(func, op, op_name) \
1050 : : PyObject * \
1051 : : func(PyObject *v, PyObject *w) { \
1052 : : return binary_op(v, w, NB_SLOT(op), op_name); \
1053 : : }
1054 : :
1055 : 1464194 : BINARY_FUNC(PyNumber_Or, nb_or, "|")
1056 : 390134 : BINARY_FUNC(PyNumber_Xor, nb_xor, "^")
1057 : 7297698 : BINARY_FUNC(PyNumber_And, nb_and, "&")
1058 : 879746 : BINARY_FUNC(PyNumber_Lshift, nb_lshift, "<<")
1059 : 1443203 : BINARY_FUNC(PyNumber_Rshift, nb_rshift, ">>")
1060 : 4563422 : BINARY_FUNC(PyNumber_Subtract, nb_subtract, "-")
1061 : 1447687 : BINARY_FUNC(PyNumber_Divmod, nb_divmod, "divmod()")
1062 : :
1063 : : PyObject *
1064 : 15448988 : PyNumber_Add(PyObject *v, PyObject *w)
1065 : : {
1066 : 15448988 : PyObject *result = BINARY_OP1(v, w, NB_SLOT(nb_add), "+");
1067 [ + + ]: 15448988 : if (result != Py_NotImplemented) {
1068 : 10044099 : return result;
1069 : : }
1070 : 5404889 : Py_DECREF(result);
1071 : :
1072 : 5404889 : PySequenceMethods *m = Py_TYPE(v)->tp_as_sequence;
1073 [ + + + + ]: 5404889 : if (m && m->sq_concat) {
1074 : 5404631 : result = (*m->sq_concat)(v, w);
1075 : : assert(_Py_CheckSlotResult(v, "+", result != NULL));
1076 : 5404631 : return result;
1077 : : }
1078 : :
1079 : 258 : return binop_type_error(v, w, "+");
1080 : : }
1081 : :
1082 : : static PyObject *
1083 : 1864797 : sequence_repeat(ssizeargfunc repeatfunc, PyObject *seq, PyObject *n)
1084 : : {
1085 : : Py_ssize_t count;
1086 [ + + ]: 1864797 : if (_PyIndex_Check(n)) {
1087 : 1864781 : count = PyNumber_AsSsize_t(n, PyExc_OverflowError);
1088 [ + + + + ]: 1864781 : if (count == -1 && PyErr_Occurred()) {
1089 : 2 : return NULL;
1090 : : }
1091 : : }
1092 : : else {
1093 : 16 : return type_error("can't multiply sequence by "
1094 : : "non-int of type '%.200s'", n);
1095 : : }
1096 : 1864779 : PyObject *res = (*repeatfunc)(seq, count);
1097 : : assert(_Py_CheckSlotResult(seq, "*", res != NULL));
1098 : 1864779 : return res;
1099 : : }
1100 : :
1101 : : PyObject *
1102 : 9503191 : PyNumber_Multiply(PyObject *v, PyObject *w)
1103 : : {
1104 : 9503191 : PyObject *result = BINARY_OP1(v, w, NB_SLOT(nb_multiply), "*");
1105 [ + + ]: 9503191 : if (result == Py_NotImplemented) {
1106 : 1864151 : PySequenceMethods *mv = Py_TYPE(v)->tp_as_sequence;
1107 : 1864151 : PySequenceMethods *mw = Py_TYPE(w)->tp_as_sequence;
1108 : 1864151 : Py_DECREF(result);
1109 [ + + + + ]: 1864151 : if (mv && mv->sq_repeat) {
1110 : 1773721 : return sequence_repeat(mv->sq_repeat, v, w);
1111 : : }
1112 [ + + + + ]: 90430 : else if (mw && mw->sq_repeat) {
1113 : 90397 : return sequence_repeat(mw->sq_repeat, w, v);
1114 : : }
1115 : 33 : result = binop_type_error(v, w, "*");
1116 : : }
1117 : 7639073 : return result;
1118 : : }
1119 : :
1120 : : PyObject *
1121 : 22 : PyNumber_MatrixMultiply(PyObject *v, PyObject *w)
1122 : : {
1123 : 22 : return binary_op(v, w, NB_SLOT(nb_matrix_multiply), "@");
1124 : : }
1125 : :
1126 : : PyObject *
1127 : 3345071 : PyNumber_FloorDivide(PyObject *v, PyObject *w)
1128 : : {
1129 : 3345071 : return binary_op(v, w, NB_SLOT(nb_floor_divide), "//");
1130 : : }
1131 : :
1132 : : PyObject *
1133 : 6400256 : PyNumber_TrueDivide(PyObject *v, PyObject *w)
1134 : : {
1135 : 6400256 : return binary_op(v, w, NB_SLOT(nb_true_divide), "/");
1136 : : }
1137 : :
1138 : : PyObject *
1139 : 2835738 : PyNumber_Remainder(PyObject *v, PyObject *w)
1140 : : {
1141 : 2835738 : return binary_op(v, w, NB_SLOT(nb_remainder), "%");
1142 : : }
1143 : :
1144 : : PyObject *
1145 : 1825269 : PyNumber_Power(PyObject *v, PyObject *w, PyObject *z)
1146 : : {
1147 : 1825269 : return ternary_op(v, w, z, NB_SLOT(nb_power), "** or pow()");
1148 : : }
1149 : :
1150 : : PyObject *
1151 : 1695877 : _PyNumber_PowerNoMod(PyObject *lhs, PyObject *rhs)
1152 : : {
1153 : 1695877 : return PyNumber_Power(lhs, rhs, Py_None);
1154 : : }
1155 : :
1156 : : /* Binary in-place operators */
1157 : :
1158 : : /* The in-place operators are defined to fall back to the 'normal',
1159 : : non in-place operations, if the in-place methods are not in place.
1160 : :
1161 : : - If the left hand object has the appropriate struct members, and
1162 : : they are filled, call the appropriate function and return the
1163 : : result. No coercion is done on the arguments; the left-hand object
1164 : : is the one the operation is performed on, and it's up to the
1165 : : function to deal with the right-hand object.
1166 : :
1167 : : - Otherwise, in-place modification is not supported. Handle it exactly as
1168 : : a non in-place operation of the same kind.
1169 : :
1170 : : */
1171 : :
1172 : : static PyObject *
1173 : 7513122 : binary_iop1(PyObject *v, PyObject *w, const int iop_slot, const int op_slot
1174 : : #ifndef NDEBUG
1175 : : , const char *op_name
1176 : : #endif
1177 : : )
1178 : : {
1179 : 7513122 : PyNumberMethods *mv = Py_TYPE(v)->tp_as_number;
1180 [ + + ]: 7513122 : if (mv != NULL) {
1181 : 7271479 : binaryfunc slot = NB_BINOP(mv, iop_slot);
1182 [ + + ]: 7271479 : if (slot) {
1183 : 2406525 : PyObject *x = (slot)(v, w);
1184 : : assert(_Py_CheckSlotResult(v, op_name, x != NULL));
1185 [ + + ]: 2406525 : if (x != Py_NotImplemented) {
1186 : 2406465 : return x;
1187 : : }
1188 : 60 : Py_DECREF(x);
1189 : : }
1190 : : }
1191 : : #ifdef NDEBUG
1192 : 5106657 : return binary_op1(v, w, op_slot);
1193 : : #else
1194 : : return binary_op1(v, w, op_slot, op_name);
1195 : : #endif
1196 : : }
1197 : :
1198 : : #ifdef NDEBUG
1199 : : # define BINARY_IOP1(v, w, iop_slot, op_slot, op_name) binary_iop1(v, w, iop_slot, op_slot)
1200 : : #else
1201 : : # define BINARY_IOP1(v, w, iop_slot, op_slot, op_name) binary_iop1(v, w, iop_slot, op_slot, op_name)
1202 : : #endif
1203 : :
1204 : : static PyObject *
1205 : 6076335 : binary_iop(PyObject *v, PyObject *w, const int iop_slot, const int op_slot,
1206 : : const char *op_name)
1207 : : {
1208 : 6076335 : PyObject *result = BINARY_IOP1(v, w, iop_slot, op_slot, op_name);
1209 [ + + ]: 6076335 : if (result == Py_NotImplemented) {
1210 : 85 : Py_DECREF(result);
1211 : 85 : return binop_type_error(v, w, op_name);
1212 : : }
1213 : 6076250 : return result;
1214 : : }
1215 : :
1216 : : static PyObject *
1217 : 21 : ternary_iop(PyObject *v, PyObject *w, PyObject *z, const int iop_slot, const int op_slot,
1218 : : const char *op_name)
1219 : : {
1220 : 21 : PyNumberMethods *mv = Py_TYPE(v)->tp_as_number;
1221 [ + + ]: 21 : if (mv != NULL) {
1222 : 20 : ternaryfunc slot = NB_TERNOP(mv, iop_slot);
1223 [ + + ]: 20 : if (slot) {
1224 : 9 : PyObject *x = (slot)(v, w, z);
1225 [ + + ]: 9 : if (x != Py_NotImplemented) {
1226 : 4 : return x;
1227 : : }
1228 : 5 : Py_DECREF(x);
1229 : : }
1230 : : }
1231 : 17 : return ternary_op(v, w, z, op_slot, op_name);
1232 : : }
1233 : :
1234 : : #define INPLACE_BINOP(func, iop, op, op_name) \
1235 : : PyObject * \
1236 : : func(PyObject *v, PyObject *w) { \
1237 : : return binary_iop(v, w, NB_SLOT(iop), NB_SLOT(op), op_name); \
1238 : : }
1239 : :
1240 : 2979685 : INPLACE_BINOP(PyNumber_InPlaceOr, nb_inplace_or, nb_or, "|=")
1241 : 13844 : INPLACE_BINOP(PyNumber_InPlaceXor, nb_inplace_xor, nb_xor, "^=")
1242 : 59121 : INPLACE_BINOP(PyNumber_InPlaceAnd, nb_inplace_and, nb_and, "&=")
1243 : 566584 : INPLACE_BINOP(PyNumber_InPlaceLshift, nb_inplace_lshift, nb_lshift, "<<=")
1244 : 5327 : INPLACE_BINOP(PyNumber_InPlaceRshift, nb_inplace_rshift, nb_rshift, ">>=")
1245 : 44802 : INPLACE_BINOP(PyNumber_InPlaceSubtract, nb_inplace_subtract, nb_subtract, "-=")
1246 : 16 : INPLACE_BINOP(PyNumber_InPlaceMatrixMultiply, nb_inplace_matrix_multiply, nb_matrix_multiply, "@=")
1247 : 307400 : INPLACE_BINOP(PyNumber_InPlaceFloorDivide, nb_inplace_floor_divide, nb_floor_divide, "//=")
1248 : 2098959 : INPLACE_BINOP(PyNumber_InPlaceTrueDivide, nb_inplace_true_divide, nb_true_divide, "/=")
1249 : 597 : INPLACE_BINOP(PyNumber_InPlaceRemainder, nb_inplace_remainder, nb_remainder, "%=")
1250 : :
1251 : : PyObject *
1252 : 1425594 : PyNumber_InPlaceAdd(PyObject *v, PyObject *w)
1253 : : {
1254 : 1425594 : PyObject *result = BINARY_IOP1(v, w, NB_SLOT(nb_inplace_add),
1255 : : NB_SLOT(nb_add), "+=");
1256 [ + + ]: 1425594 : if (result == Py_NotImplemented) {
1257 : 406502 : PySequenceMethods *m = Py_TYPE(v)->tp_as_sequence;
1258 : 406502 : Py_DECREF(result);
1259 [ + - ]: 406502 : if (m != NULL) {
1260 : 406502 : binaryfunc func = m->sq_inplace_concat;
1261 [ + + ]: 406502 : if (func == NULL)
1262 : 210905 : func = m->sq_concat;
1263 [ + + ]: 406502 : if (func != NULL) {
1264 : 406495 : result = func(v, w);
1265 : : assert(_Py_CheckSlotResult(v, "+=", result != NULL));
1266 : 406495 : return result;
1267 : : }
1268 : : }
1269 : 7 : result = binop_type_error(v, w, "+=");
1270 : : }
1271 : 1019099 : return result;
1272 : : }
1273 : :
1274 : : PyObject *
1275 : 11192 : PyNumber_InPlaceMultiply(PyObject *v, PyObject *w)
1276 : : {
1277 : 11192 : PyObject *result = BINARY_IOP1(v, w, NB_SLOT(nb_inplace_multiply),
1278 : : NB_SLOT(nb_multiply), "*=");
1279 [ + + ]: 11192 : if (result == Py_NotImplemented) {
1280 : 685 : ssizeargfunc f = NULL;
1281 : 685 : PySequenceMethods *mv = Py_TYPE(v)->tp_as_sequence;
1282 : 685 : PySequenceMethods *mw = Py_TYPE(w)->tp_as_sequence;
1283 : 685 : Py_DECREF(result);
1284 [ + + ]: 685 : if (mv != NULL) {
1285 : 205 : f = mv->sq_inplace_repeat;
1286 [ + + ]: 205 : if (f == NULL)
1287 : 50 : f = mv->sq_repeat;
1288 [ + + ]: 205 : if (f != NULL)
1289 : 199 : return sequence_repeat(f, v, w);
1290 : : }
1291 [ + - ]: 480 : else if (mw != NULL) {
1292 : : /* Note that the right hand operand should not be
1293 : : * mutated in this case so sq_inplace_repeat is not
1294 : : * used. */
1295 [ + - ]: 480 : if (mw->sq_repeat)
1296 : 480 : return sequence_repeat(mw->sq_repeat, w, v);
1297 : : }
1298 : 6 : result = binop_type_error(v, w, "*=");
1299 : : }
1300 : 10513 : return result;
1301 : : }
1302 : :
1303 : : PyObject *
1304 : 21 : PyNumber_InPlacePower(PyObject *v, PyObject *w, PyObject *z)
1305 : : {
1306 : 21 : return ternary_iop(v, w, z, NB_SLOT(nb_inplace_power),
1307 : : NB_SLOT(nb_power), "**=");
1308 : : }
1309 : :
1310 : : PyObject *
1311 : 20 : _PyNumber_InPlacePowerNoMod(PyObject *lhs, PyObject *rhs)
1312 : : {
1313 : 20 : return PyNumber_InPlacePower(lhs, rhs, Py_None);
1314 : : }
1315 : :
1316 : :
1317 : : /* Unary operators and functions */
1318 : :
1319 : : PyObject *
1320 : 1562863 : PyNumber_Negative(PyObject *o)
1321 : : {
1322 [ - + ]: 1562863 : if (o == NULL) {
1323 : 0 : return null_error();
1324 : : }
1325 : :
1326 : 1562863 : PyNumberMethods *m = Py_TYPE(o)->tp_as_number;
1327 [ + - + + ]: 1562863 : if (m && m->nb_negative) {
1328 : 1562855 : PyObject *res = (*m->nb_negative)(o);
1329 : : assert(_Py_CheckSlotResult(o, "__neg__", res != NULL));
1330 : 1562855 : return res;
1331 : : }
1332 : :
1333 : 8 : return type_error("bad operand type for unary -: '%.200s'", o);
1334 : : }
1335 : :
1336 : : PyObject *
1337 : 605 : PyNumber_Positive(PyObject *o)
1338 : : {
1339 [ - + ]: 605 : if (o == NULL) {
1340 : 0 : return null_error();
1341 : : }
1342 : :
1343 : 605 : PyNumberMethods *m = Py_TYPE(o)->tp_as_number;
1344 [ + - + + ]: 605 : if (m && m->nb_positive) {
1345 : 599 : PyObject *res = (*m->nb_positive)(o);
1346 : : assert(_Py_CheckSlotResult(o, "__pos__", res != NULL));
1347 : 599 : return res;
1348 : : }
1349 : :
1350 : 6 : return type_error("bad operand type for unary +: '%.200s'", o);
1351 : : }
1352 : :
1353 : : PyObject *
1354 : 727897 : PyNumber_Invert(PyObject *o)
1355 : : {
1356 [ - + ]: 727897 : if (o == NULL) {
1357 : 0 : return null_error();
1358 : : }
1359 : :
1360 : 727897 : PyNumberMethods *m = Py_TYPE(o)->tp_as_number;
1361 [ + - + + ]: 727897 : if (m && m->nb_invert) {
1362 : 727886 : PyObject *res = (*m->nb_invert)(o);
1363 : : assert(_Py_CheckSlotResult(o, "__invert__", res != NULL));
1364 : 727886 : return res;
1365 : : }
1366 : :
1367 : 11 : return type_error("bad operand type for unary ~: '%.200s'", o);
1368 : : }
1369 : :
1370 : : PyObject *
1371 : 2894173 : PyNumber_Absolute(PyObject *o)
1372 : : {
1373 [ - + ]: 2894173 : if (o == NULL) {
1374 : 0 : return null_error();
1375 : : }
1376 : :
1377 : 2894173 : PyNumberMethods *m = Py_TYPE(o)->tp_as_number;
1378 [ + - + + ]: 2894173 : if (m && m->nb_absolute) {
1379 : 2894169 : PyObject *res = m->nb_absolute(o);
1380 : : assert(_Py_CheckSlotResult(o, "__abs__", res != NULL));
1381 : 2894169 : return res;
1382 : : }
1383 : :
1384 : 4 : return type_error("bad operand type for abs(): '%.200s'", o);
1385 : : }
1386 : :
1387 : :
1388 : : int
1389 : 9673867 : PyIndex_Check(PyObject *obj)
1390 : : {
1391 : 9673867 : return _PyIndex_Check(obj);
1392 : : }
1393 : :
1394 : :
1395 : : /* Return a Python int from the object item.
1396 : : Can return an instance of int subclass.
1397 : : Raise TypeError if the result is not an int
1398 : : or if the object cannot be interpreted as an index.
1399 : : */
1400 : : PyObject *
1401 : 203420296 : _PyNumber_Index(PyObject *item)
1402 : : {
1403 [ - + ]: 203420296 : if (item == NULL) {
1404 : 0 : return null_error();
1405 : : }
1406 : :
1407 [ + + ]: 203420296 : if (PyLong_Check(item)) {
1408 : 202389852 : Py_INCREF(item);
1409 : 202389852 : return item;
1410 : : }
1411 [ + + ]: 1030444 : if (!_PyIndex_Check(item)) {
1412 : 1027106 : PyErr_Format(PyExc_TypeError,
1413 : : "'%.200s' object cannot be interpreted "
1414 : 1027106 : "as an integer", Py_TYPE(item)->tp_name);
1415 : 1027106 : return NULL;
1416 : : }
1417 : :
1418 : 3338 : PyObject *result = Py_TYPE(item)->tp_as_number->nb_index(item);
1419 : : assert(_Py_CheckSlotResult(item, "__index__", result != NULL));
1420 [ + + + + ]: 3338 : if (!result || PyLong_CheckExact(result)) {
1421 : 2963 : return result;
1422 : : }
1423 : :
1424 [ + + ]: 375 : if (!PyLong_Check(result)) {
1425 : 363 : PyErr_Format(PyExc_TypeError,
1426 : : "__index__ returned non-int (type %.200s)",
1427 : 363 : Py_TYPE(result)->tp_name);
1428 : 363 : Py_DECREF(result);
1429 : 363 : return NULL;
1430 : : }
1431 : : /* Issue #17576: warn if 'result' not of exact type int. */
1432 [ - + ]: 12 : if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
1433 : : "__index__ returned non-int (type %.200s). "
1434 : : "The ability to return an instance of a strict subclass of int "
1435 : : "is deprecated, and may be removed in a future version of Python.",
1436 : 12 : Py_TYPE(result)->tp_name)) {
1437 : 0 : Py_DECREF(result);
1438 : 0 : return NULL;
1439 : : }
1440 : 12 : return result;
1441 : : }
1442 : :
1443 : : /* Return an exact Python int from the object item.
1444 : : Raise TypeError if the result is not an int
1445 : : or if the object cannot be interpreted as an index.
1446 : : */
1447 : : PyObject *
1448 : 8704703 : PyNumber_Index(PyObject *item)
1449 : : {
1450 : 8704703 : PyObject *result = _PyNumber_Index(item);
1451 [ + + + + ]: 8704703 : if (result != NULL && !PyLong_CheckExact(result)) {
1452 : 58 : Py_SETREF(result, _PyLong_Copy((PyLongObject *)result));
1453 : : }
1454 : 8704703 : return result;
1455 : : }
1456 : :
1457 : : /* Return an error on Overflow only if err is not NULL*/
1458 : :
1459 : : Py_ssize_t
1460 : 180339691 : PyNumber_AsSsize_t(PyObject *item, PyObject *err)
1461 : : {
1462 : : Py_ssize_t result;
1463 : : PyObject *runerr;
1464 : 180339691 : PyObject *value = _PyNumber_Index(item);
1465 [ + + ]: 180339691 : if (value == NULL)
1466 : 737085 : return -1;
1467 : :
1468 : : /* We're done if PyLong_AsSsize_t() returns without error. */
1469 : 179602606 : result = PyLong_AsSsize_t(value);
1470 [ + + ]: 179602606 : if (result != -1)
1471 : 164933261 : goto finish;
1472 : :
1473 : 14669345 : PyThreadState *tstate = _PyThreadState_GET();
1474 : 14669345 : runerr = _PyErr_Occurred(tstate);
1475 [ + + ]: 14669345 : if (!runerr) {
1476 : 14666789 : goto finish;
1477 : : }
1478 : :
1479 : : /* Error handling code -- only manage OverflowError differently */
1480 [ - + ]: 2556 : if (!PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) {
1481 : 0 : goto finish;
1482 : : }
1483 : 2556 : _PyErr_Clear(tstate);
1484 : :
1485 : : /* If no error-handling desired then the default clipping
1486 : : is sufficient. */
1487 [ + + ]: 2556 : if (!err) {
1488 : : assert(PyLong_Check(value));
1489 : : /* Whether or not it is less than or equal to
1490 : : zero is determined by the sign of ob_size
1491 : : */
1492 [ + + ]: 2526 : if (_PyLong_Sign(value) < 0)
1493 : 25 : result = PY_SSIZE_T_MIN;
1494 : : else
1495 : 2501 : result = PY_SSIZE_T_MAX;
1496 : : }
1497 : : else {
1498 : : /* Otherwise replace the error with caller's error object. */
1499 : 30 : _PyErr_Format(tstate, err,
1500 : : "cannot fit '%.200s' into an index-sized integer",
1501 : 30 : Py_TYPE(item)->tp_name);
1502 : : }
1503 : :
1504 : 179602606 : finish:
1505 : 179602606 : Py_DECREF(value);
1506 : 179602606 : return result;
1507 : : }
1508 : :
1509 : :
1510 : : PyObject *
1511 : 3348520 : PyNumber_Long(PyObject *o)
1512 : : {
1513 : : PyObject *result;
1514 : : PyNumberMethods *m;
1515 : : PyObject *trunc_func;
1516 : : Py_buffer view;
1517 : :
1518 [ - + ]: 3348520 : if (o == NULL) {
1519 : 0 : return null_error();
1520 : : }
1521 : :
1522 [ + + ]: 3348520 : if (PyLong_CheckExact(o)) {
1523 : 1062057 : Py_INCREF(o);
1524 : 1062057 : return o;
1525 : : }
1526 : 2286463 : m = Py_TYPE(o)->tp_as_number;
1527 [ + + + + ]: 2286463 : if (m && m->nb_int) { /* This should include subclasses of int */
1528 : : /* Convert using the nb_int slot, which should return something
1529 : : of exact type int. */
1530 : 1448391 : result = m->nb_int(o);
1531 : : assert(_Py_CheckSlotResult(o, "__int__", result != NULL));
1532 [ + + + + ]: 1448391 : if (!result || PyLong_CheckExact(result)) {
1533 : 1448388 : return result;
1534 : : }
1535 : :
1536 [ + + ]: 3 : if (!PyLong_Check(result)) {
1537 : 1 : PyErr_Format(PyExc_TypeError,
1538 : : "__int__ returned non-int (type %.200s)",
1539 : 1 : Py_TYPE(result)->tp_name);
1540 : 1 : Py_DECREF(result);
1541 : 1 : return NULL;
1542 : : }
1543 : : /* Issue #17576: warn if 'result' not of exact type int. */
1544 [ - + ]: 2 : if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
1545 : : "__int__ returned non-int (type %.200s). "
1546 : : "The ability to return an instance of a strict subclass of int "
1547 : : "is deprecated, and may be removed in a future version of Python.",
1548 : 2 : Py_TYPE(result)->tp_name)) {
1549 : 0 : Py_DECREF(result);
1550 : 0 : return NULL;
1551 : : }
1552 : 2 : Py_SETREF(result, _PyLong_Copy((PyLongObject *)result));
1553 : 2 : return result;
1554 : : }
1555 [ + + + + ]: 838072 : if (m && m->nb_index) {
1556 : 1 : return PyNumber_Index(o);
1557 : : }
1558 : 838071 : trunc_func = _PyObject_LookupSpecial(o, &_Py_ID(__trunc__));
1559 [ + + ]: 838071 : if (trunc_func) {
1560 [ - + ]: 25 : if (PyErr_WarnEx(PyExc_DeprecationWarning,
1561 : : "The delegation of int() to __trunc__ is deprecated.", 1)) {
1562 : 0 : Py_DECREF(trunc_func);
1563 : 0 : return NULL;
1564 : : }
1565 : 25 : result = _PyObject_CallNoArgs(trunc_func);
1566 : 25 : Py_DECREF(trunc_func);
1567 [ + + + + ]: 25 : if (result == NULL || PyLong_CheckExact(result)) {
1568 : 5 : return result;
1569 : : }
1570 [ + + ]: 20 : if (PyLong_Check(result)) {
1571 : 2 : Py_SETREF(result, _PyLong_Copy((PyLongObject *)result));
1572 : 2 : return result;
1573 : : }
1574 : : /* __trunc__ is specified to return an Integral type,
1575 : : but int() needs to return an int. */
1576 [ + + ]: 18 : if (!PyIndex_Check(result)) {
1577 : 9 : PyErr_Format(
1578 : : PyExc_TypeError,
1579 : : "__trunc__ returned non-Integral (type %.200s)",
1580 : 9 : Py_TYPE(result)->tp_name);
1581 : 9 : Py_DECREF(result);
1582 : 9 : return NULL;
1583 : : }
1584 : 9 : Py_SETREF(result, PyNumber_Index(result));
1585 : 9 : return result;
1586 : : }
1587 [ - + ]: 838046 : if (PyErr_Occurred())
1588 : 0 : return NULL;
1589 : :
1590 [ + + ]: 838046 : if (PyUnicode_Check(o))
1591 : : /* The below check is done in PyLong_FromUnicodeObject(). */
1592 : 632102 : return PyLong_FromUnicodeObject(o, 10);
1593 : :
1594 [ + + ]: 205944 : if (PyBytes_Check(o))
1595 : : /* need to do extra error checking that PyLong_FromString()
1596 : : * doesn't do. In particular int('9\x005') must raise an
1597 : : * exception, not truncate at the null.
1598 : : */
1599 : 156824 : return _PyLong_FromBytes(PyBytes_AS_STRING(o),
1600 : : PyBytes_GET_SIZE(o), 10);
1601 : :
1602 [ + + ]: 49120 : if (PyByteArray_Check(o))
1603 : 26197 : return _PyLong_FromBytes(PyByteArray_AS_STRING(o),
1604 : : PyByteArray_GET_SIZE(o), 10);
1605 : :
1606 [ + + ]: 22923 : if (PyObject_GetBuffer(o, &view, PyBUF_SIMPLE) == 0) {
1607 : : PyObject *bytes;
1608 : :
1609 : : /* Copy to NUL-terminated buffer. */
1610 : 9 : bytes = PyBytes_FromStringAndSize((const char *)view.buf, view.len);
1611 [ - + ]: 9 : if (bytes == NULL) {
1612 : 0 : PyBuffer_Release(&view);
1613 : 0 : return NULL;
1614 : : }
1615 : 9 : result = _PyLong_FromBytes(PyBytes_AS_STRING(bytes),
1616 : : PyBytes_GET_SIZE(bytes), 10);
1617 : 9 : Py_DECREF(bytes);
1618 : 9 : PyBuffer_Release(&view);
1619 : 9 : return result;
1620 : : }
1621 : :
1622 : 22914 : return type_error("int() argument must be a string, a bytes-like object "
1623 : : "or a real number, not '%.200s'", o);
1624 : : }
1625 : :
1626 : : PyObject *
1627 : 3414513 : PyNumber_Float(PyObject *o)
1628 : : {
1629 [ - + ]: 3414513 : if (o == NULL) {
1630 : 0 : return null_error();
1631 : : }
1632 : :
1633 [ + + ]: 3414513 : if (PyFloat_CheckExact(o)) {
1634 : 17457 : return Py_NewRef(o);
1635 : : }
1636 : :
1637 : 3397056 : PyNumberMethods *m = Py_TYPE(o)->tp_as_number;
1638 [ + + + + ]: 3397056 : if (m && m->nb_float) { /* This should include subclasses of float */
1639 : 3396902 : PyObject *res = m->nb_float(o);
1640 : : assert(_Py_CheckSlotResult(o, "__float__", res != NULL));
1641 [ + + + + ]: 3396902 : if (!res || PyFloat_CheckExact(res)) {
1642 : 3396894 : return res;
1643 : : }
1644 : :
1645 [ + + ]: 8 : if (!PyFloat_Check(res)) {
1646 : 3 : PyErr_Format(PyExc_TypeError,
1647 : : "%.50s.__float__ returned non-float (type %.50s)",
1648 : 3 : Py_TYPE(o)->tp_name, Py_TYPE(res)->tp_name);
1649 : 3 : Py_DECREF(res);
1650 : 3 : return NULL;
1651 : : }
1652 : : /* Issue #26983: warn if 'res' not of exact type float. */
1653 [ - + ]: 5 : if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
1654 : : "%.50s.__float__ returned non-float (type %.50s). "
1655 : : "The ability to return an instance of a strict subclass of float "
1656 : : "is deprecated, and may be removed in a future version of Python.",
1657 : 5 : Py_TYPE(o)->tp_name, Py_TYPE(res)->tp_name)) {
1658 : 0 : Py_DECREF(res);
1659 : 0 : return NULL;
1660 : : }
1661 : 5 : double val = PyFloat_AS_DOUBLE(res);
1662 : 5 : Py_DECREF(res);
1663 : 5 : return PyFloat_FromDouble(val);
1664 : : }
1665 : :
1666 [ + + + + ]: 154 : if (m && m->nb_index) {
1667 : 6 : PyObject *res = _PyNumber_Index(o);
1668 [ - + ]: 6 : if (!res) {
1669 : 0 : return NULL;
1670 : : }
1671 : 6 : double val = PyLong_AsDouble(res);
1672 : 6 : Py_DECREF(res);
1673 [ + + + - ]: 6 : if (val == -1.0 && PyErr_Occurred()) {
1674 : 3 : return NULL;
1675 : : }
1676 : 3 : return PyFloat_FromDouble(val);
1677 : : }
1678 : :
1679 : : /* A float subclass with nb_float == NULL */
1680 [ - + ]: 148 : if (PyFloat_Check(o)) {
1681 : 0 : return PyFloat_FromDouble(PyFloat_AS_DOUBLE(o));
1682 : : }
1683 : 148 : return PyFloat_FromString(o);
1684 : : }
1685 : :
1686 : :
1687 : : PyObject *
1688 : 685984 : PyNumber_ToBase(PyObject *n, int base)
1689 : : {
1690 [ + + + + : 685984 : if (!(base == 2 || base == 8 || base == 10 || base == 16)) {
+ + + + ]
1691 : 1 : PyErr_SetString(PyExc_SystemError,
1692 : : "PyNumber_ToBase: base must be 2, 8, 10 or 16");
1693 : 1 : return NULL;
1694 : : }
1695 : 685983 : PyObject *index = _PyNumber_Index(n);
1696 [ + + ]: 685983 : if (!index)
1697 : 13 : return NULL;
1698 : 685970 : PyObject *res = _PyLong_Format(index, base);
1699 : 685970 : Py_DECREF(index);
1700 : 685970 : return res;
1701 : : }
1702 : :
1703 : :
1704 : : /* Operations on sequences */
1705 : :
1706 : : int
1707 : 787942 : PySequence_Check(PyObject *s)
1708 : : {
1709 [ + + ]: 787942 : if (PyDict_Check(s))
1710 : 1 : return 0;
1711 [ + + ]: 1552341 : return Py_TYPE(s)->tp_as_sequence &&
1712 [ + + ]: 764400 : Py_TYPE(s)->tp_as_sequence->sq_item != NULL;
1713 : : }
1714 : :
1715 : : Py_ssize_t
1716 : 445844 : PySequence_Size(PyObject *s)
1717 : : {
1718 [ - + ]: 445844 : if (s == NULL) {
1719 : 0 : null_error();
1720 : 0 : return -1;
1721 : : }
1722 : :
1723 : 445844 : PySequenceMethods *m = Py_TYPE(s)->tp_as_sequence;
1724 [ + + + + ]: 445844 : if (m && m->sq_length) {
1725 : 445828 : Py_ssize_t len = m->sq_length(s);
1726 : : assert(_Py_CheckSlotResult(s, "__len__", len >= 0));
1727 : 445828 : return len;
1728 : : }
1729 : :
1730 [ + + + + ]: 16 : if (Py_TYPE(s)->tp_as_mapping && Py_TYPE(s)->tp_as_mapping->mp_length) {
1731 : 2 : type_error("%.200s is not a sequence", s);
1732 : 2 : return -1;
1733 : : }
1734 : 14 : type_error("object of type '%.200s' has no len()", s);
1735 : 14 : return -1;
1736 : : }
1737 : :
1738 : : #undef PySequence_Length
1739 : : Py_ssize_t
1740 : 0 : PySequence_Length(PyObject *s)
1741 : : {
1742 : 0 : return PySequence_Size(s);
1743 : : }
1744 : : #define PySequence_Length PySequence_Size
1745 : :
1746 : : PyObject *
1747 : 53665 : PySequence_Concat(PyObject *s, PyObject *o)
1748 : : {
1749 [ + - - + ]: 53665 : if (s == NULL || o == NULL) {
1750 : 0 : return null_error();
1751 : : }
1752 : :
1753 : 53665 : PySequenceMethods *m = Py_TYPE(s)->tp_as_sequence;
1754 [ + + + + ]: 53665 : if (m && m->sq_concat) {
1755 : 53661 : PyObject *res = m->sq_concat(s, o);
1756 : : assert(_Py_CheckSlotResult(s, "+", res != NULL));
1757 : 53661 : return res;
1758 : : }
1759 : :
1760 : : /* Instances of user classes defining an __add__() method only
1761 : : have an nb_add slot, not an sq_concat slot. So we fall back
1762 : : to nb_add if both arguments appear to be sequences. */
1763 [ + + + - ]: 4 : if (PySequence_Check(s) && PySequence_Check(o)) {
1764 : 2 : PyObject *result = BINARY_OP1(s, o, NB_SLOT(nb_add), "+");
1765 [ + - ]: 2 : if (result != Py_NotImplemented)
1766 : 2 : return result;
1767 : 0 : Py_DECREF(result);
1768 : : }
1769 : 2 : return type_error("'%.200s' object can't be concatenated", s);
1770 : : }
1771 : :
1772 : : PyObject *
1773 : 0 : PySequence_Repeat(PyObject *o, Py_ssize_t count)
1774 : : {
1775 [ # # ]: 0 : if (o == NULL) {
1776 : 0 : return null_error();
1777 : : }
1778 : :
1779 : 0 : PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
1780 [ # # # # ]: 0 : if (m && m->sq_repeat) {
1781 : 0 : PyObject *res = m->sq_repeat(o, count);
1782 : : assert(_Py_CheckSlotResult(o, "*", res != NULL));
1783 : 0 : return res;
1784 : : }
1785 : :
1786 : : /* Instances of user classes defining a __mul__() method only
1787 : : have an nb_multiply slot, not an sq_repeat slot. so we fall back
1788 : : to nb_multiply if o appears to be a sequence. */
1789 [ # # ]: 0 : if (PySequence_Check(o)) {
1790 : : PyObject *n, *result;
1791 : 0 : n = PyLong_FromSsize_t(count);
1792 [ # # ]: 0 : if (n == NULL)
1793 : 0 : return NULL;
1794 : 0 : result = BINARY_OP1(o, n, NB_SLOT(nb_multiply), "*");
1795 : 0 : Py_DECREF(n);
1796 [ # # ]: 0 : if (result != Py_NotImplemented)
1797 : 0 : return result;
1798 : 0 : Py_DECREF(result);
1799 : : }
1800 : 0 : return type_error("'%.200s' object can't be repeated", o);
1801 : : }
1802 : :
1803 : : PyObject *
1804 : 1 : PySequence_InPlaceConcat(PyObject *s, PyObject *o)
1805 : : {
1806 [ + - - + ]: 1 : if (s == NULL || o == NULL) {
1807 : 0 : return null_error();
1808 : : }
1809 : :
1810 : 1 : PySequenceMethods *m = Py_TYPE(s)->tp_as_sequence;
1811 [ + - - + ]: 1 : if (m && m->sq_inplace_concat) {
1812 : 0 : PyObject *res = m->sq_inplace_concat(s, o);
1813 : : assert(_Py_CheckSlotResult(s, "+=", res != NULL));
1814 : 0 : return res;
1815 : : }
1816 [ + - - + ]: 1 : if (m && m->sq_concat) {
1817 : 0 : PyObject *res = m->sq_concat(s, o);
1818 : : assert(_Py_CheckSlotResult(s, "+", res != NULL));
1819 : 0 : return res;
1820 : : }
1821 : :
1822 [ + - + - ]: 1 : if (PySequence_Check(s) && PySequence_Check(o)) {
1823 : 1 : PyObject *result = BINARY_IOP1(s, o, NB_SLOT(nb_inplace_add),
1824 : : NB_SLOT(nb_add), "+=");
1825 [ + - ]: 1 : if (result != Py_NotImplemented)
1826 : 1 : return result;
1827 : 0 : Py_DECREF(result);
1828 : : }
1829 : 0 : return type_error("'%.200s' object can't be concatenated", s);
1830 : : }
1831 : :
1832 : : PyObject *
1833 : 0 : PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count)
1834 : : {
1835 [ # # ]: 0 : if (o == NULL) {
1836 : 0 : return null_error();
1837 : : }
1838 : :
1839 : 0 : PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
1840 [ # # # # ]: 0 : if (m && m->sq_inplace_repeat) {
1841 : 0 : PyObject *res = m->sq_inplace_repeat(o, count);
1842 : : assert(_Py_CheckSlotResult(o, "*=", res != NULL));
1843 : 0 : return res;
1844 : : }
1845 [ # # # # ]: 0 : if (m && m->sq_repeat) {
1846 : 0 : PyObject *res = m->sq_repeat(o, count);
1847 : : assert(_Py_CheckSlotResult(o, "*", res != NULL));
1848 : 0 : return res;
1849 : : }
1850 : :
1851 [ # # ]: 0 : if (PySequence_Check(o)) {
1852 : : PyObject *n, *result;
1853 : 0 : n = PyLong_FromSsize_t(count);
1854 [ # # ]: 0 : if (n == NULL)
1855 : 0 : return NULL;
1856 : 0 : result = BINARY_IOP1(o, n, NB_SLOT(nb_inplace_multiply),
1857 : : NB_SLOT(nb_multiply), "*=");
1858 : 0 : Py_DECREF(n);
1859 [ # # ]: 0 : if (result != Py_NotImplemented)
1860 : 0 : return result;
1861 : 0 : Py_DECREF(result);
1862 : : }
1863 : 0 : return type_error("'%.200s' object can't be repeated", o);
1864 : : }
1865 : :
1866 : : PyObject *
1867 : 7353398 : PySequence_GetItem(PyObject *s, Py_ssize_t i)
1868 : : {
1869 [ - + ]: 7353398 : if (s == NULL) {
1870 : 0 : return null_error();
1871 : : }
1872 : :
1873 : 7353398 : PySequenceMethods *m = Py_TYPE(s)->tp_as_sequence;
1874 [ + - + + ]: 7353398 : if (m && m->sq_item) {
1875 [ + + ]: 7353393 : if (i < 0) {
1876 [ + - ]: 32134 : if (m->sq_length) {
1877 : 32134 : Py_ssize_t l = (*m->sq_length)(s);
1878 : : assert(_Py_CheckSlotResult(s, "__len__", l >= 0));
1879 [ - + ]: 32134 : if (l < 0) {
1880 : 0 : return NULL;
1881 : : }
1882 : 32134 : i += l;
1883 : : }
1884 : : }
1885 : 7353393 : PyObject *res = m->sq_item(s, i);
1886 : : assert(_Py_CheckSlotResult(s, "__getitem__", res != NULL));
1887 : 7353393 : return res;
1888 : : }
1889 : :
1890 [ + - - + ]: 5 : if (Py_TYPE(s)->tp_as_mapping && Py_TYPE(s)->tp_as_mapping->mp_subscript) {
1891 : 0 : return type_error("%.200s is not a sequence", s);
1892 : : }
1893 : 5 : return type_error("'%.200s' object does not support indexing", s);
1894 : : }
1895 : :
1896 : : PyObject *
1897 : 17292 : PySequence_GetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2)
1898 : : {
1899 [ - + ]: 17292 : if (!s) {
1900 : 0 : return null_error();
1901 : : }
1902 : :
1903 : 17292 : PyMappingMethods *mp = Py_TYPE(s)->tp_as_mapping;
1904 [ + - + - ]: 17292 : if (mp && mp->mp_subscript) {
1905 : 17292 : PyObject *slice = _PySlice_FromIndices(i1, i2);
1906 [ - + ]: 17292 : if (!slice) {
1907 : 0 : return NULL;
1908 : : }
1909 : 17292 : PyObject *res = mp->mp_subscript(s, slice);
1910 : : assert(_Py_CheckSlotResult(s, "__getitem__", res != NULL));
1911 : 17292 : Py_DECREF(slice);
1912 : 17292 : return res;
1913 : : }
1914 : :
1915 : 0 : return type_error("'%.200s' object is unsliceable", s);
1916 : : }
1917 : :
1918 : : int
1919 : 5894 : PySequence_SetItem(PyObject *s, Py_ssize_t i, PyObject *o)
1920 : : {
1921 [ - + ]: 5894 : if (s == NULL) {
1922 : 0 : null_error();
1923 : 0 : return -1;
1924 : : }
1925 : :
1926 : 5894 : PySequenceMethods *m = Py_TYPE(s)->tp_as_sequence;
1927 [ + - + + ]: 5894 : if (m && m->sq_ass_item) {
1928 [ - + ]: 5886 : if (i < 0) {
1929 [ # # ]: 0 : if (m->sq_length) {
1930 : 0 : Py_ssize_t l = (*m->sq_length)(s);
1931 : : assert(_Py_CheckSlotResult(s, "__len__", l >= 0));
1932 [ # # ]: 0 : if (l < 0) {
1933 : 0 : return -1;
1934 : : }
1935 : 0 : i += l;
1936 : : }
1937 : : }
1938 : 5886 : int res = m->sq_ass_item(s, i, o);
1939 : : assert(_Py_CheckSlotResult(s, "__setitem__", res >= 0));
1940 : 5886 : return res;
1941 : : }
1942 : :
1943 [ + - - + ]: 8 : if (Py_TYPE(s)->tp_as_mapping && Py_TYPE(s)->tp_as_mapping->mp_ass_subscript) {
1944 : 0 : type_error("%.200s is not a sequence", s);
1945 : 0 : return -1;
1946 : : }
1947 : 8 : type_error("'%.200s' object does not support item assignment", s);
1948 : 8 : return -1;
1949 : : }
1950 : :
1951 : : int
1952 : 351682 : PySequence_DelItem(PyObject *s, Py_ssize_t i)
1953 : : {
1954 [ - + ]: 351682 : if (s == NULL) {
1955 : 0 : null_error();
1956 : 0 : return -1;
1957 : : }
1958 : :
1959 : 351682 : PySequenceMethods *m = Py_TYPE(s)->tp_as_sequence;
1960 [ + - + + ]: 351682 : if (m && m->sq_ass_item) {
1961 [ + + ]: 351680 : if (i < 0) {
1962 [ + - ]: 268 : if (m->sq_length) {
1963 : 268 : Py_ssize_t l = (*m->sq_length)(s);
1964 : : assert(_Py_CheckSlotResult(s, "__len__", l >= 0));
1965 [ - + ]: 268 : if (l < 0) {
1966 : 0 : return -1;
1967 : : }
1968 : 268 : i += l;
1969 : : }
1970 : : }
1971 : 351680 : int res = m->sq_ass_item(s, i, (PyObject *)NULL);
1972 : : assert(_Py_CheckSlotResult(s, "__delitem__", res >= 0));
1973 : 351680 : return res;
1974 : : }
1975 : :
1976 [ + - - + ]: 2 : if (Py_TYPE(s)->tp_as_mapping && Py_TYPE(s)->tp_as_mapping->mp_ass_subscript) {
1977 : 0 : type_error("%.200s is not a sequence", s);
1978 : 0 : return -1;
1979 : : }
1980 : 2 : type_error("'%.200s' object doesn't support item deletion", s);
1981 : 2 : return -1;
1982 : : }
1983 : :
1984 : : int
1985 : 0 : PySequence_SetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2, PyObject *o)
1986 : : {
1987 [ # # ]: 0 : if (s == NULL) {
1988 : 0 : null_error();
1989 : 0 : return -1;
1990 : : }
1991 : :
1992 : 0 : PyMappingMethods *mp = Py_TYPE(s)->tp_as_mapping;
1993 [ # # # # ]: 0 : if (mp && mp->mp_ass_subscript) {
1994 : 0 : PyObject *slice = _PySlice_FromIndices(i1, i2);
1995 [ # # ]: 0 : if (!slice)
1996 : 0 : return -1;
1997 : 0 : int res = mp->mp_ass_subscript(s, slice, o);
1998 : : assert(_Py_CheckSlotResult(s, "__setitem__", res >= 0));
1999 : 0 : Py_DECREF(slice);
2000 : 0 : return res;
2001 : : }
2002 : :
2003 : 0 : type_error("'%.200s' object doesn't support slice assignment", s);
2004 : 0 : return -1;
2005 : : }
2006 : :
2007 : : int
2008 : 0 : PySequence_DelSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2)
2009 : : {
2010 [ # # ]: 0 : if (s == NULL) {
2011 : 0 : null_error();
2012 : 0 : return -1;
2013 : : }
2014 : :
2015 : 0 : PyMappingMethods *mp = Py_TYPE(s)->tp_as_mapping;
2016 [ # # # # ]: 0 : if (mp && mp->mp_ass_subscript) {
2017 : 0 : PyObject *slice = _PySlice_FromIndices(i1, i2);
2018 [ # # ]: 0 : if (!slice) {
2019 : 0 : return -1;
2020 : : }
2021 : 0 : int res = mp->mp_ass_subscript(s, slice, NULL);
2022 : : assert(_Py_CheckSlotResult(s, "__delitem__", res >= 0));
2023 : 0 : Py_DECREF(slice);
2024 : 0 : return res;
2025 : : }
2026 : 0 : type_error("'%.200s' object doesn't support slice deletion", s);
2027 : 0 : return -1;
2028 : : }
2029 : :
2030 : : PyObject *
2031 : 11466355 : PySequence_Tuple(PyObject *v)
2032 : : {
2033 : : PyObject *it; /* iter(v) */
2034 : : Py_ssize_t n; /* guess for result tuple size */
2035 : 11466355 : PyObject *result = NULL;
2036 : : Py_ssize_t j;
2037 : :
2038 [ - + ]: 11466355 : if (v == NULL) {
2039 : 0 : return null_error();
2040 : : }
2041 : :
2042 : : /* Special-case the common tuple and list cases, for efficiency. */
2043 [ + + ]: 11466355 : if (PyTuple_CheckExact(v)) {
2044 : : /* Note that we can't know whether it's safe to return
2045 : : a tuple *subclass* instance as-is, hence the restriction
2046 : : to exact tuples here. In contrast, lists always make
2047 : : a copy, so there's no need for exactness below. */
2048 : 9994496 : Py_INCREF(v);
2049 : 9994496 : return v;
2050 : : }
2051 [ + + ]: 1471859 : if (PyList_CheckExact(v))
2052 : 1198293 : return PyList_AsTuple(v);
2053 : :
2054 : : /* Get iterator. */
2055 : 273566 : it = PyObject_GetIter(v);
2056 [ + + ]: 273566 : if (it == NULL)
2057 : 33 : return NULL;
2058 : :
2059 : : /* Guess result size and allocate space. */
2060 : 273533 : n = PyObject_LengthHint(v, 10);
2061 [ - + ]: 273533 : if (n == -1)
2062 : 0 : goto Fail;
2063 : 273533 : result = PyTuple_New(n);
2064 [ - + ]: 273533 : if (result == NULL)
2065 : 0 : goto Fail;
2066 : :
2067 : : /* Fill the tuple. */
2068 : 3827069 : for (j = 0; ; ++j) {
2069 : 3827069 : PyObject *item = PyIter_Next(it);
2070 [ + + ]: 3827069 : if (item == NULL) {
2071 [ + + ]: 273533 : if (PyErr_Occurred())
2072 : 67 : goto Fail;
2073 : 273466 : break;
2074 : : }
2075 [ + + ]: 3553536 : if (j >= n) {
2076 : 7159 : size_t newn = (size_t)n;
2077 : : /* The over-allocation strategy can grow a bit faster
2078 : : than for lists because unlike lists the
2079 : : over-allocation isn't permanent -- we reclaim
2080 : : the excess before the end of this routine.
2081 : : So, grow by ten and then add 25%.
2082 : : */
2083 : 7159 : newn += 10u;
2084 : 7159 : newn += newn >> 2;
2085 [ - + ]: 7159 : if (newn > PY_SSIZE_T_MAX) {
2086 : : /* Check for overflow */
2087 : : PyErr_NoMemory();
2088 : 0 : Py_DECREF(item);
2089 : 0 : goto Fail;
2090 : : }
2091 : 7159 : n = (Py_ssize_t)newn;
2092 [ - + ]: 7159 : if (_PyTuple_Resize(&result, n) != 0) {
2093 : 0 : Py_DECREF(item);
2094 : 0 : goto Fail;
2095 : : }
2096 : : }
2097 : 3553536 : PyTuple_SET_ITEM(result, j, item);
2098 : : }
2099 : :
2100 : : /* Cut tuple back if guess was too large. */
2101 [ + + - + ]: 431485 : if (j < n &&
2102 : 158019 : _PyTuple_Resize(&result, j) != 0)
2103 : 0 : goto Fail;
2104 : :
2105 : 273466 : Py_DECREF(it);
2106 : 273466 : return result;
2107 : :
2108 : 67 : Fail:
2109 : 67 : Py_XDECREF(result);
2110 : 67 : Py_DECREF(it);
2111 : 67 : return NULL;
2112 : : }
2113 : :
2114 : : PyObject *
2115 : 1689678 : PySequence_List(PyObject *v)
2116 : : {
2117 : : PyObject *result; /* result list */
2118 : : PyObject *rv; /* return value from PyList_Extend */
2119 : :
2120 [ - + ]: 1689678 : if (v == NULL) {
2121 : 0 : return null_error();
2122 : : }
2123 : :
2124 : 1689678 : result = PyList_New(0);
2125 [ - + ]: 1689678 : if (result == NULL)
2126 : 0 : return NULL;
2127 : :
2128 : 1689678 : rv = _PyList_Extend((PyListObject *)result, v);
2129 [ + + ]: 1689678 : if (rv == NULL) {
2130 : 32 : Py_DECREF(result);
2131 : 32 : return NULL;
2132 : : }
2133 : 1689646 : Py_DECREF(rv);
2134 : 1689646 : return result;
2135 : : }
2136 : :
2137 : : PyObject *
2138 : 20167871 : PySequence_Fast(PyObject *v, const char *m)
2139 : : {
2140 : : PyObject *it;
2141 : :
2142 [ - + ]: 20167871 : if (v == NULL) {
2143 : 0 : return null_error();
2144 : : }
2145 : :
2146 [ + + + + ]: 20167871 : if (PyList_CheckExact(v) || PyTuple_CheckExact(v)) {
2147 : 19624038 : Py_INCREF(v);
2148 : 19624038 : return v;
2149 : : }
2150 : :
2151 : 543833 : it = PyObject_GetIter(v);
2152 [ + + ]: 543833 : if (it == NULL) {
2153 : 33 : PyThreadState *tstate = _PyThreadState_GET();
2154 [ + - ]: 33 : if (_PyErr_ExceptionMatches(tstate, PyExc_TypeError)) {
2155 : 33 : _PyErr_SetString(tstate, PyExc_TypeError, m);
2156 : : }
2157 : 33 : return NULL;
2158 : : }
2159 : :
2160 : 543800 : v = PySequence_List(it);
2161 : 543800 : Py_DECREF(it);
2162 : :
2163 : 543800 : return v;
2164 : : }
2165 : :
2166 : : /* Iterate over seq. Result depends on the operation:
2167 : : PY_ITERSEARCH_COUNT: -1 if error, else # of times obj appears in seq.
2168 : : PY_ITERSEARCH_INDEX: 0-based index of first occurrence of obj in seq;
2169 : : set ValueError and return -1 if none found; also return -1 on error.
2170 : : Py_ITERSEARCH_CONTAINS: return 1 if obj in seq, else 0; -1 on error.
2171 : : */
2172 : : Py_ssize_t
2173 : 1101 : _PySequence_IterSearch(PyObject *seq, PyObject *obj, int operation)
2174 : : {
2175 : : Py_ssize_t n;
2176 : : int wrapped; /* for PY_ITERSEARCH_INDEX, true iff n wrapped around */
2177 : : PyObject *it; /* iter(seq) */
2178 : :
2179 [ + - - + ]: 1101 : if (seq == NULL || obj == NULL) {
2180 : 0 : null_error();
2181 : 0 : return -1;
2182 : : }
2183 : :
2184 : 1101 : it = PyObject_GetIter(seq);
2185 [ + + ]: 1101 : if (it == NULL) {
2186 [ + + ]: 36 : if (PyErr_ExceptionMatches(PyExc_TypeError)) {
2187 : 30 : type_error("argument of type '%.200s' is not iterable", seq);
2188 : : }
2189 : 36 : return -1;
2190 : : }
2191 : :
2192 : 1065 : n = wrapped = 0;
2193 : 4216 : for (;;) {
2194 : : int cmp;
2195 : 5281 : PyObject *item = PyIter_Next(it);
2196 [ + + ]: 5281 : if (item == NULL) {
2197 [ + + ]: 105 : if (PyErr_Occurred())
2198 : 2 : goto Fail;
2199 : 103 : break;
2200 : : }
2201 : :
2202 : 5176 : cmp = PyObject_RichCompareBool(item, obj, Py_EQ);
2203 : 5176 : Py_DECREF(item);
2204 [ + + ]: 5176 : if (cmp < 0)
2205 : 2 : goto Fail;
2206 [ + + ]: 5174 : if (cmp > 0) {
2207 [ + + + - ]: 994 : switch (operation) {
2208 : 36 : case PY_ITERSEARCH_COUNT:
2209 [ - + ]: 36 : if (n == PY_SSIZE_T_MAX) {
2210 : 0 : PyErr_SetString(PyExc_OverflowError,
2211 : : "count exceeds C integer size");
2212 : 0 : goto Fail;
2213 : : }
2214 : 36 : ++n;
2215 : 36 : break;
2216 : :
2217 : 364 : case PY_ITERSEARCH_INDEX:
2218 [ - + ]: 364 : if (wrapped) {
2219 : 0 : PyErr_SetString(PyExc_OverflowError,
2220 : : "index exceeds C integer size");
2221 : 0 : goto Fail;
2222 : : }
2223 : 364 : goto Done;
2224 : :
2225 : 594 : case PY_ITERSEARCH_CONTAINS:
2226 : 594 : n = 1;
2227 : 594 : goto Done;
2228 : :
2229 : 0 : default:
2230 : 0 : Py_UNREACHABLE();
2231 : : }
2232 : : }
2233 : :
2234 [ + + ]: 4216 : if (operation == PY_ITERSEARCH_INDEX) {
2235 [ - + ]: 464 : if (n == PY_SSIZE_T_MAX)
2236 : 0 : wrapped = 1;
2237 : 464 : ++n;
2238 : : }
2239 : : }
2240 : :
2241 [ + + ]: 103 : if (operation != PY_ITERSEARCH_INDEX)
2242 : 96 : goto Done;
2243 : :
2244 : 7 : PyErr_SetString(PyExc_ValueError,
2245 : : "sequence.index(x): x not in sequence");
2246 : : /* fall into failure code */
2247 : 11 : Fail:
2248 : 11 : n = -1;
2249 : : /* fall through */
2250 : 1065 : Done:
2251 : 1065 : Py_DECREF(it);
2252 : 1065 : return n;
2253 : :
2254 : : }
2255 : :
2256 : : /* Return # of times o appears in s. */
2257 : : Py_ssize_t
2258 : 23 : PySequence_Count(PyObject *s, PyObject *o)
2259 : : {
2260 : 23 : return _PySequence_IterSearch(s, o, PY_ITERSEARCH_COUNT);
2261 : : }
2262 : :
2263 : : /* Return -1 if error; 1 if ob in seq; 0 if ob not in seq.
2264 : : * Use sq_contains if possible, else defer to _PySequence_IterSearch().
2265 : : */
2266 : : int
2267 : 92910593 : PySequence_Contains(PyObject *seq, PyObject *ob)
2268 : : {
2269 : 92910593 : PySequenceMethods *sqm = Py_TYPE(seq)->tp_as_sequence;
2270 [ + + + + ]: 92910593 : if (sqm != NULL && sqm->sq_contains != NULL) {
2271 : 92909911 : int res = (*sqm->sq_contains)(seq, ob);
2272 : : assert(_Py_CheckSlotResult(seq, "__contains__", res >= 0));
2273 : 92909911 : return res;
2274 : : }
2275 : 682 : Py_ssize_t result = _PySequence_IterSearch(seq, ob, PY_ITERSEARCH_CONTAINS);
2276 : 682 : return Py_SAFE_DOWNCAST(result, Py_ssize_t, int);
2277 : : }
2278 : :
2279 : : /* Backwards compatibility */
2280 : : #undef PySequence_In
2281 : : int
2282 : 0 : PySequence_In(PyObject *w, PyObject *v)
2283 : : {
2284 : 0 : return PySequence_Contains(w, v);
2285 : : }
2286 : :
2287 : : Py_ssize_t
2288 : 375 : PySequence_Index(PyObject *s, PyObject *o)
2289 : : {
2290 : 375 : return _PySequence_IterSearch(s, o, PY_ITERSEARCH_INDEX);
2291 : : }
2292 : :
2293 : : /* Operations on mappings */
2294 : :
2295 : : int
2296 : 3768372 : PyMapping_Check(PyObject *o)
2297 : : {
2298 [ + - + + ]: 6826713 : return o && Py_TYPE(o)->tp_as_mapping &&
2299 [ + + ]: 3058341 : Py_TYPE(o)->tp_as_mapping->mp_subscript;
2300 : : }
2301 : :
2302 : : Py_ssize_t
2303 : 1209546 : PyMapping_Size(PyObject *o)
2304 : : {
2305 [ - + ]: 1209546 : if (o == NULL) {
2306 : 0 : null_error();
2307 : 0 : return -1;
2308 : : }
2309 : :
2310 : 1209546 : PyMappingMethods *m = Py_TYPE(o)->tp_as_mapping;
2311 [ + + + + ]: 1209546 : if (m && m->mp_length) {
2312 : 1209208 : Py_ssize_t len = m->mp_length(o);
2313 : : assert(_Py_CheckSlotResult(o, "__len__", len >= 0));
2314 : 1209208 : return len;
2315 : : }
2316 : :
2317 [ + + - + ]: 338 : if (Py_TYPE(o)->tp_as_sequence && Py_TYPE(o)->tp_as_sequence->sq_length) {
2318 : 0 : type_error("%.200s is not a mapping", o);
2319 : 0 : return -1;
2320 : : }
2321 : : /* PyMapping_Size() can be called from PyObject_Size(). */
2322 : 338 : type_error("object of type '%.200s' has no len()", o);
2323 : 338 : return -1;
2324 : : }
2325 : :
2326 : : #undef PyMapping_Length
2327 : : Py_ssize_t
2328 : 0 : PyMapping_Length(PyObject *o)
2329 : : {
2330 : 0 : return PyMapping_Size(o);
2331 : : }
2332 : : #define PyMapping_Length PyMapping_Size
2333 : :
2334 : : PyObject *
2335 : 16806 : PyMapping_GetItemString(PyObject *o, const char *key)
2336 : : {
2337 : : PyObject *okey, *r;
2338 : :
2339 [ - + ]: 16806 : if (key == NULL) {
2340 : 0 : return null_error();
2341 : : }
2342 : :
2343 : 16806 : okey = PyUnicode_FromString(key);
2344 [ - + ]: 16806 : if (okey == NULL)
2345 : 0 : return NULL;
2346 : 16806 : r = PyObject_GetItem(o, okey);
2347 : 16806 : Py_DECREF(okey);
2348 : 16806 : return r;
2349 : : }
2350 : :
2351 : : int
2352 : 8503 : PyMapping_SetItemString(PyObject *o, const char *key, PyObject *value)
2353 : : {
2354 : : PyObject *okey;
2355 : : int r;
2356 : :
2357 [ - + ]: 8503 : if (key == NULL) {
2358 : 0 : null_error();
2359 : 0 : return -1;
2360 : : }
2361 : :
2362 : 8503 : okey = PyUnicode_FromString(key);
2363 [ - + ]: 8503 : if (okey == NULL)
2364 : 0 : return -1;
2365 : 8503 : r = PyObject_SetItem(o, okey, value);
2366 : 8503 : Py_DECREF(okey);
2367 : 8503 : return r;
2368 : : }
2369 : :
2370 : : int
2371 : 0 : PyMapping_HasKeyString(PyObject *o, const char *key)
2372 : : {
2373 : : PyObject *v;
2374 : :
2375 : 0 : v = PyMapping_GetItemString(o, key);
2376 [ # # ]: 0 : if (v) {
2377 : 0 : Py_DECREF(v);
2378 : 0 : return 1;
2379 : : }
2380 : 0 : PyErr_Clear();
2381 : 0 : return 0;
2382 : : }
2383 : :
2384 : : int
2385 : 0 : PyMapping_HasKey(PyObject *o, PyObject *key)
2386 : : {
2387 : : PyObject *v;
2388 : :
2389 : 0 : v = PyObject_GetItem(o, key);
2390 [ # # ]: 0 : if (v) {
2391 : 0 : Py_DECREF(v);
2392 : 0 : return 1;
2393 : : }
2394 : 0 : PyErr_Clear();
2395 : 0 : return 0;
2396 : : }
2397 : :
2398 : : /* This function is quite similar to PySequence_Fast(), but specialized to be
2399 : : a helper for PyMapping_Keys(), PyMapping_Items() and PyMapping_Values().
2400 : : */
2401 : : static PyObject *
2402 : 275326 : method_output_as_list(PyObject *o, PyObject *meth)
2403 : : {
2404 : : PyObject *it, *result, *meth_output;
2405 : :
2406 : : assert(o != NULL);
2407 : 275326 : meth_output = PyObject_CallMethodNoArgs(o, meth);
2408 [ + + + + ]: 275326 : if (meth_output == NULL || PyList_CheckExact(meth_output)) {
2409 : 41 : return meth_output;
2410 : : }
2411 : 275285 : it = PyObject_GetIter(meth_output);
2412 [ + + ]: 275285 : if (it == NULL) {
2413 : 4 : PyThreadState *tstate = _PyThreadState_GET();
2414 [ + - ]: 4 : if (_PyErr_ExceptionMatches(tstate, PyExc_TypeError)) {
2415 : 4 : _PyErr_Format(tstate, PyExc_TypeError,
2416 : : "%.200s.%U() returned a non-iterable (type %.200s)",
2417 : 4 : Py_TYPE(o)->tp_name,
2418 : : meth,
2419 : 4 : Py_TYPE(meth_output)->tp_name);
2420 : : }
2421 : 4 : Py_DECREF(meth_output);
2422 : 4 : return NULL;
2423 : : }
2424 : 275281 : Py_DECREF(meth_output);
2425 : 275281 : result = PySequence_List(it);
2426 : 275281 : Py_DECREF(it);
2427 : 275281 : return result;
2428 : : }
2429 : :
2430 : : PyObject *
2431 : 126349 : PyMapping_Keys(PyObject *o)
2432 : : {
2433 [ - + ]: 126349 : if (o == NULL) {
2434 : 0 : return null_error();
2435 : : }
2436 [ + + ]: 126349 : if (PyDict_CheckExact(o)) {
2437 : 26674 : return PyDict_Keys(o);
2438 : : }
2439 : 99675 : return method_output_as_list(o, &_Py_ID(keys));
2440 : : }
2441 : :
2442 : : PyObject *
2443 : 176766 : PyMapping_Items(PyObject *o)
2444 : : {
2445 [ - + ]: 176766 : if (o == NULL) {
2446 : 0 : return null_error();
2447 : : }
2448 [ + + ]: 176766 : if (PyDict_CheckExact(o)) {
2449 : 1212 : return PyDict_Items(o);
2450 : : }
2451 : 175554 : return method_output_as_list(o, &_Py_ID(items));
2452 : : }
2453 : :
2454 : : PyObject *
2455 : 104 : PyMapping_Values(PyObject *o)
2456 : : {
2457 [ - + ]: 104 : if (o == NULL) {
2458 : 0 : return null_error();
2459 : : }
2460 [ + + ]: 104 : if (PyDict_CheckExact(o)) {
2461 : 7 : return PyDict_Values(o);
2462 : : }
2463 : 97 : return method_output_as_list(o, &_Py_ID(values));
2464 : : }
2465 : :
2466 : : /* isinstance(), issubclass() */
2467 : :
2468 : : /* abstract_get_bases() has logically 4 return states:
2469 : : *
2470 : : * 1. getattr(cls, '__bases__') could raise an AttributeError
2471 : : * 2. getattr(cls, '__bases__') could raise some other exception
2472 : : * 3. getattr(cls, '__bases__') could return a tuple
2473 : : * 4. getattr(cls, '__bases__') could return something other than a tuple
2474 : : *
2475 : : * Only state #3 is a non-error state and only it returns a non-NULL object
2476 : : * (it returns the retrieved tuple).
2477 : : *
2478 : : * Any raised AttributeErrors are masked by clearing the exception and
2479 : : * returning NULL. If an object other than a tuple comes out of __bases__,
2480 : : * then again, the return value is NULL. So yes, these two situations
2481 : : * produce exactly the same results: NULL is returned and no error is set.
2482 : : *
2483 : : * If some exception other than AttributeError is raised, then NULL is also
2484 : : * returned, but the exception is not cleared. That's because we want the
2485 : : * exception to be propagated along.
2486 : : *
2487 : : * Callers are expected to test for PyErr_Occurred() when the return value
2488 : : * is NULL to decide whether a valid exception should be propagated or not.
2489 : : * When there's no exception to propagate, it's customary for the caller to
2490 : : * set a TypeError.
2491 : : */
2492 : : static PyObject *
2493 : 268 : abstract_get_bases(PyObject *cls)
2494 : : {
2495 : : PyObject *bases;
2496 : :
2497 : 268 : (void)_PyObject_LookupAttr(cls, &_Py_ID(__bases__), &bases);
2498 [ + + - + ]: 268 : if (bases != NULL && !PyTuple_Check(bases)) {
2499 : 0 : Py_DECREF(bases);
2500 : 0 : return NULL;
2501 : : }
2502 : 268 : return bases;
2503 : : }
2504 : :
2505 : :
2506 : : static int
2507 : 105 : abstract_issubclass(PyObject *derived, PyObject *cls)
2508 : : {
2509 : 105 : PyObject *bases = NULL;
2510 : : Py_ssize_t i, n;
2511 : 105 : int r = 0;
2512 : :
2513 : : while (1) {
2514 [ + + ]: 118 : if (derived == cls) {
2515 : 7 : Py_XDECREF(bases); /* See below comment */
2516 : 7 : return 1;
2517 : : }
2518 : : /* Use XSETREF to drop bases reference *after* finishing with
2519 : : derived; bases might be the only reference to it.
2520 : : XSETREF is used instead of SETREF, because bases is NULL on the
2521 : : first iteration of the loop.
2522 : : */
2523 : 111 : Py_XSETREF(bases, abstract_get_bases(derived));
2524 [ + + ]: 111 : if (bases == NULL) {
2525 [ + + ]: 4 : if (PyErr_Occurred())
2526 : 3 : return -1;
2527 : 1 : return 0;
2528 : : }
2529 : 107 : n = PyTuple_GET_SIZE(bases);
2530 [ + + ]: 107 : if (n == 0) {
2531 : 10 : Py_DECREF(bases);
2532 : 10 : return 0;
2533 : : }
2534 : : /* Avoid recursivity in the single inheritance case */
2535 [ + + ]: 97 : if (n == 1) {
2536 : 13 : derived = PyTuple_GET_ITEM(bases, 0);
2537 : 13 : continue;
2538 : : }
2539 : 84 : break;
2540 : : }
2541 : : assert(n >= 2);
2542 [ - + ]: 84 : if (_Py_EnterRecursiveCall(" in __issubclass__")) {
2543 : 0 : Py_DECREF(bases);
2544 : 0 : return -1;
2545 : : }
2546 [ + - ]: 84 : for (i = 0; i < n; i++) {
2547 : 84 : r = abstract_issubclass(PyTuple_GET_ITEM(bases, i), cls);
2548 [ + - ]: 84 : if (r != 0) {
2549 : 84 : break;
2550 : : }
2551 : : }
2552 : 84 : _Py_LeaveRecursiveCall();
2553 : 84 : Py_DECREF(bases);
2554 : 84 : return r;
2555 : : }
2556 : :
2557 : : static int
2558 : 157 : check_class(PyObject *cls, const char *error)
2559 : : {
2560 : 157 : PyObject *bases = abstract_get_bases(cls);
2561 [ + + ]: 157 : if (bases == NULL) {
2562 : : /* Do not mask errors. */
2563 : 104 : PyThreadState *tstate = _PyThreadState_GET();
2564 [ + + ]: 104 : if (!_PyErr_Occurred(tstate)) {
2565 : 97 : _PyErr_SetString(tstate, PyExc_TypeError, error);
2566 : : }
2567 : 104 : return 0;
2568 : : }
2569 : 53 : Py_DECREF(bases);
2570 : 53 : return -1;
2571 : : }
2572 : :
2573 : : static int
2574 : 24295904 : object_isinstance(PyObject *inst, PyObject *cls)
2575 : : {
2576 : : PyObject *icls;
2577 : : int retval;
2578 [ + + ]: 24295904 : if (PyType_Check(cls)) {
2579 : 24295889 : retval = PyObject_TypeCheck(inst, (PyTypeObject *)cls);
2580 [ + + ]: 24295889 : if (retval == 0) {
2581 : 21710195 : retval = _PyObject_LookupAttr(inst, &_Py_ID(__class__), &icls);
2582 [ + + ]: 21710195 : if (icls != NULL) {
2583 [ + + + + ]: 21710192 : if (icls != (PyObject *)(Py_TYPE(inst)) && PyType_Check(icls)) {
2584 : 1203 : retval = PyType_IsSubtype(
2585 : : (PyTypeObject *)icls,
2586 : : (PyTypeObject *)cls);
2587 : : }
2588 : : else {
2589 : 21708989 : retval = 0;
2590 : : }
2591 : 21710192 : Py_DECREF(icls);
2592 : : }
2593 : : }
2594 : : }
2595 : : else {
2596 [ + + ]: 15 : if (!check_class(cls,
2597 : : "isinstance() arg 2 must be a type, a tuple of types, or a union"))
2598 : 6 : return -1;
2599 : 9 : retval = _PyObject_LookupAttr(inst, &_Py_ID(__class__), &icls);
2600 [ + - ]: 9 : if (icls != NULL) {
2601 : 9 : retval = abstract_issubclass(icls, cls);
2602 : 9 : Py_DECREF(icls);
2603 : : }
2604 : : }
2605 : :
2606 : 24295898 : return retval;
2607 : : }
2608 : :
2609 : : static int
2610 : 48025224 : object_recursive_isinstance(PyThreadState *tstate, PyObject *inst, PyObject *cls)
2611 : : {
2612 : : /* Quick test for an exact match */
2613 [ + + ]: 48025224 : if (Py_IS_TYPE(inst, (PyTypeObject *)cls)) {
2614 : 19391099 : return 1;
2615 : : }
2616 : :
2617 : : /* We know what type's __instancecheck__ does. */
2618 [ + + ]: 28634125 : if (PyType_CheckExact(cls)) {
2619 : 23894337 : return object_isinstance(inst, cls);
2620 : : }
2621 : :
2622 [ + + ]: 4739788 : if (_PyUnion_Check(cls)) {
2623 : 20 : cls = _Py_union_args(cls);
2624 : : }
2625 : :
2626 [ + + ]: 4739788 : if (PyTuple_Check(cls)) {
2627 : : /* Not a general sequence -- that opens up the road to
2628 : : recursion and stack overflow. */
2629 [ + + ]: 3793835 : if (_Py_EnterRecursiveCallTstate(tstate, " in __instancecheck__")) {
2630 : 2 : return -1;
2631 : : }
2632 : 3793833 : Py_ssize_t n = PyTuple_GET_SIZE(cls);
2633 : 3793833 : int r = 0;
2634 [ + + ]: 5210342 : for (Py_ssize_t i = 0; i < n; ++i) {
2635 : 4660564 : PyObject *item = PyTuple_GET_ITEM(cls, i);
2636 : 4660564 : r = object_recursive_isinstance(tstate, inst, item);
2637 [ + + ]: 4660564 : if (r != 0) {
2638 : : /* either found it, or got an error */
2639 : 3244055 : break;
2640 : : }
2641 : : }
2642 : 3793833 : _Py_LeaveRecursiveCallTstate(tstate);
2643 : 3793833 : return r;
2644 : : }
2645 : :
2646 : 945953 : PyObject *checker = _PyObject_LookupSpecial(cls, &_Py_ID(__instancecheck__));
2647 [ + + ]: 945953 : if (checker != NULL) {
2648 [ - + ]: 945937 : if (_Py_EnterRecursiveCallTstate(tstate, " in __instancecheck__")) {
2649 : 0 : Py_DECREF(checker);
2650 : 0 : return -1;
2651 : : }
2652 : :
2653 : 945937 : PyObject *res = PyObject_CallOneArg(checker, inst);
2654 : 945937 : _Py_LeaveRecursiveCallTstate(tstate);
2655 : 945937 : Py_DECREF(checker);
2656 : :
2657 [ + + ]: 945937 : if (res == NULL) {
2658 : 50 : return -1;
2659 : : }
2660 : 945887 : int ok = PyObject_IsTrue(res);
2661 : 945887 : Py_DECREF(res);
2662 : :
2663 : 945887 : return ok;
2664 : : }
2665 [ + + ]: 16 : else if (_PyErr_Occurred(tstate)) {
2666 : 1 : return -1;
2667 : : }
2668 : :
2669 : : /* cls has no __instancecheck__() method */
2670 : 15 : return object_isinstance(inst, cls);
2671 : : }
2672 : :
2673 : :
2674 : : int
2675 : 43364660 : PyObject_IsInstance(PyObject *inst, PyObject *cls)
2676 : : {
2677 : 43364660 : PyThreadState *tstate = _PyThreadState_GET();
2678 : 43364660 : return object_recursive_isinstance(tstate, inst, cls);
2679 : : }
2680 : :
2681 : :
2682 : : static int
2683 : 6131096 : recursive_issubclass(PyObject *derived, PyObject *cls)
2684 : : {
2685 [ + + + + ]: 6131096 : if (PyType_Check(cls) && PyType_Check(derived)) {
2686 : : /* Fast path (non-recursive) */
2687 : 6130986 : return PyType_IsSubtype((PyTypeObject *)derived, (PyTypeObject *)cls);
2688 : : }
2689 [ + + ]: 110 : if (!check_class(derived,
2690 : : "issubclass() arg 1 must be a class"))
2691 : 78 : return -1;
2692 : :
2693 [ + - + + ]: 32 : if (!_PyUnion_Check(cls) && !check_class(cls,
2694 : : "issubclass() arg 2 must be a class,"
2695 : : " a tuple of classes, or a union")) {
2696 : 20 : return -1;
2697 : : }
2698 : :
2699 : 12 : return abstract_issubclass(derived, cls);
2700 : : }
2701 : :
2702 : : static int
2703 : 3129564 : object_issubclass(PyThreadState *tstate, PyObject *derived, PyObject *cls)
2704 : : {
2705 : : PyObject *checker;
2706 : :
2707 : : /* We know what type's __subclasscheck__ does. */
2708 [ + + ]: 3129564 : if (PyType_CheckExact(cls)) {
2709 : : /* Quick test for an exact match */
2710 [ + + ]: 2586223 : if (derived == cls)
2711 : 1971217 : return 1;
2712 : 615006 : return recursive_issubclass(derived, cls);
2713 : : }
2714 : :
2715 [ + + ]: 543341 : if (_PyUnion_Check(cls)) {
2716 : 18 : cls = _Py_union_args(cls);
2717 : : }
2718 : :
2719 [ + + ]: 543341 : if (PyTuple_Check(cls)) {
2720 : :
2721 [ + + ]: 33802 : if (_Py_EnterRecursiveCallTstate(tstate, " in __subclasscheck__")) {
2722 : 1 : return -1;
2723 : : }
2724 : 33801 : Py_ssize_t n = PyTuple_GET_SIZE(cls);
2725 : 33801 : int r = 0;
2726 [ + + ]: 58108 : for (Py_ssize_t i = 0; i < n; ++i) {
2727 : 58070 : PyObject *item = PyTuple_GET_ITEM(cls, i);
2728 : 58070 : r = object_issubclass(tstate, derived, item);
2729 [ + + ]: 58070 : if (r != 0)
2730 : : /* either found it, or got an error */
2731 : 33763 : break;
2732 : : }
2733 : 33801 : _Py_LeaveRecursiveCallTstate(tstate);
2734 : 33801 : return r;
2735 : : }
2736 : :
2737 : 509539 : checker = _PyObject_LookupSpecial(cls, &_Py_ID(__subclasscheck__));
2738 [ + + ]: 509539 : if (checker != NULL) {
2739 : 509510 : int ok = -1;
2740 [ - + ]: 509510 : if (_Py_EnterRecursiveCallTstate(tstate, " in __subclasscheck__")) {
2741 : 0 : Py_DECREF(checker);
2742 : 0 : return ok;
2743 : : }
2744 : 509510 : PyObject *res = PyObject_CallOneArg(checker, derived);
2745 : 509510 : _Py_LeaveRecursiveCallTstate(tstate);
2746 : 509510 : Py_DECREF(checker);
2747 [ + + ]: 509510 : if (res != NULL) {
2748 : 509441 : ok = PyObject_IsTrue(res);
2749 : 509441 : Py_DECREF(res);
2750 : : }
2751 : 509510 : return ok;
2752 : : }
2753 [ + + ]: 29 : else if (_PyErr_Occurred(tstate)) {
2754 : 1 : return -1;
2755 : : }
2756 : :
2757 : : /* Probably never reached anymore. */
2758 : 28 : return recursive_issubclass(derived, cls);
2759 : : }
2760 : :
2761 : :
2762 : : int
2763 : 3071494 : PyObject_IsSubclass(PyObject *derived, PyObject *cls)
2764 : : {
2765 : 3071494 : PyThreadState *tstate = _PyThreadState_GET();
2766 : 3071494 : return object_issubclass(tstate, derived, cls);
2767 : : }
2768 : :
2769 : :
2770 : : int
2771 : 401552 : _PyObject_RealIsInstance(PyObject *inst, PyObject *cls)
2772 : : {
2773 : 401552 : return object_isinstance(inst, cls);
2774 : : }
2775 : :
2776 : : int
2777 : 5516062 : _PyObject_RealIsSubclass(PyObject *derived, PyObject *cls)
2778 : : {
2779 : 5516062 : return recursive_issubclass(derived, cls);
2780 : : }
2781 : :
2782 : :
2783 : : PyObject *
2784 : 74638433 : PyObject_GetIter(PyObject *o)
2785 : : {
2786 : 74638433 : PyTypeObject *t = Py_TYPE(o);
2787 : : getiterfunc f;
2788 : :
2789 : 74638433 : f = t->tp_iter;
2790 [ + + ]: 74638433 : if (f == NULL) {
2791 [ + + ]: 414690 : if (PySequence_Check(o))
2792 : 350459 : return PySeqIter_New(o);
2793 : 64231 : return type_error("'%.200s' object is not iterable", o);
2794 : : }
2795 : : else {
2796 : 74223743 : PyObject *res = (*f)(o);
2797 [ + + + + ]: 74223743 : if (res != NULL && !PyIter_Check(res)) {
2798 : 199 : PyErr_Format(PyExc_TypeError,
2799 : : "iter() returned non-iterator "
2800 : : "of type '%.100s'",
2801 : 199 : Py_TYPE(res)->tp_name);
2802 : 199 : Py_DECREF(res);
2803 : 199 : res = NULL;
2804 : : }
2805 : 74223743 : return res;
2806 : : }
2807 : : }
2808 : :
2809 : : PyObject *
2810 : 5 : PyObject_GetAIter(PyObject *o) {
2811 : 5 : PyTypeObject *t = Py_TYPE(o);
2812 : : unaryfunc f;
2813 : :
2814 [ + + - + ]: 5 : if (t->tp_as_async == NULL || t->tp_as_async->am_aiter == NULL) {
2815 : 1 : return type_error("'%.200s' object is not an async iterable", o);
2816 : : }
2817 : 4 : f = t->tp_as_async->am_aiter;
2818 : 4 : PyObject *it = (*f)(o);
2819 [ + - - + ]: 4 : if (it != NULL && !PyAIter_Check(it)) {
2820 : 0 : PyErr_Format(PyExc_TypeError,
2821 : : "aiter() returned not an async iterator of type '%.100s'",
2822 : 0 : Py_TYPE(it)->tp_name);
2823 : 0 : Py_DECREF(it);
2824 : 0 : it = NULL;
2825 : : }
2826 : 4 : return it;
2827 : : }
2828 : :
2829 : : int
2830 : 78288386 : PyIter_Check(PyObject *obj)
2831 : : {
2832 : 78288386 : PyTypeObject *tp = Py_TYPE(obj);
2833 [ + + ]: 156576606 : return (tp->tp_iternext != NULL &&
2834 [ + + ]: 78288220 : tp->tp_iternext != &_PyObject_NextNotImplemented);
2835 : : }
2836 : :
2837 : : int
2838 : 4 : PyAIter_Check(PyObject *obj)
2839 : : {
2840 : 4 : PyTypeObject *tp = Py_TYPE(obj);
2841 : 8 : return (tp->tp_as_async != NULL &&
2842 [ + - + - ]: 8 : tp->tp_as_async->am_anext != NULL &&
2843 [ + - ]: 4 : tp->tp_as_async->am_anext != &_PyObject_NextNotImplemented);
2844 : : }
2845 : :
2846 : : /* Return next item.
2847 : : * If an error occurs, return NULL. PyErr_Occurred() will be true.
2848 : : * If the iteration terminates normally, return NULL and clear the
2849 : : * PyExc_StopIteration exception (if it was set). PyErr_Occurred()
2850 : : * will be false.
2851 : : * Else return the next object. PyErr_Occurred() will be false.
2852 : : */
2853 : : PyObject *
2854 : 121743538 : PyIter_Next(PyObject *iter)
2855 : : {
2856 : : PyObject *result;
2857 : 121743538 : result = (*Py_TYPE(iter)->tp_iternext)(iter);
2858 [ + + ]: 121743538 : if (result == NULL) {
2859 : 14781840 : PyThreadState *tstate = _PyThreadState_GET();
2860 [ + + ]: 14781840 : if (_PyErr_Occurred(tstate)
2861 [ + + ]: 899 : && _PyErr_ExceptionMatches(tstate, PyExc_StopIteration))
2862 : : {
2863 : 308 : _PyErr_Clear(tstate);
2864 : : }
2865 : : }
2866 : 121743538 : return result;
2867 : : }
2868 : :
2869 : : PySendResult
2870 : 6775554 : PyIter_Send(PyObject *iter, PyObject *arg, PyObject **result)
2871 : : {
2872 : : assert(arg != NULL);
2873 : : assert(result != NULL);
2874 [ + + + + ]: 6775554 : if (Py_TYPE(iter)->tp_as_async && Py_TYPE(iter)->tp_as_async->am_send) {
2875 : 5691121 : PySendResult res = Py_TYPE(iter)->tp_as_async->am_send(iter, arg, result);
2876 : : assert(_Py_CheckSlotResult(iter, "am_send", res != PYGEN_ERROR));
2877 : 5691121 : return res;
2878 : : }
2879 [ + + + + ]: 1084433 : if (arg == Py_None && PyIter_Check(iter)) {
2880 : 1084420 : *result = Py_TYPE(iter)->tp_iternext(iter);
2881 : : }
2882 : : else {
2883 : 13 : *result = PyObject_CallMethodOneArg(iter, &_Py_ID(send), arg);
2884 : : }
2885 [ + + ]: 1084433 : if (*result != NULL) {
2886 : 1074908 : return PYGEN_NEXT;
2887 : : }
2888 [ + + ]: 9525 : if (_PyGen_FetchStopIterationValue(result) == 0) {
2889 : 9346 : return PYGEN_RETURN;
2890 : : }
2891 : 179 : return PYGEN_ERROR;
2892 : : }
2893 : :
2894 : : /*
2895 : : * Flatten a sequence of bytes() objects into a C array of
2896 : : * NULL terminated string pointers with a NULL char* terminating the array.
2897 : : * (ie: an argv or env list)
2898 : : *
2899 : : * Memory allocated for the returned list is allocated using PyMem_Malloc()
2900 : : * and MUST be freed by _Py_FreeCharPArray().
2901 : : */
2902 : : char *const *
2903 : 13025 : _PySequence_BytesToCharpArray(PyObject* self)
2904 : : {
2905 : : char **array;
2906 : : Py_ssize_t i, argc;
2907 : 13025 : PyObject *item = NULL;
2908 : : Py_ssize_t size;
2909 : :
2910 : 13025 : argc = PySequence_Size(self);
2911 [ + + ]: 13025 : if (argc == -1)
2912 : 2 : return NULL;
2913 : :
2914 : : assert(argc >= 0);
2915 : :
2916 [ + + ]: 13023 : if ((size_t)argc > (PY_SSIZE_T_MAX-sizeof(char *)) / sizeof(char *)) {
2917 : : PyErr_NoMemory();
2918 : 1 : return NULL;
2919 : : }
2920 : :
2921 : 13022 : array = PyMem_Malloc((argc + 1) * sizeof(char *));
2922 [ - + ]: 13022 : if (array == NULL) {
2923 : : PyErr_NoMemory();
2924 : 0 : return NULL;
2925 : : }
2926 [ + + ]: 252284 : for (i = 0; i < argc; ++i) {
2927 : : char *data;
2928 : 239269 : item = PySequence_GetItem(self, i);
2929 [ + + ]: 239269 : if (item == NULL) {
2930 : : /* NULL terminate before freeing. */
2931 : 1 : array[i] = NULL;
2932 : 7 : goto fail;
2933 : : }
2934 : : /* check for embedded null bytes */
2935 [ + + ]: 239268 : if (PyBytes_AsStringAndSize(item, &data, NULL) < 0) {
2936 : : /* NULL terminate before freeing. */
2937 : 6 : array[i] = NULL;
2938 : 6 : goto fail;
2939 : : }
2940 : 239262 : size = PyBytes_GET_SIZE(item) + 1;
2941 : 239262 : array[i] = PyMem_Malloc(size);
2942 [ - + ]: 239262 : if (!array[i]) {
2943 : : PyErr_NoMemory();
2944 : 0 : goto fail;
2945 : : }
2946 : 239262 : memcpy(array[i], data, size);
2947 : 239262 : Py_DECREF(item);
2948 : : }
2949 : 13015 : array[argc] = NULL;
2950 : :
2951 : 13015 : return array;
2952 : :
2953 : 7 : fail:
2954 : 7 : Py_XDECREF(item);
2955 : 7 : _Py_FreeCharPArray(array);
2956 : 7 : return NULL;
2957 : : }
2958 : :
2959 : :
2960 : : /* Free's a NULL terminated char** array of C strings. */
2961 : : void
2962 : 13022 : _Py_FreeCharPArray(char *const array[])
2963 : : {
2964 : : Py_ssize_t i;
2965 [ + + ]: 252284 : for (i = 0; array[i] != NULL; ++i) {
2966 : 239262 : PyMem_Free(array[i]);
2967 : : }
2968 : 13022 : PyMem_Free((void*)array);
2969 : 13022 : }
|
