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 68984 : type_error(const char *msg, PyObject *obj)
20 : {
21 68984 : PyErr_Format(PyExc_TypeError, msg, Py_TYPE(obj)->tp_name);
22 68984 : 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 26856 : PyObject_Type(PyObject *o)
40 : {
41 : PyObject *v;
42 :
43 26856 : if (o == NULL) {
44 0 : return null_error();
45 : }
46 :
47 26856 : v = (PyObject *)Py_TYPE(o);
48 26856 : Py_INCREF(v);
49 26856 : return v;
50 : }
51 :
52 : Py_ssize_t
53 32397900 : PyObject_Size(PyObject *o)
54 : {
55 32397900 : if (o == NULL) {
56 0 : null_error();
57 0 : return -1;
58 : }
59 :
60 32397900 : PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
61 32397900 : if (m && m->sq_length) {
62 31177000 : Py_ssize_t len = m->sq_length(o);
63 31177000 : assert(_Py_CheckSlotResult(o, "__len__", len >= 0));
64 31177000 : return len;
65 : }
66 :
67 1220910 : 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 1806740 : _PyObject_HasLen(PyObject *o) {
80 3358530 : return (Py_TYPE(o)->tp_as_sequence && Py_TYPE(o)->tp_as_sequence->sq_length) ||
81 1551780 : (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 1797320 : PyObject_LengthHint(PyObject *o, Py_ssize_t defaultvalue)
92 : {
93 : PyObject *hint, *result;
94 : Py_ssize_t res;
95 1797320 : if (_PyObject_HasLen(o)) {
96 380895 : res = PyObject_Length(o);
97 380895 : if (res < 0) {
98 5 : PyThreadState *tstate = _PyThreadState_GET();
99 5 : 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 380890 : return res;
107 : }
108 : }
109 1416420 : hint = _PyObject_LookupSpecial(o, &_Py_ID(__length_hint__));
110 1416420 : if (hint == NULL) {
111 996749 : if (PyErr_Occurred()) {
112 1 : return -1;
113 : }
114 996748 : return defaultvalue;
115 : }
116 419674 : result = _PyObject_CallNoArgs(hint);
117 419674 : Py_DECREF(hint);
118 419674 : 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 419667 : else if (result == Py_NotImplemented) {
127 49 : Py_DECREF(result);
128 49 : return defaultvalue;
129 : }
130 419618 : 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 419617 : res = PyLong_AsSsize_t(result);
137 419617 : Py_DECREF(result);
138 419617 : if (res < 0 && PyErr_Occurred()) {
139 0 : return -1;
140 : }
141 419617 : if (res < 0) {
142 1 : PyErr_Format(PyExc_ValueError, "__length_hint__() should return >= 0");
143 1 : return -1;
144 : }
145 419616 : return res;
146 : }
147 :
148 : PyObject *
149 131024000 : PyObject_GetItem(PyObject *o, PyObject *key)
150 : {
151 131024000 : if (o == NULL || key == NULL) {
152 0 : return null_error();
153 : }
154 :
155 131024000 : PyMappingMethods *m = Py_TYPE(o)->tp_as_mapping;
156 131024000 : if (m && m->mp_subscript) {
157 130893000 : PyObject *item = m->mp_subscript(o, key);
158 130893000 : assert(_Py_CheckSlotResult(o, "__getitem__", item != NULL));
159 130893000 : return item;
160 : }
161 :
162 131261 : PySequenceMethods *ms = Py_TYPE(o)->tp_as_sequence;
163 131261 : if (ms && ms->sq_item) {
164 102377 : if (_PyIndex_Check(key)) {
165 : Py_ssize_t key_value;
166 102377 : key_value = PyNumber_AsSsize_t(key, PyExc_IndexError);
167 102377 : if (key_value == -1 && PyErr_Occurred())
168 0 : return NULL;
169 102377 : 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 28884 : if (PyType_Check(o)) {
178 : PyObject *meth, *result;
179 :
180 : // Special case type[int], but disallow other types so str[int] fails
181 27490 : if ((PyTypeObject*)o == &PyType_Type) {
182 1401 : return Py_GenericAlias(o, key);
183 : }
184 :
185 26089 : if (_PyObject_LookupAttr(o, &_Py_ID(__class_getitem__), &meth) < 0) {
186 0 : return NULL;
187 : }
188 26089 : if (meth && meth != Py_None) {
189 26080 : result = PyObject_CallOneArg(meth, key);
190 26080 : Py_DECREF(meth);
191 26080 : 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 1394 : return type_error("'%.200s' object is not subscriptable", o);
200 : }
201 :
202 : int
203 10721500 : PyObject_SetItem(PyObject *o, PyObject *key, PyObject *value)
204 : {
205 10721500 : if (o == NULL || key == NULL || value == NULL) {
206 0 : null_error();
207 0 : return -1;
208 : }
209 :
210 10721500 : PyMappingMethods *m = Py_TYPE(o)->tp_as_mapping;
211 10721500 : if (m && m->mp_ass_subscript) {
212 10716400 : int res = m->mp_ass_subscript(o, key, value);
213 10716400 : assert(_Py_CheckSlotResult(o, "__setitem__", res >= 0));
214 10716400 : 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 2857820 : PyObject_DelItem(PyObject *o, PyObject *key)
238 : {
239 2857820 : if (o == NULL || key == NULL) {
240 0 : null_error();
241 0 : return -1;
242 : }
243 :
244 2857820 : PyMappingMethods *m = Py_TYPE(o)->tp_as_mapping;
245 2857820 : if (m && m->mp_ass_subscript) {
246 2854270 : int res = m->mp_ass_subscript(o, key, (PyObject*)NULL);
247 2854270 : assert(_Py_CheckSlotResult(o, "__delitem__", res >= 0));
248 2854270 : return res;
249 : }
250 :
251 3549 : if (Py_TYPE(o)->tp_as_sequence) {
252 3549 : if (_PyIndex_Check(key)) {
253 : Py_ssize_t key_value;
254 3544 : key_value = PyNumber_AsSsize_t(key, PyExc_IndexError);
255 3544 : if (key_value == -1 && PyErr_Occurred())
256 0 : return -1;
257 3544 : 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 7301260 : PyObject_CheckBuffer(PyObject *obj)
292 : {
293 7301260 : PyBufferProcs *tp_as_buffer = Py_TYPE(obj)->tp_as_buffer;
294 7301260 : 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 24814900 : PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags)
381 : {
382 24814900 : PyBufferProcs *pb = Py_TYPE(obj)->tp_as_buffer;
383 :
384 24814900 : if (pb == NULL || pb->bf_getbuffer == NULL) {
385 3399 : PyErr_Format(PyExc_TypeError,
386 : "a bytes-like object is required, not '%.100s'",
387 3399 : Py_TYPE(obj)->tp_name);
388 3399 : return -1;
389 : }
390 24811500 : int res = (*pb->bf_getbuffer)(obj, view, flags);
391 24811500 : assert(_Py_CheckSlotResult(obj, "getbuffer", res >= 0));
392 24811500 : return res;
393 : }
394 :
395 : static int
396 981660 : _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 981660 : if (view->len == 0) return 1;
405 981298 : if (view->strides == NULL) { /* C-contiguous by definition */
406 : /* Trivially F-contiguous */
407 6859 : if (view->ndim <= 1) return 1;
408 :
409 : /* ndim > 1 implies shape != NULL */
410 978 : assert(view->shape != NULL);
411 :
412 : /* Effectively 1-d */
413 978 : sd = 0;
414 3590 : for (i=0; i<view->ndim; i++) {
415 2612 : if (view->shape[i] > 1) sd += 1;
416 : }
417 978 : return sd <= 1;
418 : }
419 :
420 : /* strides != NULL implies both of these */
421 974439 : assert(view->ndim > 0);
422 974439 : assert(view->shape != NULL);
423 :
424 974439 : sd = view->itemsize;
425 1996670 : for (i=0; i<view->ndim; i++) {
426 1462380 : dim = view->shape[i];
427 1462380 : if (dim > 1 && view->strides[i] != sd) {
428 440155 : return 0;
429 : }
430 1022230 : sd *= dim;
431 : }
432 534284 : return 1;
433 : }
434 :
435 : static int
436 11278100 : _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 11278100 : if (view->len == 0) return 1;
445 10965100 : if (view->strides == NULL) return 1; /* C-contiguous by definition */
446 :
447 : /* strides != NULL implies both of these */
448 1306830 : assert(view->ndim > 0);
449 1306830 : assert(view->shape != NULL);
450 :
451 1306830 : sd = view->itemsize;
452 2825420 : for (i=view->ndim-1; i>=0; i--) {
453 1954570 : dim = view->shape[i];
454 1954570 : if (dim > 1 && view->strides[i] != sd) {
455 435985 : return 0;
456 : }
457 1518590 : sd *= dim;
458 : }
459 870849 : return 1;
460 : }
461 :
462 : int
463 12666300 : PyBuffer_IsContiguous(const Py_buffer *view, char order)
464 : {
465 :
466 12666300 : if (view->suboffsets != NULL) return 0;
467 :
468 12214400 : if (order == 'C')
469 11197800 : return _IsCContiguous(view);
470 1016560 : else if (order == 'F')
471 936291 : return _IsFortranContiguous(view);
472 80274 : else if (order == 'A')
473 80274 : return (_IsCContiguous(view) || _IsFortranContiguous(view));
474 0 : return 0;
475 : }
476 :
477 :
478 : void*
479 60309 : PyBuffer_GetPointer(const Py_buffer *view, const Py_ssize_t *indices)
480 : {
481 : char* pointer;
482 : int i;
483 60309 : pointer = (char *)view->buf;
484 155164 : for (i = 0; i < view->ndim; i++) {
485 94855 : pointer += view->strides[i]*indices[i];
486 94855 : if ((view->suboffsets != NULL) && (view->suboffsets[i] >= 0)) {
487 14150 : pointer = *((char**)pointer) + view->suboffsets[i];
488 : }
489 : }
490 60309 : 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 0 : 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 0 : 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 21424500 : PyBuffer_FillInfo(Py_buffer *view, PyObject *obj, void *buf, Py_ssize_t len,
710 : int readonly, int flags)
711 : {
712 21424500 : if (view == NULL) {
713 1 : PyErr_SetString(PyExc_BufferError,
714 : "PyBuffer_FillInfo: view==NULL argument is obsolete");
715 1 : return -1;
716 : }
717 :
718 21424500 : if (((flags & PyBUF_WRITABLE) == PyBUF_WRITABLE) &&
719 : (readonly == 1)) {
720 11 : PyErr_SetString(PyExc_BufferError,
721 : "Object is not writable.");
722 11 : return -1;
723 : }
724 :
725 21424500 : view->obj = obj;
726 21424500 : if (obj)
727 20445800 : Py_INCREF(obj);
728 21424500 : view->buf = buf;
729 21424500 : view->len = len;
730 21424500 : view->readonly = readonly;
731 21424500 : view->itemsize = 1;
732 21424500 : view->format = NULL;
733 21424500 : if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT)
734 944368 : view->format = "B";
735 21424500 : view->ndim = 1;
736 21424500 : view->shape = NULL;
737 21424500 : if ((flags & PyBUF_ND) == PyBUF_ND)
738 5337750 : view->shape = &(view->len);
739 21424500 : view->strides = NULL;
740 21424500 : if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES)
741 944368 : view->strides = &(view->itemsize);
742 21424500 : view->suboffsets = NULL;
743 21424500 : view->internal = NULL;
744 21424500 : return 0;
745 : }
746 :
747 : void
748 27475500 : PyBuffer_Release(Py_buffer *view)
749 : {
750 27475500 : PyObject *obj = view->obj;
751 : PyBufferProcs *pb;
752 27475500 : if (obj == NULL)
753 1392360 : return;
754 26083100 : pb = Py_TYPE(obj)->tp_as_buffer;
755 26083100 : if (pb && pb->bf_releasebuffer) {
756 5945690 : pb->bf_releasebuffer(obj, view);
757 : }
758 26083100 : view->obj = NULL;
759 26083100 : Py_DECREF(obj);
760 : }
761 :
762 : PyObject *
763 4027220 : PyObject_Format(PyObject *obj, PyObject *format_spec)
764 : {
765 : PyObject *meth;
766 4027220 : PyObject *empty = NULL;
767 4027220 : PyObject *result = NULL;
768 :
769 4027220 : 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 4027220 : if (format_spec == NULL || PyUnicode_GET_LENGTH(format_spec) == 0) {
778 367099 : if (PyUnicode_CheckExact(obj)) {
779 216 : Py_INCREF(obj);
780 216 : return obj;
781 : }
782 366883 : if (PyLong_CheckExact(obj)) {
783 350332 : return PyObject_Str(obj);
784 : }
785 : }
786 :
787 : /* If no format_spec is provided, use an empty string */
788 3676680 : if (format_spec == NULL) {
789 15740 : empty = PyUnicode_New(0, 0);
790 15740 : format_spec = empty;
791 : }
792 :
793 : /* Find the (unbound!) __format__ method */
794 3676680 : meth = _PyObject_LookupSpecial(obj, &_Py_ID(__format__));
795 3676680 : 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 3676680 : result = PyObject_CallOneArg(meth, format_spec);
807 3676680 : Py_DECREF(meth);
808 :
809 3676680 : 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 3676670 : done:
819 3676680 : Py_XDECREF(empty);
820 3676680 : return result;
821 : }
822 : /* Operations on numbers */
823 :
824 : int
825 1124520 : PyNumber_Check(PyObject *o)
826 : {
827 1124520 : if (o == NULL)
828 0 : return 0;
829 1124520 : PyNumberMethods *nb = Py_TYPE(o)->tp_as_number;
830 1124520 : 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 58897600 : 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 58897600 : if (Py_TYPE(v)->tp_as_number != NULL) {
860 58000000 : slotv = NB_BINOP(Py_TYPE(v)->tp_as_number, op_slot);
861 : }
862 : else {
863 897540 : slotv = NULL;
864 : }
865 :
866 : binaryfunc slotw;
867 58897600 : if (!Py_IS_TYPE(w, Py_TYPE(v)) && Py_TYPE(w)->tp_as_number != NULL) {
868 5310590 : slotw = NB_BINOP(Py_TYPE(w)->tp_as_number, op_slot);
869 5310590 : if (slotw == slotv) {
870 1029670 : slotw = NULL;
871 : }
872 : }
873 : else {
874 53587000 : slotw = NULL;
875 : }
876 :
877 58897600 : if (slotv) {
878 : PyObject *x;
879 51200000 : if (slotw && PyType_IsSubtype(Py_TYPE(w), Py_TYPE(v))) {
880 265742 : x = slotw(v, w);
881 265742 : if (x != Py_NotImplemented)
882 265742 : return x;
883 0 : Py_DECREF(x); /* can't do it */
884 0 : slotw = NULL;
885 : }
886 50934300 : x = slotv(v, w);
887 50934300 : assert(_Py_CheckSlotResult(v, op_name, x != NULL));
888 50934300 : if (x != Py_NotImplemented) {
889 49976700 : return x;
890 : }
891 957590 : Py_DECREF(x); /* can't do it */
892 : }
893 8655140 : if (slotw) {
894 2664040 : PyObject *x = slotw(v, w);
895 2664040 : assert(_Py_CheckSlotResult(w, op_name, x != NULL));
896 2664040 : if (x != Py_NotImplemented) {
897 866300 : return x;
898 : }
899 1797740 : Py_DECREF(x); /* can't do it */
900 : }
901 7788840 : 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 29521400 : binary_op(PyObject *v, PyObject *w, const int op_slot, const char *op_name)
924 : {
925 29521400 : PyObject *result = BINARY_OP1(v, w, op_slot, op_name);
926 29521400 : 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 29521100 : 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 1814690 : ternary_op(PyObject *v,
957 : PyObject *w,
958 : PyObject *z,
959 : const int op_slot,
960 : const char *op_name
961 : )
962 : {
963 1814690 : PyNumberMethods *mv = Py_TYPE(v)->tp_as_number;
964 1814690 : PyNumberMethods *mw = Py_TYPE(w)->tp_as_number;
965 :
966 : ternaryfunc slotv;
967 1814690 : if (mv != NULL) {
968 1814690 : slotv = NB_TERNOP(mv, op_slot);
969 : }
970 : else {
971 1 : slotv = NULL;
972 : }
973 :
974 : ternaryfunc slotw;
975 1814690 : 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 1456240 : slotw = NULL;
983 : }
984 :
985 1814690 : if (slotv) {
986 : PyObject *x;
987 1814680 : 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 1814680 : x = slotv(v, w, z);
996 1814680 : assert(_Py_CheckSlotResult(v, op_name, x != NULL));
997 1814680 : if (x != Py_NotImplemented) {
998 1814550 : 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 139 : 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 1 : 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 1536920 : BINARY_FUNC(PyNumber_Or, nb_or, "|")
1056 388615 : BINARY_FUNC(PyNumber_Xor, nb_xor, "^")
1057 7741980 : BINARY_FUNC(PyNumber_And, nb_and, "&")
1058 880550 : BINARY_FUNC(PyNumber_Lshift, nb_lshift, "<<")
1059 1459230 : BINARY_FUNC(PyNumber_Rshift, nb_rshift, ">>")
1060 4440380 : BINARY_FUNC(PyNumber_Subtract, nb_subtract, "-")
1061 1423870 : BINARY_FUNC(PyNumber_Divmod, nb_divmod, "divmod()")
1062 :
1063 : PyObject *
1064 15531300 : PyNumber_Add(PyObject *v, PyObject *w)
1065 : {
1066 15531300 : PyObject *result = BINARY_OP1(v, w, NB_SLOT(nb_add), "+");
1067 15531300 : if (result != Py_NotImplemented) {
1068 10062400 : return result;
1069 : }
1070 5468910 : Py_DECREF(result);
1071 :
1072 5468910 : PySequenceMethods *m = Py_TYPE(v)->tp_as_sequence;
1073 5468910 : if (m && m->sq_concat) {
1074 5468660 : result = (*m->sq_concat)(v, w);
1075 5468660 : assert(_Py_CheckSlotResult(v, "+", result != NULL));
1076 5468660 : return result;
1077 : }
1078 :
1079 258 : return binop_type_error(v, w, "+");
1080 : }
1081 :
1082 : static PyObject *
1083 1888270 : sequence_repeat(ssizeargfunc repeatfunc, PyObject *seq, PyObject *n)
1084 : {
1085 : Py_ssize_t count;
1086 1888270 : if (_PyIndex_Check(n)) {
1087 1888250 : count = PyNumber_AsSsize_t(n, PyExc_OverflowError);
1088 1888250 : 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 1888250 : PyObject *res = (*repeatfunc)(seq, count);
1097 1888250 : assert(_Py_CheckSlotResult(seq, "*", res != NULL));
1098 1888250 : return res;
1099 : }
1100 :
1101 : PyObject *
1102 9142130 : PyNumber_Multiply(PyObject *v, PyObject *w)
1103 : {
1104 9142130 : PyObject *result = BINARY_OP1(v, w, NB_SLOT(nb_multiply), "*");
1105 9142130 : if (result == Py_NotImplemented) {
1106 1887620 : PySequenceMethods *mv = Py_TYPE(v)->tp_as_sequence;
1107 1887620 : PySequenceMethods *mw = Py_TYPE(w)->tp_as_sequence;
1108 1887620 : Py_DECREF(result);
1109 1887620 : if (mv && mv->sq_repeat) {
1110 1797200 : return sequence_repeat(mv->sq_repeat, v, w);
1111 : }
1112 90426 : else if (mw && mw->sq_repeat) {
1113 90393 : return sequence_repeat(mw->sq_repeat, w, v);
1114 : }
1115 33 : result = binop_type_error(v, w, "*");
1116 : }
1117 7254540 : 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 3279780 : PyNumber_FloorDivide(PyObject *v, PyObject *w)
1128 : {
1129 3279780 : return binary_op(v, w, NB_SLOT(nb_floor_divide), "//");
1130 : }
1131 :
1132 : PyObject *
1133 5742900 : PyNumber_TrueDivide(PyObject *v, PyObject *w)
1134 : {
1135 5742900 : return binary_op(v, w, NB_SLOT(nb_true_divide), "/");
1136 : }
1137 :
1138 : PyObject *
1139 2627140 : PyNumber_Remainder(PyObject *v, PyObject *w)
1140 : {
1141 2627140 : return binary_op(v, w, NB_SLOT(nb_remainder), "%");
1142 : }
1143 :
1144 : PyObject *
1145 1814680 : PyNumber_Power(PyObject *v, PyObject *w, PyObject *z)
1146 : {
1147 1814680 : return ternary_op(v, w, z, NB_SLOT(nb_power), "** or pow()");
1148 : }
1149 :
1150 : PyObject *
1151 1695880 : _PyNumber_PowerNoMod(PyObject *lhs, PyObject *rhs)
1152 : {
1153 1695880 : 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 7129030 : 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 7129030 : PyNumberMethods *mv = Py_TYPE(v)->tp_as_number;
1180 7129030 : if (mv != NULL) {
1181 6888100 : binaryfunc slot = NB_BINOP(mv, iop_slot);
1182 6888100 : if (slot) {
1183 2426300 : PyObject *x = (slot)(v, w);
1184 2426300 : assert(_Py_CheckSlotResult(v, op_name, x != NULL));
1185 2426300 : if (x != Py_NotImplemented) {
1186 2426240 : return x;
1187 : }
1188 60 : Py_DECREF(x);
1189 : }
1190 : }
1191 : #ifdef NDEBUG
1192 : return binary_op1(v, w, op_slot);
1193 : #else
1194 4702790 : 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 6180450 : binary_iop(PyObject *v, PyObject *w, const int iop_slot, const int op_slot,
1206 : const char *op_name)
1207 : {
1208 6180450 : PyObject *result = BINARY_IOP1(v, w, iop_slot, op_slot, op_name);
1209 6180450 : if (result == Py_NotImplemented) {
1210 85 : Py_DECREF(result);
1211 85 : return binop_type_error(v, w, op_name);
1212 : }
1213 6180360 : 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 3085260 : INPLACE_BINOP(PyNumber_InPlaceOr, nb_inplace_or, nb_or, "|=")
1241 13712 : INPLACE_BINOP(PyNumber_InPlaceXor, nb_inplace_xor, nb_xor, "^=")
1242 58971 : 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 43606 : INPLACE_BINOP(PyNumber_InPlaceSubtract, nb_inplace_subtract, nb_subtract, "-=")
1246 16 : INPLACE_BINOP(PyNumber_InPlaceMatrixMultiply, nb_inplace_matrix_multiply, nb_matrix_multiply, "@=")
1247 307410 : INPLACE_BINOP(PyNumber_InPlaceFloorDivide, nb_inplace_floor_divide, nb_floor_divide, "//=")
1248 2098960 : INPLACE_BINOP(PyNumber_InPlaceTrueDivide, nb_inplace_true_divide, nb_true_divide, "/=")
1249 603 : INPLACE_BINOP(PyNumber_InPlaceRemainder, nb_inplace_remainder, nb_remainder, "%=")
1250 :
1251 : PyObject *
1252 936845 : PyNumber_InPlaceAdd(PyObject *v, PyObject *w)
1253 : {
1254 936845 : PyObject *result = BINARY_IOP1(v, w, NB_SLOT(nb_inplace_add),
1255 : NB_SLOT(nb_add), "+=");
1256 936845 : if (result == Py_NotImplemented) {
1257 431231 : PySequenceMethods *m = Py_TYPE(v)->tp_as_sequence;
1258 431231 : Py_DECREF(result);
1259 431231 : if (m != NULL) {
1260 431231 : binaryfunc func = m->sq_inplace_concat;
1261 431231 : if (func == NULL)
1262 236991 : func = m->sq_concat;
1263 431231 : if (func != NULL) {
1264 431224 : result = func(v, w);
1265 431224 : assert(_Py_CheckSlotResult(v, "+=", result != NULL));
1266 431224 : return result;
1267 : }
1268 : }
1269 7 : result = binop_type_error(v, w, "+=");
1270 : }
1271 505621 : return result;
1272 : }
1273 :
1274 : PyObject *
1275 11734 : PyNumber_InPlaceMultiply(PyObject *v, PyObject *w)
1276 : {
1277 11734 : PyObject *result = BINARY_IOP1(v, w, NB_SLOT(nb_inplace_multiply),
1278 : NB_SLOT(nb_multiply), "*=");
1279 11734 : 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 11055 : 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 1591310 : PyNumber_Negative(PyObject *o)
1321 : {
1322 1591310 : if (o == NULL) {
1323 0 : return null_error();
1324 : }
1325 :
1326 1591310 : PyNumberMethods *m = Py_TYPE(o)->tp_as_number;
1327 1591310 : if (m && m->nb_negative) {
1328 1591300 : PyObject *res = (*m->nb_negative)(o);
1329 1591300 : assert(_Py_CheckSlotResult(o, "__neg__", res != NULL));
1330 1591300 : return res;
1331 : }
1332 :
1333 8 : return type_error("bad operand type for unary -: '%.200s'", o);
1334 : }
1335 :
1336 : PyObject *
1337 608 : PyNumber_Positive(PyObject *o)
1338 : {
1339 608 : if (o == NULL) {
1340 0 : return null_error();
1341 : }
1342 :
1343 608 : PyNumberMethods *m = Py_TYPE(o)->tp_as_number;
1344 608 : if (m && m->nb_positive) {
1345 602 : PyObject *res = (*m->nb_positive)(o);
1346 602 : assert(_Py_CheckSlotResult(o, "__pos__", res != NULL));
1347 602 : return res;
1348 : }
1349 :
1350 6 : return type_error("bad operand type for unary +: '%.200s'", o);
1351 : }
1352 :
1353 : PyObject *
1354 824899 : PyNumber_Invert(PyObject *o)
1355 : {
1356 824899 : if (o == NULL) {
1357 0 : return null_error();
1358 : }
1359 :
1360 824899 : PyNumberMethods *m = Py_TYPE(o)->tp_as_number;
1361 824899 : if (m && m->nb_invert) {
1362 824888 : PyObject *res = (*m->nb_invert)(o);
1363 824888 : assert(_Py_CheckSlotResult(o, "__invert__", res != NULL));
1364 824888 : return res;
1365 : }
1366 :
1367 11 : return type_error("bad operand type for unary ~: '%.200s'", o);
1368 : }
1369 :
1370 : PyObject *
1371 2894090 : PyNumber_Absolute(PyObject *o)
1372 : {
1373 2894090 : if (o == NULL) {
1374 0 : return null_error();
1375 : }
1376 :
1377 2894090 : PyNumberMethods *m = Py_TYPE(o)->tp_as_number;
1378 2894090 : if (m && m->nb_absolute) {
1379 2894080 : PyObject *res = m->nb_absolute(o);
1380 2894080 : assert(_Py_CheckSlotResult(o, "__abs__", res != NULL));
1381 2894080 : return res;
1382 : }
1383 :
1384 4 : return type_error("bad operand type for abs(): '%.200s'", o);
1385 : }
1386 :
1387 :
1388 : int
1389 9707220 : PyIndex_Check(PyObject *obj)
1390 : {
1391 9707220 : 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 202412000 : _PyNumber_Index(PyObject *item)
1402 : {
1403 202412000 : if (item == NULL) {
1404 0 : return null_error();
1405 : }
1406 :
1407 202412000 : if (PyLong_Check(item)) {
1408 201347000 : Py_INCREF(item);
1409 201347000 : return item;
1410 : }
1411 1065300 : if (!_PyIndex_Check(item)) {
1412 1061970 : PyErr_Format(PyExc_TypeError,
1413 : "'%.200s' object cannot be interpreted "
1414 1061970 : "as an integer", Py_TYPE(item)->tp_name);
1415 1061970 : return NULL;
1416 : }
1417 :
1418 3336 : PyObject *result = Py_TYPE(item)->tp_as_number->nb_index(item);
1419 3336 : assert(_Py_CheckSlotResult(item, "__index__", result != NULL));
1420 3336 : if (!result || PyLong_CheckExact(result)) {
1421 2961 : 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 8363380 : PyNumber_Index(PyObject *item)
1449 : {
1450 8363380 : PyObject *result = _PyNumber_Index(item);
1451 8363380 : if (result != NULL && !PyLong_CheckExact(result)) {
1452 56 : Py_SETREF(result, _PyLong_Copy((PyLongObject *)result));
1453 : }
1454 8363380 : return result;
1455 : }
1456 :
1457 : /* Return an error on Overflow only if err is not NULL*/
1458 :
1459 : Py_ssize_t
1460 180067000 : PyNumber_AsSsize_t(PyObject *item, PyObject *err)
1461 : {
1462 : Py_ssize_t result;
1463 : PyObject *runerr;
1464 180067000 : PyObject *value = _PyNumber_Index(item);
1465 180067000 : if (value == NULL)
1466 753260 : return -1;
1467 :
1468 : /* We're done if PyLong_AsSsize_t() returns without error. */
1469 179314000 : result = PyLong_AsSsize_t(value);
1470 179314000 : if (result != -1)
1471 164665000 : goto finish;
1472 :
1473 14648600 : PyThreadState *tstate = _PyThreadState_GET();
1474 14648600 : runerr = _PyErr_Occurred(tstate);
1475 14648600 : if (!runerr) {
1476 14646100 : 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 2526 : 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 179314000 : finish:
1505 179314000 : Py_DECREF(value);
1506 179314000 : return result;
1507 : }
1508 :
1509 :
1510 : PyObject *
1511 3304870 : PyNumber_Long(PyObject *o)
1512 : {
1513 : PyObject *result;
1514 : PyNumberMethods *m;
1515 : PyObject *trunc_func;
1516 : Py_buffer view;
1517 :
1518 3304870 : if (o == NULL) {
1519 0 : return null_error();
1520 : }
1521 :
1522 3304870 : if (PyLong_CheckExact(o)) {
1523 1101980 : Py_INCREF(o);
1524 1101980 : return o;
1525 : }
1526 2202900 : m = Py_TYPE(o)->tp_as_number;
1527 2202900 : 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 1384690 : result = m->nb_int(o);
1531 1384690 : assert(_Py_CheckSlotResult(o, "__int__", result != NULL));
1532 1384690 : if (!result || PyLong_CheckExact(result)) {
1533 1384680 : 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 818207 : if (m && m->nb_index) {
1556 1 : return PyNumber_Index(o);
1557 : }
1558 818206 : trunc_func = _PyObject_LookupSpecial(o, &_Py_ID(__trunc__));
1559 818206 : 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 818181 : if (PyErr_Occurred())
1588 0 : return NULL;
1589 :
1590 818181 : if (PyUnicode_Check(o))
1591 : /* The below check is done in PyLong_FromUnicodeObject(). */
1592 632151 : return PyLong_FromUnicodeObject(o, 10);
1593 :
1594 186030 : 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 156986 : return _PyLong_FromBytes(PyBytes_AS_STRING(o),
1600 : PyBytes_GET_SIZE(o), 10);
1601 :
1602 29044 : if (PyByteArray_Check(o))
1603 26197 : return _PyLong_FromBytes(PyByteArray_AS_STRING(o),
1604 : PyByteArray_GET_SIZE(o), 10);
1605 :
1606 2847 : 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 2838 : 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 3414510 : PyNumber_Float(PyObject *o)
1628 : {
1629 3414510 : if (o == NULL) {
1630 0 : return null_error();
1631 : }
1632 :
1633 3414510 : if (PyFloat_CheckExact(o)) {
1634 17457 : return Py_NewRef(o);
1635 : }
1636 :
1637 3397050 : PyNumberMethods *m = Py_TYPE(o)->tp_as_number;
1638 3397050 : if (m && m->nb_float) { /* This should include subclasses of float */
1639 3396900 : PyObject *res = m->nb_float(o);
1640 3396900 : assert(_Py_CheckSlotResult(o, "__float__", res != NULL));
1641 3396900 : if (!res || PyFloat_CheckExact(res)) {
1642 3396890 : 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 515191 : PyNumber_ToBase(PyObject *n, int base)
1689 : {
1690 515191 : 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 515190 : PyObject *index = _PyNumber_Index(n);
1696 515190 : if (!index)
1697 13 : return NULL;
1698 515177 : PyObject *res = _PyLong_Format(index, base);
1699 515177 : Py_DECREF(index);
1700 515177 : return res;
1701 : }
1702 :
1703 :
1704 : /* Operations on sequences */
1705 :
1706 : int
1707 787523 : PySequence_Check(PyObject *s)
1708 : {
1709 787523 : if (PyDict_Check(s))
1710 1 : return 0;
1711 1551490 : return Py_TYPE(s)->tp_as_sequence &&
1712 763972 : Py_TYPE(s)->tp_as_sequence->sq_item != NULL;
1713 : }
1714 :
1715 : Py_ssize_t
1716 342979 : PySequence_Size(PyObject *s)
1717 : {
1718 342979 : if (s == NULL) {
1719 0 : null_error();
1720 0 : return -1;
1721 : }
1722 :
1723 342979 : PySequenceMethods *m = Py_TYPE(s)->tp_as_sequence;
1724 342979 : if (m && m->sq_length) {
1725 342963 : Py_ssize_t len = m->sq_length(s);
1726 342963 : assert(_Py_CheckSlotResult(s, "__len__", len >= 0));
1727 342963 : 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 54298 : PySequence_Concat(PyObject *s, PyObject *o)
1748 : {
1749 54298 : if (s == NULL || o == NULL) {
1750 0 : return null_error();
1751 : }
1752 :
1753 54298 : PySequenceMethods *m = Py_TYPE(s)->tp_as_sequence;
1754 54298 : if (m && m->sq_concat) {
1755 54294 : PyObject *res = m->sq_concat(s, o);
1756 54294 : assert(_Py_CheckSlotResult(s, "+", res != NULL));
1757 54294 : 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 0 : 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 0 : 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 0 : 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 0 : 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 0 : 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 7395750 : PySequence_GetItem(PyObject *s, Py_ssize_t i)
1868 : {
1869 7395750 : if (s == NULL) {
1870 0 : return null_error();
1871 : }
1872 :
1873 7395750 : PySequenceMethods *m = Py_TYPE(s)->tp_as_sequence;
1874 7395750 : if (m && m->sq_item) {
1875 7395740 : if (i < 0) {
1876 29531 : if (m->sq_length) {
1877 29531 : Py_ssize_t l = (*m->sq_length)(s);
1878 29531 : assert(_Py_CheckSlotResult(s, "__len__", l >= 0));
1879 29531 : if (l < 0) {
1880 0 : return NULL;
1881 : }
1882 29531 : i += l;
1883 : }
1884 : }
1885 7395740 : PyObject *res = m->sq_item(s, i);
1886 7395740 : assert(_Py_CheckSlotResult(s, "__getitem__", res != NULL));
1887 7395740 : 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 17245 : PySequence_GetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2)
1898 : {
1899 17245 : if (!s) {
1900 0 : return null_error();
1901 : }
1902 :
1903 17245 : PyMappingMethods *mp = Py_TYPE(s)->tp_as_mapping;
1904 17245 : if (mp && mp->mp_subscript) {
1905 17245 : PyObject *slice = _PySlice_FromIndices(i1, i2);
1906 17245 : if (!slice) {
1907 0 : return NULL;
1908 : }
1909 17245 : PyObject *res = mp->mp_subscript(s, slice);
1910 17245 : assert(_Py_CheckSlotResult(s, "__getitem__", res != NULL));
1911 17245 : Py_DECREF(slice);
1912 17245 : return res;
1913 : }
1914 :
1915 0 : return type_error("'%.200s' object is unsliceable", s);
1916 : }
1917 :
1918 : int
1919 5893 : PySequence_SetItem(PyObject *s, Py_ssize_t i, PyObject *o)
1920 : {
1921 5893 : if (s == NULL) {
1922 0 : null_error();
1923 0 : return -1;
1924 : }
1925 :
1926 5893 : PySequenceMethods *m = Py_TYPE(s)->tp_as_sequence;
1927 5893 : if (m && m->sq_ass_item) {
1928 5885 : if (i < 0) {
1929 0 : if (m->sq_length) {
1930 0 : Py_ssize_t l = (*m->sq_length)(s);
1931 0 : assert(_Py_CheckSlotResult(s, "__len__", l >= 0));
1932 0 : if (l < 0) {
1933 0 : return -1;
1934 : }
1935 0 : i += l;
1936 : }
1937 : }
1938 5885 : int res = m->sq_ass_item(s, i, o);
1939 5885 : assert(_Py_CheckSlotResult(s, "__setitem__", res >= 0));
1940 5885 : 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 354551 : PySequence_DelItem(PyObject *s, Py_ssize_t i)
1953 : {
1954 354551 : if (s == NULL) {
1955 0 : null_error();
1956 0 : return -1;
1957 : }
1958 :
1959 354551 : PySequenceMethods *m = Py_TYPE(s)->tp_as_sequence;
1960 354551 : if (m && m->sq_ass_item) {
1961 354549 : if (i < 0) {
1962 239 : if (m->sq_length) {
1963 239 : Py_ssize_t l = (*m->sq_length)(s);
1964 239 : assert(_Py_CheckSlotResult(s, "__len__", l >= 0));
1965 239 : if (l < 0) {
1966 0 : return -1;
1967 : }
1968 239 : i += l;
1969 : }
1970 : }
1971 354549 : int res = m->sq_ass_item(s, i, (PyObject *)NULL);
1972 354549 : assert(_Py_CheckSlotResult(s, "__delitem__", res >= 0));
1973 354549 : 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 0 : 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 0 : 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 11617100 : PySequence_Tuple(PyObject *v)
2032 : {
2033 : PyObject *it; /* iter(v) */
2034 : Py_ssize_t n; /* guess for result tuple size */
2035 11617100 : PyObject *result = NULL;
2036 : Py_ssize_t j;
2037 :
2038 11617100 : if (v == NULL) {
2039 0 : return null_error();
2040 : }
2041 :
2042 : /* Special-case the common tuple and list cases, for efficiency. */
2043 11617100 : 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 10080400 : Py_INCREF(v);
2049 10080400 : return v;
2050 : }
2051 1536670 : if (PyList_CheckExact(v))
2052 1239330 : return PyList_AsTuple(v);
2053 :
2054 : /* Get iterator. */
2055 297338 : it = PyObject_GetIter(v);
2056 297338 : if (it == NULL)
2057 32 : return NULL;
2058 :
2059 : /* Guess result size and allocate space. */
2060 297306 : n = PyObject_LengthHint(v, 10);
2061 297306 : if (n == -1)
2062 0 : goto Fail;
2063 297306 : result = PyTuple_New(n);
2064 297306 : if (result == NULL)
2065 0 : goto Fail;
2066 :
2067 : /* Fill the tuple. */
2068 3872490 : for (j = 0; ; ++j) {
2069 3872490 : PyObject *item = PyIter_Next(it);
2070 3872490 : if (item == NULL) {
2071 297306 : if (PyErr_Occurred())
2072 67 : goto Fail;
2073 297239 : break;
2074 : }
2075 3575180 : if (j >= n) {
2076 9493 : 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 9493 : newn += 10u;
2084 9493 : newn += newn >> 2;
2085 9493 : if (newn > PY_SSIZE_T_MAX) {
2086 : /* Check for overflow */
2087 0 : PyErr_NoMemory();
2088 0 : Py_DECREF(item);
2089 0 : goto Fail;
2090 : }
2091 9493 : n = (Py_ssize_t)newn;
2092 9493 : if (_PyTuple_Resize(&result, n) != 0) {
2093 0 : Py_DECREF(item);
2094 0 : goto Fail;
2095 : }
2096 : }
2097 3575180 : PyTuple_SET_ITEM(result, j, item);
2098 : }
2099 :
2100 : /* Cut tuple back if guess was too large. */
2101 472816 : if (j < n &&
2102 175577 : _PyTuple_Resize(&result, j) != 0)
2103 0 : goto Fail;
2104 :
2105 297239 : Py_DECREF(it);
2106 297239 : 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 1711950 : PySequence_List(PyObject *v)
2116 : {
2117 : PyObject *result; /* result list */
2118 : PyObject *rv; /* return value from PyList_Extend */
2119 :
2120 1711950 : if (v == NULL) {
2121 0 : return null_error();
2122 : }
2123 :
2124 1711950 : result = PyList_New(0);
2125 1711950 : if (result == NULL)
2126 0 : return NULL;
2127 :
2128 1711950 : rv = _PyList_Extend((PyListObject *)result, v);
2129 1711950 : if (rv == NULL) {
2130 32 : Py_DECREF(result);
2131 32 : return NULL;
2132 : }
2133 1711920 : Py_DECREF(rv);
2134 1711920 : return result;
2135 : }
2136 :
2137 : PyObject *
2138 20982800 : PySequence_Fast(PyObject *v, const char *m)
2139 : {
2140 : PyObject *it;
2141 :
2142 20982800 : if (v == NULL) {
2143 0 : return null_error();
2144 : }
2145 :
2146 20982800 : if (PyList_CheckExact(v) || PyTuple_CheckExact(v)) {
2147 20423200 : Py_INCREF(v);
2148 20423200 : return v;
2149 : }
2150 :
2151 559637 : it = PyObject_GetIter(v);
2152 559637 : if (it == NULL) {
2153 36 : PyThreadState *tstate = _PyThreadState_GET();
2154 36 : if (_PyErr_ExceptionMatches(tstate, PyExc_TypeError)) {
2155 36 : _PyErr_SetString(tstate, PyExc_TypeError, m);
2156 : }
2157 36 : return NULL;
2158 : }
2159 :
2160 559601 : v = PySequence_List(it);
2161 559601 : Py_DECREF(it);
2162 :
2163 559601 : 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 1177 : _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 1177 : if (seq == NULL || obj == NULL) {
2180 0 : null_error();
2181 0 : return -1;
2182 : }
2183 :
2184 1177 : it = PyObject_GetIter(seq);
2185 1177 : 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 1141 : n = wrapped = 0;
2193 6198 : for (;;) {
2194 : int cmp;
2195 7339 : PyObject *item = PyIter_Next(it);
2196 7339 : if (item == NULL) {
2197 124 : if (PyErr_Occurred())
2198 2 : goto Fail;
2199 122 : break;
2200 : }
2201 :
2202 7215 : cmp = PyObject_RichCompareBool(item, obj, Py_EQ);
2203 7215 : Py_DECREF(item);
2204 7215 : if (cmp < 0)
2205 2 : goto Fail;
2206 7213 : if (cmp > 0) {
2207 1051 : 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 651 : case PY_ITERSEARCH_CONTAINS:
2226 651 : n = 1;
2227 651 : goto Done;
2228 :
2229 0 : default:
2230 0 : Py_UNREACHABLE();
2231 : }
2232 6162 : }
2233 :
2234 6198 : if (operation == PY_ITERSEARCH_INDEX) {
2235 464 : if (n == PY_SSIZE_T_MAX)
2236 0 : wrapped = 1;
2237 464 : ++n;
2238 : }
2239 : }
2240 :
2241 122 : if (operation != PY_ITERSEARCH_INDEX)
2242 115 : 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 1141 : Done:
2251 1141 : Py_DECREF(it);
2252 1141 : 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 93727000 : PySequence_Contains(PyObject *seq, PyObject *ob)
2268 : {
2269 93727000 : PySequenceMethods *sqm = Py_TYPE(seq)->tp_as_sequence;
2270 93727000 : if (sqm != NULL && sqm->sq_contains != NULL) {
2271 93726200 : int res = (*sqm->sq_contains)(seq, ob);
2272 93726200 : assert(_Py_CheckSlotResult(seq, "__contains__", res >= 0));
2273 93726200 : return res;
2274 : }
2275 758 : Py_ssize_t result = _PySequence_IterSearch(seq, ob, PY_ITERSEARCH_CONTAINS);
2276 758 : 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 3672140 : PyMapping_Check(PyObject *o)
2297 : {
2298 6806600 : return o && Py_TYPE(o)->tp_as_mapping &&
2299 3134470 : Py_TYPE(o)->tp_as_mapping->mp_subscript;
2300 : }
2301 :
2302 : Py_ssize_t
2303 1221010 : PyMapping_Size(PyObject *o)
2304 : {
2305 1221010 : if (o == NULL) {
2306 0 : null_error();
2307 0 : return -1;
2308 : }
2309 :
2310 1221010 : PyMappingMethods *m = Py_TYPE(o)->tp_as_mapping;
2311 1221010 : if (m && m->mp_length) {
2312 1220670 : Py_ssize_t len = m->mp_length(o);
2313 1220670 : assert(_Py_CheckSlotResult(o, "__len__", len >= 0));
2314 1220670 : 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 16786 : PyMapping_GetItemString(PyObject *o, const char *key)
2336 : {
2337 : PyObject *okey, *r;
2338 :
2339 16786 : if (key == NULL) {
2340 0 : return null_error();
2341 : }
2342 :
2343 16786 : okey = PyUnicode_FromString(key);
2344 16786 : if (okey == NULL)
2345 0 : return NULL;
2346 16786 : r = PyObject_GetItem(o, okey);
2347 16786 : Py_DECREF(okey);
2348 16786 : return r;
2349 : }
2350 :
2351 : int
2352 8592 : PyMapping_SetItemString(PyObject *o, const char *key, PyObject *value)
2353 : {
2354 : PyObject *okey;
2355 : int r;
2356 :
2357 8592 : if (key == NULL) {
2358 0 : null_error();
2359 0 : return -1;
2360 : }
2361 :
2362 8592 : okey = PyUnicode_FromString(key);
2363 8592 : if (okey == NULL)
2364 0 : return -1;
2365 8592 : r = PyObject_SetItem(o, okey, value);
2366 8592 : Py_DECREF(okey);
2367 8592 : 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 277078 : method_output_as_list(PyObject *o, PyObject *meth)
2403 : {
2404 : PyObject *it, *result, *meth_output;
2405 :
2406 277078 : assert(o != NULL);
2407 277078 : meth_output = PyObject_CallMethodNoArgs(o, meth);
2408 277078 : if (meth_output == NULL || PyList_CheckExact(meth_output)) {
2409 41 : return meth_output;
2410 : }
2411 277037 : it = PyObject_GetIter(meth_output);
2412 277037 : 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 277033 : Py_DECREF(meth_output);
2425 277033 : result = PySequence_List(it);
2426 277033 : Py_DECREF(it);
2427 277033 : return result;
2428 : }
2429 :
2430 : PyObject *
2431 127491 : PyMapping_Keys(PyObject *o)
2432 : {
2433 127491 : if (o == NULL) {
2434 0 : return null_error();
2435 : }
2436 127491 : if (PyDict_CheckExact(o)) {
2437 26803 : return PyDict_Keys(o);
2438 : }
2439 100688 : return method_output_as_list(o, &_Py_ID(keys));
2440 : }
2441 :
2442 : PyObject *
2443 177505 : PyMapping_Items(PyObject *o)
2444 : {
2445 177505 : if (o == NULL) {
2446 0 : return null_error();
2447 : }
2448 177505 : if (PyDict_CheckExact(o)) {
2449 1212 : return PyDict_Items(o);
2450 : }
2451 176293 : 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 84 : 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 24270700 : object_isinstance(PyObject *inst, PyObject *cls)
2575 : {
2576 : PyObject *icls;
2577 : int retval;
2578 24270700 : if (PyType_Check(cls)) {
2579 24270700 : retval = PyObject_TypeCheck(inst, (PyTypeObject *)cls);
2580 24270700 : if (retval == 0) {
2581 21635800 : retval = _PyObject_LookupAttr(inst, &_Py_ID(__class__), &icls);
2582 21635800 : if (icls != NULL) {
2583 21635800 : if (icls != (PyObject *)(Py_TYPE(inst)) && PyType_Check(icls)) {
2584 1201 : retval = PyType_IsSubtype(
2585 : (PyTypeObject *)icls,
2586 : (PyTypeObject *)cls);
2587 : }
2588 : else {
2589 21634600 : retval = 0;
2590 : }
2591 21635800 : 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 24270700 : return retval;
2607 : }
2608 :
2609 : static int
2610 48726300 : object_recursive_isinstance(PyThreadState *tstate, PyObject *inst, PyObject *cls)
2611 : {
2612 : /* Quick test for an exact match */
2613 48726300 : if (Py_IS_TYPE(inst, (PyTypeObject *)cls)) {
2614 19438700 : return 1;
2615 : }
2616 :
2617 : /* We know what type's __instancecheck__ does. */
2618 29287600 : if (PyType_CheckExact(cls)) {
2619 23891300 : return object_isinstance(inst, cls);
2620 : }
2621 :
2622 5396290 : if (_PyUnion_Check(cls)) {
2623 20 : cls = _Py_union_args(cls);
2624 : }
2625 :
2626 5396290 : if (PyTuple_Check(cls)) {
2627 : /* Not a general sequence -- that opens up the road to
2628 : recursion and stack overflow. */
2629 4472430 : if (_Py_EnterRecursiveCallTstate(tstate, " in __instancecheck__")) {
2630 2 : return -1;
2631 : }
2632 4472430 : Py_ssize_t n = PyTuple_GET_SIZE(cls);
2633 4472430 : int r = 0;
2634 5883530 : for (Py_ssize_t i = 0; i < n; ++i) {
2635 5335620 : PyObject *item = PyTuple_GET_ITEM(cls, i);
2636 5335620 : r = object_recursive_isinstance(tstate, inst, item);
2637 5335620 : if (r != 0) {
2638 : /* either found it, or got an error */
2639 3924520 : break;
2640 : }
2641 : }
2642 4472430 : _Py_LeaveRecursiveCallTstate(tstate);
2643 4472430 : return r;
2644 : }
2645 :
2646 923861 : PyObject *checker = _PyObject_LookupSpecial(cls, &_Py_ID(__instancecheck__));
2647 923861 : if (checker != NULL) {
2648 923845 : if (_Py_EnterRecursiveCallTstate(tstate, " in __instancecheck__")) {
2649 0 : Py_DECREF(checker);
2650 0 : return -1;
2651 : }
2652 :
2653 923845 : PyObject *res = PyObject_CallOneArg(checker, inst);
2654 923845 : _Py_LeaveRecursiveCallTstate(tstate);
2655 923845 : Py_DECREF(checker);
2656 :
2657 923845 : if (res == NULL) {
2658 50 : return -1;
2659 : }
2660 923795 : int ok = PyObject_IsTrue(res);
2661 923795 : Py_DECREF(res);
2662 :
2663 923795 : 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 43390700 : PyObject_IsInstance(PyObject *inst, PyObject *cls)
2676 : {
2677 43390700 : PyThreadState *tstate = _PyThreadState_GET();
2678 43390700 : return object_recursive_isinstance(tstate, inst, cls);
2679 : }
2680 :
2681 :
2682 : static int
2683 12629600 : recursive_issubclass(PyObject *derived, PyObject *cls)
2684 : {
2685 12629600 : if (PyType_Check(cls) && PyType_Check(derived)) {
2686 : /* Fast path (non-recursive) */
2687 12629500 : 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 4192870 : object_issubclass(PyThreadState *tstate, PyObject *derived, PyObject *cls)
2704 : {
2705 : PyObject *checker;
2706 :
2707 : /* We know what type's __subclasscheck__ does. */
2708 4192870 : if (PyType_CheckExact(cls)) {
2709 : /* Quick test for an exact match */
2710 3668810 : if (derived == cls)
2711 3035370 : return 1;
2712 633438 : return recursive_issubclass(derived, cls);
2713 : }
2714 :
2715 524062 : if (_PyUnion_Check(cls)) {
2716 18 : cls = _Py_union_args(cls);
2717 : }
2718 :
2719 524062 : if (PyTuple_Check(cls)) {
2720 :
2721 33796 : if (_Py_EnterRecursiveCallTstate(tstate, " in __subclasscheck__")) {
2722 1 : return -1;
2723 : }
2724 33795 : Py_ssize_t n = PyTuple_GET_SIZE(cls);
2725 33795 : int r = 0;
2726 58470 : for (Py_ssize_t i = 0; i < n; ++i) {
2727 58432 : PyObject *item = PyTuple_GET_ITEM(cls, i);
2728 58432 : r = object_issubclass(tstate, derived, item);
2729 58432 : if (r != 0)
2730 : /* either found it, or got an error */
2731 33757 : break;
2732 : }
2733 33795 : _Py_LeaveRecursiveCallTstate(tstate);
2734 33795 : return r;
2735 : }
2736 :
2737 490266 : checker = _PyObject_LookupSpecial(cls, &_Py_ID(__subclasscheck__));
2738 490266 : if (checker != NULL) {
2739 490237 : int ok = -1;
2740 490237 : if (_Py_EnterRecursiveCallTstate(tstate, " in __subclasscheck__")) {
2741 0 : Py_DECREF(checker);
2742 0 : return ok;
2743 : }
2744 490237 : PyObject *res = PyObject_CallOneArg(checker, derived);
2745 490237 : _Py_LeaveRecursiveCallTstate(tstate);
2746 490237 : Py_DECREF(checker);
2747 490237 : if (res != NULL) {
2748 490168 : ok = PyObject_IsTrue(res);
2749 490168 : Py_DECREF(res);
2750 : }
2751 490237 : 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 4134440 : PyObject_IsSubclass(PyObject *derived, PyObject *cls)
2764 : {
2765 4134440 : PyThreadState *tstate = _PyThreadState_GET();
2766 4134440 : return object_issubclass(tstate, derived, cls);
2767 : }
2768 :
2769 :
2770 : int
2771 379397 : _PyObject_RealIsInstance(PyObject *inst, PyObject *cls)
2772 : {
2773 379397 : return object_isinstance(inst, cls);
2774 : }
2775 :
2776 : int
2777 11996100 : _PyObject_RealIsSubclass(PyObject *derived, PyObject *cls)
2778 : {
2779 11996100 : return recursive_issubclass(derived, cls);
2780 : }
2781 :
2782 :
2783 : PyObject *
2784 76082900 : PyObject_GetIter(PyObject *o)
2785 : {
2786 76082900 : PyTypeObject *t = Py_TYPE(o);
2787 : getiterfunc f;
2788 :
2789 76082900 : f = t->tp_iter;
2790 76082900 : if (f == NULL) {
2791 414490 : if (PySequence_Check(o))
2792 350249 : return PySeqIter_New(o);
2793 64241 : return type_error("'%.200s' object is not iterable", o);
2794 : }
2795 : else {
2796 75668400 : PyObject *res = (*f)(o);
2797 75668400 : 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 75668400 : 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 79682200 : PyIter_Check(PyObject *obj)
2831 : {
2832 79682200 : PyTypeObject *tp = Py_TYPE(obj);
2833 159364000 : return (tp->tp_iternext != NULL &&
2834 79682100 : 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 122063000 : PyIter_Next(PyObject *iter)
2855 : {
2856 : PyObject *result;
2857 122063000 : result = (*Py_TYPE(iter)->tp_iternext)(iter);
2858 122063000 : if (result == NULL) {
2859 14966600 : PyThreadState *tstate = _PyThreadState_GET();
2860 14966600 : if (_PyErr_Occurred(tstate)
2861 902 : && _PyErr_ExceptionMatches(tstate, PyExc_StopIteration))
2862 : {
2863 308 : _PyErr_Clear(tstate);
2864 : }
2865 : }
2866 122063000 : return result;
2867 : }
2868 :
2869 : PySendResult
2870 6806660 : PyIter_Send(PyObject *iter, PyObject *arg, PyObject **result)
2871 : {
2872 6806660 : assert(arg != NULL);
2873 6806660 : assert(result != NULL);
2874 6806660 : if (Py_TYPE(iter)->tp_as_async && Py_TYPE(iter)->tp_as_async->am_send) {
2875 5722430 : PySendResult res = Py_TYPE(iter)->tp_as_async->am_send(iter, arg, result);
2876 5722430 : assert(_Py_CheckSlotResult(iter, "am_send", res != PYGEN_ERROR));
2877 5722430 : return res;
2878 : }
2879 1084230 : if (arg == Py_None && PyIter_Check(iter)) {
2880 1084220 : *result = Py_TYPE(iter)->tp_iternext(iter);
2881 : }
2882 : else {
2883 13 : *result = PyObject_CallMethodOneArg(iter, &_Py_ID(send), arg);
2884 : }
2885 1084230 : if (*result != NULL) {
2886 1074710 : return PYGEN_NEXT;
2887 : }
2888 9517 : if (_PyGen_FetchStopIterationValue(result) == 0) {
2889 9338 : 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 13209 : _PySequence_BytesToCharpArray(PyObject* self)
2904 : {
2905 : char **array;
2906 : Py_ssize_t i, argc;
2907 13209 : PyObject *item = NULL;
2908 : Py_ssize_t size;
2909 :
2910 13209 : argc = PySequence_Size(self);
2911 13209 : if (argc == -1)
2912 2 : return NULL;
2913 :
2914 13207 : assert(argc >= 0);
2915 :
2916 13207 : if ((size_t)argc > (PY_SSIZE_T_MAX-sizeof(char *)) / sizeof(char *)) {
2917 1 : PyErr_NoMemory();
2918 1 : return NULL;
2919 : }
2920 :
2921 13206 : array = PyMem_Malloc((argc + 1) * sizeof(char *));
2922 13206 : if (array == NULL) {
2923 0 : PyErr_NoMemory();
2924 0 : return NULL;
2925 : }
2926 294704 : for (i = 0; i < argc; ++i) {
2927 : char *data;
2928 281505 : item = PySequence_GetItem(self, i);
2929 281505 : 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 281504 : if (PyBytes_AsStringAndSize(item, &data, NULL) < 0) {
2936 : /* NULL terminate before freeing. */
2937 6 : array[i] = NULL;
2938 6 : goto fail;
2939 : }
2940 281498 : size = PyBytes_GET_SIZE(item) + 1;
2941 281498 : array[i] = PyMem_Malloc(size);
2942 281498 : if (!array[i]) {
2943 0 : PyErr_NoMemory();
2944 0 : goto fail;
2945 : }
2946 281498 : memcpy(array[i], data, size);
2947 281498 : Py_DECREF(item);
2948 : }
2949 13199 : array[argc] = NULL;
2950 :
2951 13199 : 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 13206 : _Py_FreeCharPArray(char *const array[])
2963 : {
2964 : Py_ssize_t i;
2965 294704 : for (i = 0; array[i] != NULL; ++i) {
2966 281498 : PyMem_Free(array[i]);
2967 : }
2968 13206 : PyMem_Free((void*)array);
2969 13206 : }
|
