Nuitka
The Python compiler
Loading...
Searching...
No Matches
HelpersOperationBinaryRshift.c
1// Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
2
3/* WARNING, this code is GENERATED. Modify the template HelperOperationBinary.c.j2 instead! */
4
5/* This file is included from another C file, help IDEs to still parse it on its own. */
6#ifdef __IDE_ONLY__
7#include "nuitka/prelude.h"
8#endif
9
10/* C helpers for type specialized ">>" (RSHIFT) operations */
11
12/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
13static PyObject *_BINARY_OPERATION_RSHIFT_OBJECT_LONG_LONG(PyObject *operand1, PyObject *operand2) {
14 CHECK_OBJECT(operand1);
15 assert(PyLong_CheckExact(operand1));
16 CHECK_OBJECT(operand2);
17 assert(PyLong_CheckExact(operand2));
18
19 PyObject *result;
20
21 // Not every code path will make use of all possible results.
22#if defined(_MSC_VER)
23#pragma warning(push)
24#pragma warning(disable : 4101)
25#endif
26 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
27 NUITKA_MAY_BE_UNUSED long clong_result;
28#if defined(_MSC_VER)
29#pragma warning(pop)
30#endif
31
32 PyObject *x = PyLong_Type.tp_as_number->nb_rshift(operand1, operand2);
33 assert(x != Py_NotImplemented);
34
35 obj_result = x;
36 goto exit_result_object;
37
38exit_result_object:
39 if (unlikely(obj_result == NULL)) {
40 goto exit_result_exception;
41 }
42 result = obj_result;
43 goto exit_result_ok;
44
45exit_result_ok:
46 return result;
47
48exit_result_exception:
49 return NULL;
50}
51
52PyObject *BINARY_OPERATION_RSHIFT_OBJECT_LONG_LONG(PyObject *operand1, PyObject *operand2) {
53 return _BINARY_OPERATION_RSHIFT_OBJECT_LONG_LONG(operand1, operand2);
54}
55
56/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
57static HEDLEY_NEVER_INLINE PyObject *__BINARY_OPERATION_RSHIFT_OBJECT_OBJECT_LONG(PyObject *operand1,
58 PyObject *operand2) {
59 PyTypeObject *type1 = Py_TYPE(operand1);
60
61#if defined(_MSC_VER)
62#pragma warning(push)
63#pragma warning(disable : 4101)
64#endif
65 NUITKA_MAY_BE_UNUSED bool cbool_result;
66 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
67#if defined(_MSC_VER)
68#pragma warning(pop)
69#endif
70
71 binaryfunc slot1 =
72 (type1->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type1)) ? type1->tp_as_number->nb_rshift : NULL;
73 binaryfunc slot2 = NULL;
74
75 if (!(type1 == &PyLong_Type)) {
76 // Different types, need to consider second value slot.
77
78 slot2 = PyLong_Type.tp_as_number->nb_rshift;
79
80 if (slot1 == slot2) {
81 slot2 = NULL;
82 }
83 }
84
85 if (slot1 != NULL) {
86 PyObject *x = slot1(operand1, operand2);
87
88 if (x != Py_NotImplemented) {
89 obj_result = x;
90 goto exit_binary_result_object;
91 }
92
93 Py_DECREF_IMMORTAL(x);
94 }
95
96 if (slot2 != NULL) {
97 PyObject *x = slot2(operand1, operand2);
98
99 if (x != Py_NotImplemented) {
100 obj_result = x;
101 goto exit_binary_result_object;
102 }
103
104 Py_DECREF_IMMORTAL(x);
105 }
106
107#if PYTHON_VERSION < 0x300
108 if (!NEW_STYLE_NUMBER_TYPE(type1) || !1) {
109 coercion c1 =
110 (type1->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type1)) ? type1->tp_as_number->nb_coerce : NULL;
111
112 if (c1 != NULL) {
113 PyObject *coerced1 = operand1;
114 PyObject *coerced2 = operand2;
115
116 int err = c1(&coerced1, &coerced2);
117
118 if (unlikely(err < 0)) {
119 goto exit_binary_exception;
120 }
121
122 if (err == 0) {
123 PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
124
125 if (likely(mv == NULL)) {
126 binaryfunc slot = mv->nb_rshift;
127
128 if (likely(slot != NULL)) {
129 PyObject *x = slot(coerced1, coerced2);
130
131 Py_DECREF(coerced1);
132 Py_DECREF(coerced2);
133
134 obj_result = x;
135 goto exit_binary_result_object;
136 }
137 }
138
139 // nb_coerce took a reference.
140 Py_DECREF(coerced1);
141 Py_DECREF(coerced2);
142 }
143 }
144 coercion c2 = PyLong_Type.tp_as_number->nb_coerce;
145
146 if (c2 != NULL) {
147 PyObject *coerced1 = operand1;
148 PyObject *coerced2 = operand2;
149
150 int err = c2(&coerced2, &coerced1);
151
152 if (unlikely(err < 0)) {
153 goto exit_binary_exception;
154 }
155
156 if (err == 0) {
157 PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
158
159 if (likely(mv == NULL)) {
160 binaryfunc slot = mv->nb_rshift;
161
162 if (likely(slot != NULL)) {
163 PyObject *x = slot(coerced1, coerced2);
164
165 Py_DECREF(coerced1);
166 Py_DECREF(coerced2);
167
168 obj_result = x;
169 goto exit_binary_result_object;
170 }
171 }
172
173 // nb_coerce took a reference.
174 Py_DECREF(coerced1);
175 Py_DECREF(coerced2);
176 }
177 }
178 }
179#endif
180
181#if PYTHON_VERSION < 0x300
182 PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for >>: '%s' and 'long'", type1->tp_name);
183#else
184 PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for >>: '%s' and 'int'", type1->tp_name);
185#endif
186 goto exit_binary_exception;
187
188exit_binary_result_object:
189 return obj_result;
190
191exit_binary_exception:
192 return NULL;
193}
194static PyObject *_BINARY_OPERATION_RSHIFT_OBJECT_OBJECT_LONG(PyObject *operand1, PyObject *operand2) {
195 CHECK_OBJECT(operand1);
196 CHECK_OBJECT(operand2);
197 assert(PyLong_CheckExact(operand2));
198
199 PyTypeObject *type1 = Py_TYPE(operand1);
200
201 if (type1 == &PyLong_Type) {
202 PyObject *result;
203
204 // return _BINARY_OPERATION_RSHIFT_OBJECT_LONG_LONG(operand1, operand2);
205
206 // Not every code path will make use of all possible results.
207#if defined(_MSC_VER)
208#pragma warning(push)
209#pragma warning(disable : 4101)
210#endif
211 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
212 NUITKA_MAY_BE_UNUSED long clong_result;
213#if defined(_MSC_VER)
214#pragma warning(pop)
215#endif
216
217 PyObject *x = PyLong_Type.tp_as_number->nb_rshift(operand1, operand2);
218 assert(x != Py_NotImplemented);
219
220 obj_result = x;
221 goto exit_result_object;
222
223 exit_result_object:
224 if (unlikely(obj_result == NULL)) {
225 goto exit_result_exception;
226 }
227 result = obj_result;
228 goto exit_result_ok;
229
230 exit_result_ok:
231 return result;
232
233 exit_result_exception:
234 return NULL;
235 }
236
237 return __BINARY_OPERATION_RSHIFT_OBJECT_OBJECT_LONG(operand1, operand2);
238}
239
240PyObject *BINARY_OPERATION_RSHIFT_OBJECT_OBJECT_LONG(PyObject *operand1, PyObject *operand2) {
241 return _BINARY_OPERATION_RSHIFT_OBJECT_OBJECT_LONG(operand1, operand2);
242}
243
244/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
245static HEDLEY_NEVER_INLINE PyObject *__BINARY_OPERATION_RSHIFT_OBJECT_LONG_OBJECT(PyObject *operand1,
246 PyObject *operand2) {
247 PyTypeObject *type2 = Py_TYPE(operand2);
248
249#if defined(_MSC_VER)
250#pragma warning(push)
251#pragma warning(disable : 4101)
252#endif
253 NUITKA_MAY_BE_UNUSED bool cbool_result;
254 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
255#if defined(_MSC_VER)
256#pragma warning(pop)
257#endif
258
259 binaryfunc slot1 = PyLong_Type.tp_as_number->nb_rshift;
260 binaryfunc slot2 = NULL;
261
262 if (!(&PyLong_Type == type2)) {
263 // Different types, need to consider second value slot.
264
265 slot2 = (type2->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type2)) ? type2->tp_as_number->nb_rshift : NULL;
266
267 if (slot1 == slot2) {
268 slot2 = NULL;
269 }
270 }
271
272 if (slot1 != NULL) {
273 if (slot2 != NULL) {
274 if (Nuitka_Type_IsSubtype(type2, &PyLong_Type)) {
275 PyObject *x = slot2(operand1, operand2);
276
277 if (x != Py_NotImplemented) {
278 obj_result = x;
279 goto exit_binary_result_object;
280 }
281
282 Py_DECREF_IMMORTAL(x);
283 slot2 = NULL;
284 }
285 }
286
287 PyObject *x = slot1(operand1, operand2);
288
289 if (x != Py_NotImplemented) {
290 obj_result = x;
291 goto exit_binary_result_object;
292 }
293
294 Py_DECREF_IMMORTAL(x);
295 }
296
297 if (slot2 != NULL) {
298 PyObject *x = slot2(operand1, operand2);
299
300 if (x != Py_NotImplemented) {
301 obj_result = x;
302 goto exit_binary_result_object;
303 }
304
305 Py_DECREF_IMMORTAL(x);
306 }
307
308#if PYTHON_VERSION < 0x300
309 if (!1 || !NEW_STYLE_NUMBER_TYPE(type2)) {
310 coercion c1 = PyLong_Type.tp_as_number->nb_coerce;
311
312 if (c1 != NULL) {
313 PyObject *coerced1 = operand1;
314 PyObject *coerced2 = operand2;
315
316 int err = c1(&coerced1, &coerced2);
317
318 if (unlikely(err < 0)) {
319 goto exit_binary_exception;
320 }
321
322 if (err == 0) {
323 PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
324
325 if (likely(mv == NULL)) {
326 binaryfunc slot = mv->nb_rshift;
327
328 if (likely(slot != NULL)) {
329 PyObject *x = slot(coerced1, coerced2);
330
331 Py_DECREF(coerced1);
332 Py_DECREF(coerced2);
333
334 obj_result = x;
335 goto exit_binary_result_object;
336 }
337 }
338
339 // nb_coerce took a reference.
340 Py_DECREF(coerced1);
341 Py_DECREF(coerced2);
342 }
343 }
344 coercion c2 =
345 (type2->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type2)) ? type2->tp_as_number->nb_coerce : NULL;
346
347 if (c2 != NULL) {
348 PyObject *coerced1 = operand1;
349 PyObject *coerced2 = operand2;
350
351 int err = c2(&coerced2, &coerced1);
352
353 if (unlikely(err < 0)) {
354 goto exit_binary_exception;
355 }
356
357 if (err == 0) {
358 PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
359
360 if (likely(mv == NULL)) {
361 binaryfunc slot = mv->nb_rshift;
362
363 if (likely(slot != NULL)) {
364 PyObject *x = slot(coerced1, coerced2);
365
366 Py_DECREF(coerced1);
367 Py_DECREF(coerced2);
368
369 obj_result = x;
370 goto exit_binary_result_object;
371 }
372 }
373
374 // nb_coerce took a reference.
375 Py_DECREF(coerced1);
376 Py_DECREF(coerced2);
377 }
378 }
379 }
380#endif
381
382#if PYTHON_VERSION < 0x300
383 PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for >>: 'long' and '%s'", type2->tp_name);
384#else
385 PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for >>: 'int' and '%s'", type2->tp_name);
386#endif
387 goto exit_binary_exception;
388
389exit_binary_result_object:
390 return obj_result;
391
392exit_binary_exception:
393 return NULL;
394}
395static PyObject *_BINARY_OPERATION_RSHIFT_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *operand2) {
396 CHECK_OBJECT(operand1);
397 assert(PyLong_CheckExact(operand1));
398 CHECK_OBJECT(operand2);
399
400 PyTypeObject *type2 = Py_TYPE(operand2);
401
402 if (&PyLong_Type == type2) {
403 PyObject *result;
404
405 // return _BINARY_OPERATION_RSHIFT_OBJECT_LONG_LONG(operand1, operand2);
406
407 // Not every code path will make use of all possible results.
408#if defined(_MSC_VER)
409#pragma warning(push)
410#pragma warning(disable : 4101)
411#endif
412 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
413 NUITKA_MAY_BE_UNUSED long clong_result;
414#if defined(_MSC_VER)
415#pragma warning(pop)
416#endif
417
418 PyObject *x = PyLong_Type.tp_as_number->nb_rshift(operand1, operand2);
419 assert(x != Py_NotImplemented);
420
421 obj_result = x;
422 goto exit_result_object;
423
424 exit_result_object:
425 if (unlikely(obj_result == NULL)) {
426 goto exit_result_exception;
427 }
428 result = obj_result;
429 goto exit_result_ok;
430
431 exit_result_ok:
432 return result;
433
434 exit_result_exception:
435 return NULL;
436 }
437
438 return __BINARY_OPERATION_RSHIFT_OBJECT_LONG_OBJECT(operand1, operand2);
439}
440
441PyObject *BINARY_OPERATION_RSHIFT_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *operand2) {
442 return _BINARY_OPERATION_RSHIFT_OBJECT_LONG_OBJECT(operand1, operand2);
443}
444
445/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "LONG" to Python2 'long', Python3 'int'. */
446static nuitka_bool _BINARY_OPERATION_RSHIFT_NBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2) {
447 CHECK_OBJECT(operand1);
448 assert(PyLong_CheckExact(operand1));
449 CHECK_OBJECT(operand2);
450 assert(PyLong_CheckExact(operand2));
451
452 nuitka_bool result;
453
454 // Not every code path will make use of all possible results.
455#if defined(_MSC_VER)
456#pragma warning(push)
457#pragma warning(disable : 4101)
458#endif
459 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
460 NUITKA_MAY_BE_UNUSED long clong_result;
461#if defined(_MSC_VER)
462#pragma warning(pop)
463#endif
464
465 PyObject *x = PyLong_Type.tp_as_number->nb_rshift(operand1, operand2);
466 assert(x != Py_NotImplemented);
467
468 obj_result = x;
469 goto exit_result_object;
470
471exit_result_object:
472 if (unlikely(obj_result == NULL)) {
473 goto exit_result_exception;
474 }
475 result = CHECK_IF_TRUE(obj_result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
476 Py_DECREF(obj_result);
477 goto exit_result_ok;
478
479exit_result_ok:
480 return result;
481
482exit_result_exception:
483 return NUITKA_BOOL_EXCEPTION;
484}
485
486nuitka_bool BINARY_OPERATION_RSHIFT_NBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2) {
487 return _BINARY_OPERATION_RSHIFT_NBOOL_LONG_LONG(operand1, operand2);
488}
489
490/* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
491static HEDLEY_NEVER_INLINE nuitka_bool __BINARY_OPERATION_RSHIFT_NBOOL_OBJECT_LONG(PyObject *operand1,
492 PyObject *operand2) {
493 PyTypeObject *type1 = Py_TYPE(operand1);
494
495#if defined(_MSC_VER)
496#pragma warning(push)
497#pragma warning(disable : 4101)
498#endif
499 NUITKA_MAY_BE_UNUSED bool cbool_result;
500 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
501#if defined(_MSC_VER)
502#pragma warning(pop)
503#endif
504
505 binaryfunc slot1 =
506 (type1->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type1)) ? type1->tp_as_number->nb_rshift : NULL;
507 binaryfunc slot2 = NULL;
508
509 if (!(type1 == &PyLong_Type)) {
510 // Different types, need to consider second value slot.
511
512 slot2 = PyLong_Type.tp_as_number->nb_rshift;
513
514 if (slot1 == slot2) {
515 slot2 = NULL;
516 }
517 }
518
519 if (slot1 != NULL) {
520 PyObject *x = slot1(operand1, operand2);
521
522 if (x != Py_NotImplemented) {
523 obj_result = x;
524 goto exit_binary_result_object;
525 }
526
527 Py_DECREF_IMMORTAL(x);
528 }
529
530 if (slot2 != NULL) {
531 PyObject *x = slot2(operand1, operand2);
532
533 if (x != Py_NotImplemented) {
534 obj_result = x;
535 goto exit_binary_result_object;
536 }
537
538 Py_DECREF_IMMORTAL(x);
539 }
540
541#if PYTHON_VERSION < 0x300
542 if (!NEW_STYLE_NUMBER_TYPE(type1) || !1) {
543 coercion c1 =
544 (type1->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type1)) ? type1->tp_as_number->nb_coerce : NULL;
545
546 if (c1 != NULL) {
547 PyObject *coerced1 = operand1;
548 PyObject *coerced2 = operand2;
549
550 int err = c1(&coerced1, &coerced2);
551
552 if (unlikely(err < 0)) {
553 goto exit_binary_exception;
554 }
555
556 if (err == 0) {
557 PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
558
559 if (likely(mv == NULL)) {
560 binaryfunc slot = mv->nb_rshift;
561
562 if (likely(slot != NULL)) {
563 PyObject *x = slot(coerced1, coerced2);
564
565 Py_DECREF(coerced1);
566 Py_DECREF(coerced2);
567
568 obj_result = x;
569 goto exit_binary_result_object;
570 }
571 }
572
573 // nb_coerce took a reference.
574 Py_DECREF(coerced1);
575 Py_DECREF(coerced2);
576 }
577 }
578 coercion c2 = PyLong_Type.tp_as_number->nb_coerce;
579
580 if (c2 != NULL) {
581 PyObject *coerced1 = operand1;
582 PyObject *coerced2 = operand2;
583
584 int err = c2(&coerced2, &coerced1);
585
586 if (unlikely(err < 0)) {
587 goto exit_binary_exception;
588 }
589
590 if (err == 0) {
591 PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
592
593 if (likely(mv == NULL)) {
594 binaryfunc slot = mv->nb_rshift;
595
596 if (likely(slot != NULL)) {
597 PyObject *x = slot(coerced1, coerced2);
598
599 Py_DECREF(coerced1);
600 Py_DECREF(coerced2);
601
602 obj_result = x;
603 goto exit_binary_result_object;
604 }
605 }
606
607 // nb_coerce took a reference.
608 Py_DECREF(coerced1);
609 Py_DECREF(coerced2);
610 }
611 }
612 }
613#endif
614
615#if PYTHON_VERSION < 0x300
616 PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for >>: '%s' and 'long'", type1->tp_name);
617#else
618 PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for >>: '%s' and 'int'", type1->tp_name);
619#endif
620 goto exit_binary_exception;
621
622exit_binary_result_object:
623 if (unlikely(obj_result == NULL)) {
624 return NUITKA_BOOL_EXCEPTION;
625 }
626
627 {
628 nuitka_bool r = CHECK_IF_TRUE(obj_result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
629 Py_DECREF(obj_result);
630 return r;
631 }
632
633exit_binary_exception:
634 return NUITKA_BOOL_EXCEPTION;
635}
636static nuitka_bool _BINARY_OPERATION_RSHIFT_NBOOL_OBJECT_LONG(PyObject *operand1, PyObject *operand2) {
637 CHECK_OBJECT(operand1);
638 CHECK_OBJECT(operand2);
639 assert(PyLong_CheckExact(operand2));
640
641 PyTypeObject *type1 = Py_TYPE(operand1);
642
643 if (type1 == &PyLong_Type) {
644 nuitka_bool result;
645
646 // return _BINARY_OPERATION_RSHIFT_NBOOL_LONG_LONG(operand1, operand2);
647
648 // Not every code path will make use of all possible results.
649#if defined(_MSC_VER)
650#pragma warning(push)
651#pragma warning(disable : 4101)
652#endif
653 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
654 NUITKA_MAY_BE_UNUSED long clong_result;
655#if defined(_MSC_VER)
656#pragma warning(pop)
657#endif
658
659 PyObject *x = PyLong_Type.tp_as_number->nb_rshift(operand1, operand2);
660 assert(x != Py_NotImplemented);
661
662 obj_result = x;
663 goto exit_result_object;
664
665 exit_result_object:
666 if (unlikely(obj_result == NULL)) {
667 goto exit_result_exception;
668 }
669 result = CHECK_IF_TRUE(obj_result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
670 Py_DECREF(obj_result);
671 goto exit_result_ok;
672
673 exit_result_ok:
674 return result;
675
676 exit_result_exception:
677 return NUITKA_BOOL_EXCEPTION;
678 }
679
680 return __BINARY_OPERATION_RSHIFT_NBOOL_OBJECT_LONG(operand1, operand2);
681}
682
683nuitka_bool BINARY_OPERATION_RSHIFT_NBOOL_OBJECT_LONG(PyObject *operand1, PyObject *operand2) {
684 return _BINARY_OPERATION_RSHIFT_NBOOL_OBJECT_LONG(operand1, operand2);
685}
686
687/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "OBJECT" to any Python object. */
688static HEDLEY_NEVER_INLINE nuitka_bool __BINARY_OPERATION_RSHIFT_NBOOL_LONG_OBJECT(PyObject *operand1,
689 PyObject *operand2) {
690 PyTypeObject *type2 = Py_TYPE(operand2);
691
692#if defined(_MSC_VER)
693#pragma warning(push)
694#pragma warning(disable : 4101)
695#endif
696 NUITKA_MAY_BE_UNUSED bool cbool_result;
697 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
698#if defined(_MSC_VER)
699#pragma warning(pop)
700#endif
701
702 binaryfunc slot1 = PyLong_Type.tp_as_number->nb_rshift;
703 binaryfunc slot2 = NULL;
704
705 if (!(&PyLong_Type == type2)) {
706 // Different types, need to consider second value slot.
707
708 slot2 = (type2->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type2)) ? type2->tp_as_number->nb_rshift : NULL;
709
710 if (slot1 == slot2) {
711 slot2 = NULL;
712 }
713 }
714
715 if (slot1 != NULL) {
716 if (slot2 != NULL) {
717 if (Nuitka_Type_IsSubtype(type2, &PyLong_Type)) {
718 PyObject *x = slot2(operand1, operand2);
719
720 if (x != Py_NotImplemented) {
721 obj_result = x;
722 goto exit_binary_result_object;
723 }
724
725 Py_DECREF_IMMORTAL(x);
726 slot2 = NULL;
727 }
728 }
729
730 PyObject *x = slot1(operand1, operand2);
731
732 if (x != Py_NotImplemented) {
733 obj_result = x;
734 goto exit_binary_result_object;
735 }
736
737 Py_DECREF_IMMORTAL(x);
738 }
739
740 if (slot2 != NULL) {
741 PyObject *x = slot2(operand1, operand2);
742
743 if (x != Py_NotImplemented) {
744 obj_result = x;
745 goto exit_binary_result_object;
746 }
747
748 Py_DECREF_IMMORTAL(x);
749 }
750
751#if PYTHON_VERSION < 0x300
752 if (!1 || !NEW_STYLE_NUMBER_TYPE(type2)) {
753 coercion c1 = PyLong_Type.tp_as_number->nb_coerce;
754
755 if (c1 != NULL) {
756 PyObject *coerced1 = operand1;
757 PyObject *coerced2 = operand2;
758
759 int err = c1(&coerced1, &coerced2);
760
761 if (unlikely(err < 0)) {
762 goto exit_binary_exception;
763 }
764
765 if (err == 0) {
766 PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
767
768 if (likely(mv == NULL)) {
769 binaryfunc slot = mv->nb_rshift;
770
771 if (likely(slot != NULL)) {
772 PyObject *x = slot(coerced1, coerced2);
773
774 Py_DECREF(coerced1);
775 Py_DECREF(coerced2);
776
777 obj_result = x;
778 goto exit_binary_result_object;
779 }
780 }
781
782 // nb_coerce took a reference.
783 Py_DECREF(coerced1);
784 Py_DECREF(coerced2);
785 }
786 }
787 coercion c2 =
788 (type2->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type2)) ? type2->tp_as_number->nb_coerce : NULL;
789
790 if (c2 != NULL) {
791 PyObject *coerced1 = operand1;
792 PyObject *coerced2 = operand2;
793
794 int err = c2(&coerced2, &coerced1);
795
796 if (unlikely(err < 0)) {
797 goto exit_binary_exception;
798 }
799
800 if (err == 0) {
801 PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
802
803 if (likely(mv == NULL)) {
804 binaryfunc slot = mv->nb_rshift;
805
806 if (likely(slot != NULL)) {
807 PyObject *x = slot(coerced1, coerced2);
808
809 Py_DECREF(coerced1);
810 Py_DECREF(coerced2);
811
812 obj_result = x;
813 goto exit_binary_result_object;
814 }
815 }
816
817 // nb_coerce took a reference.
818 Py_DECREF(coerced1);
819 Py_DECREF(coerced2);
820 }
821 }
822 }
823#endif
824
825#if PYTHON_VERSION < 0x300
826 PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for >>: 'long' and '%s'", type2->tp_name);
827#else
828 PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for >>: 'int' and '%s'", type2->tp_name);
829#endif
830 goto exit_binary_exception;
831
832exit_binary_result_object:
833 if (unlikely(obj_result == NULL)) {
834 return NUITKA_BOOL_EXCEPTION;
835 }
836
837 {
838 nuitka_bool r = CHECK_IF_TRUE(obj_result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
839 Py_DECREF(obj_result);
840 return r;
841 }
842
843exit_binary_exception:
844 return NUITKA_BOOL_EXCEPTION;
845}
846static nuitka_bool _BINARY_OPERATION_RSHIFT_NBOOL_LONG_OBJECT(PyObject *operand1, PyObject *operand2) {
847 CHECK_OBJECT(operand1);
848 assert(PyLong_CheckExact(operand1));
849 CHECK_OBJECT(operand2);
850
851 PyTypeObject *type2 = Py_TYPE(operand2);
852
853 if (&PyLong_Type == type2) {
854 nuitka_bool result;
855
856 // return _BINARY_OPERATION_RSHIFT_NBOOL_LONG_LONG(operand1, operand2);
857
858 // Not every code path will make use of all possible results.
859#if defined(_MSC_VER)
860#pragma warning(push)
861#pragma warning(disable : 4101)
862#endif
863 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
864 NUITKA_MAY_BE_UNUSED long clong_result;
865#if defined(_MSC_VER)
866#pragma warning(pop)
867#endif
868
869 PyObject *x = PyLong_Type.tp_as_number->nb_rshift(operand1, operand2);
870 assert(x != Py_NotImplemented);
871
872 obj_result = x;
873 goto exit_result_object;
874
875 exit_result_object:
876 if (unlikely(obj_result == NULL)) {
877 goto exit_result_exception;
878 }
879 result = CHECK_IF_TRUE(obj_result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
880 Py_DECREF(obj_result);
881 goto exit_result_ok;
882
883 exit_result_ok:
884 return result;
885
886 exit_result_exception:
887 return NUITKA_BOOL_EXCEPTION;
888 }
889
890 return __BINARY_OPERATION_RSHIFT_NBOOL_LONG_OBJECT(operand1, operand2);
891}
892
893nuitka_bool BINARY_OPERATION_RSHIFT_NBOOL_LONG_OBJECT(PyObject *operand1, PyObject *operand2) {
894 return _BINARY_OPERATION_RSHIFT_NBOOL_LONG_OBJECT(operand1, operand2);
895}
896
897#if PYTHON_VERSION < 0x300
898/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
899static PyObject *_BINARY_OPERATION_RSHIFT_OBJECT_INT_INT(PyObject *operand1, PyObject *operand2) {
900 CHECK_OBJECT(operand1);
901 assert(PyInt_CheckExact(operand1));
902 CHECK_OBJECT(operand2);
903 assert(PyInt_CheckExact(operand2));
904
905 PyObject *result;
906
907 // Not every code path will make use of all possible results.
908#if defined(_MSC_VER)
909#pragma warning(push)
910#pragma warning(disable : 4101)
911#endif
912 NUITKA_MAY_BE_UNUSED bool cbool_result;
913 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
914 NUITKA_MAY_BE_UNUSED long clong_result;
915 NUITKA_MAY_BE_UNUSED double cfloat_result;
916#if defined(_MSC_VER)
917#pragma warning(pop)
918#endif
919
920 CHECK_OBJECT(operand1);
921 assert(PyInt_CheckExact(operand1));
922 CHECK_OBJECT(operand2);
923 assert(PyInt_CheckExact(operand2));
924
925 const long a = PyInt_AS_LONG(operand1);
926 const long b = PyInt_AS_LONG(operand2);
927
928 if (unlikely(b < 0)) {
929 PyThreadState *tstate = PyThreadState_GET();
930
931 SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_ValueError, "negative shift count");
932 goto exit_result_exception;
933 }
934
935 /* Short cut for zero shift or shifting zero. */
936 if (a == 0 || b == 0) {
937 goto exit_result_ok_left;
938 } else if (b >= LONG_BIT) {
939 if (a < 0) {
940 goto exit_result_ok_const_int_neg_1;
941 } else {
942 goto exit_result_ok_const_int_0;
943 }
944 } else {
945 long r = Py_ARITHMETIC_RIGHT_SHIFT(long, a, b);
946
947 clong_result = r;
948 goto exit_result_ok_clong;
949 }
950
951exit_result_ok_clong:
952 result = Nuitka_PyInt_FromLong(clong_result);
953 goto exit_result_ok;
954
955exit_result_ok_left:
956 result = operand1;
957 Py_INCREF(result);
958 goto exit_result_ok;
959
960exit_result_ok_const_int_0:
961 Py_INCREF(const_int_0);
962 result = const_int_0;
963 goto exit_result_ok;
964
965exit_result_ok_const_int_neg_1:
966 Py_INCREF(const_int_neg_1);
967 result = const_int_neg_1;
968 goto exit_result_ok;
969
970exit_result_ok:
971 return result;
972
973exit_result_exception:
974 return NULL;
975}
976
977PyObject *BINARY_OPERATION_RSHIFT_OBJECT_INT_INT(PyObject *operand1, PyObject *operand2) {
978 return _BINARY_OPERATION_RSHIFT_OBJECT_INT_INT(operand1, operand2);
979}
980#endif
981
982#if PYTHON_VERSION < 0x300
983/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
984static HEDLEY_NEVER_INLINE PyObject *__BINARY_OPERATION_RSHIFT_OBJECT_OBJECT_INT(PyObject *operand1,
985 PyObject *operand2) {
986 PyTypeObject *type1 = Py_TYPE(operand1);
987
988#if defined(_MSC_VER)
989#pragma warning(push)
990#pragma warning(disable : 4101)
991#endif
992 NUITKA_MAY_BE_UNUSED bool cbool_result;
993 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
994#if defined(_MSC_VER)
995#pragma warning(pop)
996#endif
997
998 binaryfunc slot1 =
999 (type1->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type1)) ? type1->tp_as_number->nb_rshift : NULL;
1000 binaryfunc slot2 = NULL;
1001
1002 if (!(type1 == &PyInt_Type)) {
1003 // Different types, need to consider second value slot.
1004
1005 slot2 = PyInt_Type.tp_as_number->nb_rshift;
1006
1007 if (slot1 == slot2) {
1008 slot2 = NULL;
1009 }
1010 }
1011
1012 if (slot1 != NULL) {
1013 PyObject *x = slot1(operand1, operand2);
1014
1015 if (x != Py_NotImplemented) {
1016 obj_result = x;
1017 goto exit_binary_result_object;
1018 }
1019
1020 Py_DECREF_IMMORTAL(x);
1021 }
1022
1023 if (slot2 != NULL) {
1024 PyObject *x = slot2(operand1, operand2);
1025
1026 if (x != Py_NotImplemented) {
1027 obj_result = x;
1028 goto exit_binary_result_object;
1029 }
1030
1031 Py_DECREF_IMMORTAL(x);
1032 }
1033
1034#if PYTHON_VERSION < 0x300
1035 if (!NEW_STYLE_NUMBER_TYPE(type1) || !1) {
1036 coercion c1 =
1037 (type1->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type1)) ? type1->tp_as_number->nb_coerce : NULL;
1038
1039 if (c1 != NULL) {
1040 PyObject *coerced1 = operand1;
1041 PyObject *coerced2 = operand2;
1042
1043 int err = c1(&coerced1, &coerced2);
1044
1045 if (unlikely(err < 0)) {
1046 goto exit_binary_exception;
1047 }
1048
1049 if (err == 0) {
1050 PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
1051
1052 if (likely(mv == NULL)) {
1053 binaryfunc slot = mv->nb_rshift;
1054
1055 if (likely(slot != NULL)) {
1056 PyObject *x = slot(coerced1, coerced2);
1057
1058 Py_DECREF(coerced1);
1059 Py_DECREF(coerced2);
1060
1061 obj_result = x;
1062 goto exit_binary_result_object;
1063 }
1064 }
1065
1066 // nb_coerce took a reference.
1067 Py_DECREF(coerced1);
1068 Py_DECREF(coerced2);
1069 }
1070 }
1071 coercion c2 = PyInt_Type.tp_as_number->nb_coerce;
1072
1073 if (c2 != NULL) {
1074 PyObject *coerced1 = operand1;
1075 PyObject *coerced2 = operand2;
1076
1077 int err = c2(&coerced2, &coerced1);
1078
1079 if (unlikely(err < 0)) {
1080 goto exit_binary_exception;
1081 }
1082
1083 if (err == 0) {
1084 PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
1085
1086 if (likely(mv == NULL)) {
1087 binaryfunc slot = mv->nb_rshift;
1088
1089 if (likely(slot != NULL)) {
1090 PyObject *x = slot(coerced1, coerced2);
1091
1092 Py_DECREF(coerced1);
1093 Py_DECREF(coerced2);
1094
1095 obj_result = x;
1096 goto exit_binary_result_object;
1097 }
1098 }
1099
1100 // nb_coerce took a reference.
1101 Py_DECREF(coerced1);
1102 Py_DECREF(coerced2);
1103 }
1104 }
1105 }
1106#endif
1107
1108 PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for >>: '%s' and 'int'", type1->tp_name);
1109 goto exit_binary_exception;
1110
1111exit_binary_result_object:
1112 return obj_result;
1113
1114exit_binary_exception:
1115 return NULL;
1116}
1117static PyObject *_BINARY_OPERATION_RSHIFT_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operand2) {
1118 CHECK_OBJECT(operand1);
1119 CHECK_OBJECT(operand2);
1120 assert(PyInt_CheckExact(operand2));
1121
1122 PyTypeObject *type1 = Py_TYPE(operand1);
1123
1124 if (type1 == &PyInt_Type) {
1125 PyObject *result;
1126
1127 // return _BINARY_OPERATION_RSHIFT_OBJECT_INT_INT(operand1, operand2);
1128
1129 // Not every code path will make use of all possible results.
1130#if defined(_MSC_VER)
1131#pragma warning(push)
1132#pragma warning(disable : 4101)
1133#endif
1134 NUITKA_MAY_BE_UNUSED bool cbool_result;
1135 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
1136 NUITKA_MAY_BE_UNUSED long clong_result;
1137 NUITKA_MAY_BE_UNUSED double cfloat_result;
1138#if defined(_MSC_VER)
1139#pragma warning(pop)
1140#endif
1141
1142 CHECK_OBJECT(operand1);
1143 assert(PyInt_CheckExact(operand1));
1144 CHECK_OBJECT(operand2);
1145 assert(PyInt_CheckExact(operand2));
1146
1147 const long a = PyInt_AS_LONG(operand1);
1148 const long b = PyInt_AS_LONG(operand2);
1149
1150 if (unlikely(b < 0)) {
1151 PyThreadState *tstate = PyThreadState_GET();
1152
1153 SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_ValueError, "negative shift count");
1154 goto exit_result_exception;
1155 }
1156
1157 /* Short cut for zero shift or shifting zero. */
1158 if (a == 0 || b == 0) {
1159 goto exit_result_ok_left;
1160 } else if (b >= LONG_BIT) {
1161 if (a < 0) {
1162 goto exit_result_ok_const_int_neg_1;
1163 } else {
1164 goto exit_result_ok_const_int_0;
1165 }
1166 } else {
1167 long r = Py_ARITHMETIC_RIGHT_SHIFT(long, a, b);
1168
1169 clong_result = r;
1170 goto exit_result_ok_clong;
1171 }
1172
1173 exit_result_ok_clong:
1174 result = Nuitka_PyInt_FromLong(clong_result);
1175 goto exit_result_ok;
1176
1177 exit_result_ok_left:
1178 result = operand1;
1179 Py_INCREF(result);
1180 goto exit_result_ok;
1181
1182 exit_result_ok_const_int_0:
1183 Py_INCREF(const_int_0);
1184 result = const_int_0;
1185 goto exit_result_ok;
1186
1187 exit_result_ok_const_int_neg_1:
1188 Py_INCREF(const_int_neg_1);
1189 result = const_int_neg_1;
1190 goto exit_result_ok;
1191
1192 exit_result_ok:
1193 return result;
1194
1195 exit_result_exception:
1196 return NULL;
1197 }
1198
1199 return __BINARY_OPERATION_RSHIFT_OBJECT_OBJECT_INT(operand1, operand2);
1200}
1201
1202PyObject *BINARY_OPERATION_RSHIFT_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operand2) {
1203 return _BINARY_OPERATION_RSHIFT_OBJECT_OBJECT_INT(operand1, operand2);
1204}
1205#endif
1206
1207#if PYTHON_VERSION < 0x300
1208/* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
1209static HEDLEY_NEVER_INLINE PyObject *__BINARY_OPERATION_RSHIFT_OBJECT_INT_OBJECT(PyObject *operand1,
1210 PyObject *operand2) {
1211 PyTypeObject *type2 = Py_TYPE(operand2);
1212
1213#if defined(_MSC_VER)
1214#pragma warning(push)
1215#pragma warning(disable : 4101)
1216#endif
1217 NUITKA_MAY_BE_UNUSED bool cbool_result;
1218 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
1219#if defined(_MSC_VER)
1220#pragma warning(pop)
1221#endif
1222
1223 binaryfunc slot1 = PyInt_Type.tp_as_number->nb_rshift;
1224 binaryfunc slot2 = NULL;
1225
1226 if (!(&PyInt_Type == type2)) {
1227 // Different types, need to consider second value slot.
1228
1229 slot2 = (type2->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type2)) ? type2->tp_as_number->nb_rshift : NULL;
1230
1231 if (slot1 == slot2) {
1232 slot2 = NULL;
1233 }
1234 }
1235
1236 if (slot1 != NULL) {
1237 if (slot2 != NULL) {
1238 if (Nuitka_Type_IsSubtype(type2, &PyInt_Type)) {
1239 PyObject *x = slot2(operand1, operand2);
1240
1241 if (x != Py_NotImplemented) {
1242 obj_result = x;
1243 goto exit_binary_result_object;
1244 }
1245
1246 Py_DECREF_IMMORTAL(x);
1247 slot2 = NULL;
1248 }
1249 }
1250
1251 PyObject *x = slot1(operand1, operand2);
1252
1253 if (x != Py_NotImplemented) {
1254 obj_result = x;
1255 goto exit_binary_result_object;
1256 }
1257
1258 Py_DECREF_IMMORTAL(x);
1259 }
1260
1261 if (slot2 != NULL) {
1262 PyObject *x = slot2(operand1, operand2);
1263
1264 if (x != Py_NotImplemented) {
1265 obj_result = x;
1266 goto exit_binary_result_object;
1267 }
1268
1269 Py_DECREF_IMMORTAL(x);
1270 }
1271
1272#if PYTHON_VERSION < 0x300
1273 if (!1 || !NEW_STYLE_NUMBER_TYPE(type2)) {
1274 coercion c1 = PyInt_Type.tp_as_number->nb_coerce;
1275
1276 if (c1 != NULL) {
1277 PyObject *coerced1 = operand1;
1278 PyObject *coerced2 = operand2;
1279
1280 int err = c1(&coerced1, &coerced2);
1281
1282 if (unlikely(err < 0)) {
1283 goto exit_binary_exception;
1284 }
1285
1286 if (err == 0) {
1287 PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
1288
1289 if (likely(mv == NULL)) {
1290 binaryfunc slot = mv->nb_rshift;
1291
1292 if (likely(slot != NULL)) {
1293 PyObject *x = slot(coerced1, coerced2);
1294
1295 Py_DECREF(coerced1);
1296 Py_DECREF(coerced2);
1297
1298 obj_result = x;
1299 goto exit_binary_result_object;
1300 }
1301 }
1302
1303 // nb_coerce took a reference.
1304 Py_DECREF(coerced1);
1305 Py_DECREF(coerced2);
1306 }
1307 }
1308 coercion c2 =
1309 (type2->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type2)) ? type2->tp_as_number->nb_coerce : NULL;
1310
1311 if (c2 != NULL) {
1312 PyObject *coerced1 = operand1;
1313 PyObject *coerced2 = operand2;
1314
1315 int err = c2(&coerced2, &coerced1);
1316
1317 if (unlikely(err < 0)) {
1318 goto exit_binary_exception;
1319 }
1320
1321 if (err == 0) {
1322 PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
1323
1324 if (likely(mv == NULL)) {
1325 binaryfunc slot = mv->nb_rshift;
1326
1327 if (likely(slot != NULL)) {
1328 PyObject *x = slot(coerced1, coerced2);
1329
1330 Py_DECREF(coerced1);
1331 Py_DECREF(coerced2);
1332
1333 obj_result = x;
1334 goto exit_binary_result_object;
1335 }
1336 }
1337
1338 // nb_coerce took a reference.
1339 Py_DECREF(coerced1);
1340 Py_DECREF(coerced2);
1341 }
1342 }
1343 }
1344#endif
1345
1346 PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for >>: 'int' and '%s'", type2->tp_name);
1347 goto exit_binary_exception;
1348
1349exit_binary_result_object:
1350 return obj_result;
1351
1352exit_binary_exception:
1353 return NULL;
1354}
1355static PyObject *_BINARY_OPERATION_RSHIFT_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operand2) {
1356 CHECK_OBJECT(operand1);
1357 assert(PyInt_CheckExact(operand1));
1358 CHECK_OBJECT(operand2);
1359
1360 PyTypeObject *type2 = Py_TYPE(operand2);
1361
1362 if (&PyInt_Type == type2) {
1363 PyObject *result;
1364
1365 // return _BINARY_OPERATION_RSHIFT_OBJECT_INT_INT(operand1, operand2);
1366
1367 // Not every code path will make use of all possible results.
1368#if defined(_MSC_VER)
1369#pragma warning(push)
1370#pragma warning(disable : 4101)
1371#endif
1372 NUITKA_MAY_BE_UNUSED bool cbool_result;
1373 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
1374 NUITKA_MAY_BE_UNUSED long clong_result;
1375 NUITKA_MAY_BE_UNUSED double cfloat_result;
1376#if defined(_MSC_VER)
1377#pragma warning(pop)
1378#endif
1379
1380 CHECK_OBJECT(operand1);
1381 assert(PyInt_CheckExact(operand1));
1382 CHECK_OBJECT(operand2);
1383 assert(PyInt_CheckExact(operand2));
1384
1385 const long a = PyInt_AS_LONG(operand1);
1386 const long b = PyInt_AS_LONG(operand2);
1387
1388 if (unlikely(b < 0)) {
1389 PyThreadState *tstate = PyThreadState_GET();
1390
1391 SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_ValueError, "negative shift count");
1392 goto exit_result_exception;
1393 }
1394
1395 /* Short cut for zero shift or shifting zero. */
1396 if (a == 0 || b == 0) {
1397 goto exit_result_ok_left;
1398 } else if (b >= LONG_BIT) {
1399 if (a < 0) {
1400 goto exit_result_ok_const_int_neg_1;
1401 } else {
1402 goto exit_result_ok_const_int_0;
1403 }
1404 } else {
1405 long r = Py_ARITHMETIC_RIGHT_SHIFT(long, a, b);
1406
1407 clong_result = r;
1408 goto exit_result_ok_clong;
1409 }
1410
1411 exit_result_ok_clong:
1412 result = Nuitka_PyInt_FromLong(clong_result);
1413 goto exit_result_ok;
1414
1415 exit_result_ok_left:
1416 result = operand1;
1417 Py_INCREF(result);
1418 goto exit_result_ok;
1419
1420 exit_result_ok_const_int_0:
1421 Py_INCREF(const_int_0);
1422 result = const_int_0;
1423 goto exit_result_ok;
1424
1425 exit_result_ok_const_int_neg_1:
1426 Py_INCREF(const_int_neg_1);
1427 result = const_int_neg_1;
1428 goto exit_result_ok;
1429
1430 exit_result_ok:
1431 return result;
1432
1433 exit_result_exception:
1434 return NULL;
1435 }
1436
1437 return __BINARY_OPERATION_RSHIFT_OBJECT_INT_OBJECT(operand1, operand2);
1438}
1439
1440PyObject *BINARY_OPERATION_RSHIFT_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operand2) {
1441 return _BINARY_OPERATION_RSHIFT_OBJECT_INT_OBJECT(operand1, operand2);
1442}
1443#endif
1444
1445#if PYTHON_VERSION < 0x300
1446/* Code referring to "INT" corresponds to Python2 'int' and "INT" to Python2 'int'. */
1447static nuitka_bool _BINARY_OPERATION_RSHIFT_NBOOL_INT_INT(PyObject *operand1, PyObject *operand2) {
1448 CHECK_OBJECT(operand1);
1449 assert(PyInt_CheckExact(operand1));
1450 CHECK_OBJECT(operand2);
1451 assert(PyInt_CheckExact(operand2));
1452
1453 nuitka_bool result;
1454
1455 // Not every code path will make use of all possible results.
1456#if defined(_MSC_VER)
1457#pragma warning(push)
1458#pragma warning(disable : 4101)
1459#endif
1460 NUITKA_MAY_BE_UNUSED bool cbool_result;
1461 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
1462 NUITKA_MAY_BE_UNUSED long clong_result;
1463 NUITKA_MAY_BE_UNUSED double cfloat_result;
1464#if defined(_MSC_VER)
1465#pragma warning(pop)
1466#endif
1467
1468 CHECK_OBJECT(operand1);
1469 assert(PyInt_CheckExact(operand1));
1470 CHECK_OBJECT(operand2);
1471 assert(PyInt_CheckExact(operand2));
1472
1473 const long a = PyInt_AS_LONG(operand1);
1474 const long b = PyInt_AS_LONG(operand2);
1475
1476 if (unlikely(b < 0)) {
1477 PyThreadState *tstate = PyThreadState_GET();
1478
1479 SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_ValueError, "negative shift count");
1480 goto exit_result_exception;
1481 }
1482
1483 /* Short cut for zero shift or shifting zero. */
1484 if (a == 0 || b == 0) {
1485 goto exit_result_ok_left;
1486 } else if (b >= LONG_BIT) {
1487 if (a < 0) {
1488 goto exit_result_ok_const_int_neg_1;
1489 } else {
1490 goto exit_result_ok_const_int_0;
1491 }
1492 } else {
1493 long r = Py_ARITHMETIC_RIGHT_SHIFT(long, a, b);
1494
1495 clong_result = r;
1496 goto exit_result_ok_clong;
1497 }
1498
1499exit_result_ok_clong:
1500 result = clong_result != 0 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
1501 goto exit_result_ok;
1502
1503exit_result_ok_left:
1504 result = PyInt_AS_LONG(operand1) != 0 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
1505 goto exit_result_ok;
1506
1507exit_result_ok_const_int_0:
1508 result = 0 != 0 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
1509 goto exit_result_ok;
1510
1511exit_result_ok_const_int_neg_1:
1512 result = -1 != 0 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
1513 goto exit_result_ok;
1514
1515exit_result_ok:
1516 return result;
1517
1518exit_result_exception:
1519 return NUITKA_BOOL_EXCEPTION;
1520}
1521
1522nuitka_bool BINARY_OPERATION_RSHIFT_NBOOL_INT_INT(PyObject *operand1, PyObject *operand2) {
1523 return _BINARY_OPERATION_RSHIFT_NBOOL_INT_INT(operand1, operand2);
1524}
1525#endif
1526
1527#if PYTHON_VERSION < 0x300
1528/* Code referring to "OBJECT" corresponds to any Python object and "INT" to Python2 'int'. */
1529static HEDLEY_NEVER_INLINE nuitka_bool __BINARY_OPERATION_RSHIFT_NBOOL_OBJECT_INT(PyObject *operand1,
1530 PyObject *operand2) {
1531 PyTypeObject *type1 = Py_TYPE(operand1);
1532
1533#if defined(_MSC_VER)
1534#pragma warning(push)
1535#pragma warning(disable : 4101)
1536#endif
1537 NUITKA_MAY_BE_UNUSED bool cbool_result;
1538 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
1539#if defined(_MSC_VER)
1540#pragma warning(pop)
1541#endif
1542
1543 binaryfunc slot1 =
1544 (type1->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type1)) ? type1->tp_as_number->nb_rshift : NULL;
1545 binaryfunc slot2 = NULL;
1546
1547 if (!(type1 == &PyInt_Type)) {
1548 // Different types, need to consider second value slot.
1549
1550 slot2 = PyInt_Type.tp_as_number->nb_rshift;
1551
1552 if (slot1 == slot2) {
1553 slot2 = NULL;
1554 }
1555 }
1556
1557 if (slot1 != NULL) {
1558 PyObject *x = slot1(operand1, operand2);
1559
1560 if (x != Py_NotImplemented) {
1561 obj_result = x;
1562 goto exit_binary_result_object;
1563 }
1564
1565 Py_DECREF_IMMORTAL(x);
1566 }
1567
1568 if (slot2 != NULL) {
1569 PyObject *x = slot2(operand1, operand2);
1570
1571 if (x != Py_NotImplemented) {
1572 obj_result = x;
1573 goto exit_binary_result_object;
1574 }
1575
1576 Py_DECREF_IMMORTAL(x);
1577 }
1578
1579#if PYTHON_VERSION < 0x300
1580 if (!NEW_STYLE_NUMBER_TYPE(type1) || !1) {
1581 coercion c1 =
1582 (type1->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type1)) ? type1->tp_as_number->nb_coerce : NULL;
1583
1584 if (c1 != NULL) {
1585 PyObject *coerced1 = operand1;
1586 PyObject *coerced2 = operand2;
1587
1588 int err = c1(&coerced1, &coerced2);
1589
1590 if (unlikely(err < 0)) {
1591 goto exit_binary_exception;
1592 }
1593
1594 if (err == 0) {
1595 PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
1596
1597 if (likely(mv == NULL)) {
1598 binaryfunc slot = mv->nb_rshift;
1599
1600 if (likely(slot != NULL)) {
1601 PyObject *x = slot(coerced1, coerced2);
1602
1603 Py_DECREF(coerced1);
1604 Py_DECREF(coerced2);
1605
1606 obj_result = x;
1607 goto exit_binary_result_object;
1608 }
1609 }
1610
1611 // nb_coerce took a reference.
1612 Py_DECREF(coerced1);
1613 Py_DECREF(coerced2);
1614 }
1615 }
1616 coercion c2 = PyInt_Type.tp_as_number->nb_coerce;
1617
1618 if (c2 != NULL) {
1619 PyObject *coerced1 = operand1;
1620 PyObject *coerced2 = operand2;
1621
1622 int err = c2(&coerced2, &coerced1);
1623
1624 if (unlikely(err < 0)) {
1625 goto exit_binary_exception;
1626 }
1627
1628 if (err == 0) {
1629 PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
1630
1631 if (likely(mv == NULL)) {
1632 binaryfunc slot = mv->nb_rshift;
1633
1634 if (likely(slot != NULL)) {
1635 PyObject *x = slot(coerced1, coerced2);
1636
1637 Py_DECREF(coerced1);
1638 Py_DECREF(coerced2);
1639
1640 obj_result = x;
1641 goto exit_binary_result_object;
1642 }
1643 }
1644
1645 // nb_coerce took a reference.
1646 Py_DECREF(coerced1);
1647 Py_DECREF(coerced2);
1648 }
1649 }
1650 }
1651#endif
1652
1653 PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for >>: '%s' and 'int'", type1->tp_name);
1654 goto exit_binary_exception;
1655
1656exit_binary_result_object:
1657 if (unlikely(obj_result == NULL)) {
1658 return NUITKA_BOOL_EXCEPTION;
1659 }
1660
1661 {
1662 nuitka_bool r = CHECK_IF_TRUE(obj_result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
1663 Py_DECREF(obj_result);
1664 return r;
1665 }
1666
1667exit_binary_exception:
1668 return NUITKA_BOOL_EXCEPTION;
1669}
1670static nuitka_bool _BINARY_OPERATION_RSHIFT_NBOOL_OBJECT_INT(PyObject *operand1, PyObject *operand2) {
1671 CHECK_OBJECT(operand1);
1672 CHECK_OBJECT(operand2);
1673 assert(PyInt_CheckExact(operand2));
1674
1675 PyTypeObject *type1 = Py_TYPE(operand1);
1676
1677 if (type1 == &PyInt_Type) {
1678 nuitka_bool result;
1679
1680 // return _BINARY_OPERATION_RSHIFT_NBOOL_INT_INT(operand1, operand2);
1681
1682 // Not every code path will make use of all possible results.
1683#if defined(_MSC_VER)
1684#pragma warning(push)
1685#pragma warning(disable : 4101)
1686#endif
1687 NUITKA_MAY_BE_UNUSED bool cbool_result;
1688 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
1689 NUITKA_MAY_BE_UNUSED long clong_result;
1690 NUITKA_MAY_BE_UNUSED double cfloat_result;
1691#if defined(_MSC_VER)
1692#pragma warning(pop)
1693#endif
1694
1695 CHECK_OBJECT(operand1);
1696 assert(PyInt_CheckExact(operand1));
1697 CHECK_OBJECT(operand2);
1698 assert(PyInt_CheckExact(operand2));
1699
1700 const long a = PyInt_AS_LONG(operand1);
1701 const long b = PyInt_AS_LONG(operand2);
1702
1703 if (unlikely(b < 0)) {
1704 PyThreadState *tstate = PyThreadState_GET();
1705
1706 SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_ValueError, "negative shift count");
1707 goto exit_result_exception;
1708 }
1709
1710 /* Short cut for zero shift or shifting zero. */
1711 if (a == 0 || b == 0) {
1712 goto exit_result_ok_left;
1713 } else if (b >= LONG_BIT) {
1714 if (a < 0) {
1715 goto exit_result_ok_const_int_neg_1;
1716 } else {
1717 goto exit_result_ok_const_int_0;
1718 }
1719 } else {
1720 long r = Py_ARITHMETIC_RIGHT_SHIFT(long, a, b);
1721
1722 clong_result = r;
1723 goto exit_result_ok_clong;
1724 }
1725
1726 exit_result_ok_clong:
1727 result = clong_result != 0 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
1728 goto exit_result_ok;
1729
1730 exit_result_ok_left:
1731 result = PyInt_AS_LONG(operand1) != 0 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
1732 goto exit_result_ok;
1733
1734 exit_result_ok_const_int_0:
1735 result = 0 != 0 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
1736 goto exit_result_ok;
1737
1738 exit_result_ok_const_int_neg_1:
1739 result = -1 != 0 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
1740 goto exit_result_ok;
1741
1742 exit_result_ok:
1743 return result;
1744
1745 exit_result_exception:
1746 return NUITKA_BOOL_EXCEPTION;
1747 }
1748
1749 return __BINARY_OPERATION_RSHIFT_NBOOL_OBJECT_INT(operand1, operand2);
1750}
1751
1752nuitka_bool BINARY_OPERATION_RSHIFT_NBOOL_OBJECT_INT(PyObject *operand1, PyObject *operand2) {
1753 return _BINARY_OPERATION_RSHIFT_NBOOL_OBJECT_INT(operand1, operand2);
1754}
1755#endif
1756
1757#if PYTHON_VERSION < 0x300
1758/* Code referring to "INT" corresponds to Python2 'int' and "OBJECT" to any Python object. */
1759static HEDLEY_NEVER_INLINE nuitka_bool __BINARY_OPERATION_RSHIFT_NBOOL_INT_OBJECT(PyObject *operand1,
1760 PyObject *operand2) {
1761 PyTypeObject *type2 = Py_TYPE(operand2);
1762
1763#if defined(_MSC_VER)
1764#pragma warning(push)
1765#pragma warning(disable : 4101)
1766#endif
1767 NUITKA_MAY_BE_UNUSED bool cbool_result;
1768 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
1769#if defined(_MSC_VER)
1770#pragma warning(pop)
1771#endif
1772
1773 binaryfunc slot1 = PyInt_Type.tp_as_number->nb_rshift;
1774 binaryfunc slot2 = NULL;
1775
1776 if (!(&PyInt_Type == type2)) {
1777 // Different types, need to consider second value slot.
1778
1779 slot2 = (type2->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type2)) ? type2->tp_as_number->nb_rshift : NULL;
1780
1781 if (slot1 == slot2) {
1782 slot2 = NULL;
1783 }
1784 }
1785
1786 if (slot1 != NULL) {
1787 if (slot2 != NULL) {
1788 if (Nuitka_Type_IsSubtype(type2, &PyInt_Type)) {
1789 PyObject *x = slot2(operand1, operand2);
1790
1791 if (x != Py_NotImplemented) {
1792 obj_result = x;
1793 goto exit_binary_result_object;
1794 }
1795
1796 Py_DECREF_IMMORTAL(x);
1797 slot2 = NULL;
1798 }
1799 }
1800
1801 PyObject *x = slot1(operand1, operand2);
1802
1803 if (x != Py_NotImplemented) {
1804 obj_result = x;
1805 goto exit_binary_result_object;
1806 }
1807
1808 Py_DECREF_IMMORTAL(x);
1809 }
1810
1811 if (slot2 != NULL) {
1812 PyObject *x = slot2(operand1, operand2);
1813
1814 if (x != Py_NotImplemented) {
1815 obj_result = x;
1816 goto exit_binary_result_object;
1817 }
1818
1819 Py_DECREF_IMMORTAL(x);
1820 }
1821
1822#if PYTHON_VERSION < 0x300
1823 if (!1 || !NEW_STYLE_NUMBER_TYPE(type2)) {
1824 coercion c1 = PyInt_Type.tp_as_number->nb_coerce;
1825
1826 if (c1 != NULL) {
1827 PyObject *coerced1 = operand1;
1828 PyObject *coerced2 = operand2;
1829
1830 int err = c1(&coerced1, &coerced2);
1831
1832 if (unlikely(err < 0)) {
1833 goto exit_binary_exception;
1834 }
1835
1836 if (err == 0) {
1837 PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
1838
1839 if (likely(mv == NULL)) {
1840 binaryfunc slot = mv->nb_rshift;
1841
1842 if (likely(slot != NULL)) {
1843 PyObject *x = slot(coerced1, coerced2);
1844
1845 Py_DECREF(coerced1);
1846 Py_DECREF(coerced2);
1847
1848 obj_result = x;
1849 goto exit_binary_result_object;
1850 }
1851 }
1852
1853 // nb_coerce took a reference.
1854 Py_DECREF(coerced1);
1855 Py_DECREF(coerced2);
1856 }
1857 }
1858 coercion c2 =
1859 (type2->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type2)) ? type2->tp_as_number->nb_coerce : NULL;
1860
1861 if (c2 != NULL) {
1862 PyObject *coerced1 = operand1;
1863 PyObject *coerced2 = operand2;
1864
1865 int err = c2(&coerced2, &coerced1);
1866
1867 if (unlikely(err < 0)) {
1868 goto exit_binary_exception;
1869 }
1870
1871 if (err == 0) {
1872 PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
1873
1874 if (likely(mv == NULL)) {
1875 binaryfunc slot = mv->nb_rshift;
1876
1877 if (likely(slot != NULL)) {
1878 PyObject *x = slot(coerced1, coerced2);
1879
1880 Py_DECREF(coerced1);
1881 Py_DECREF(coerced2);
1882
1883 obj_result = x;
1884 goto exit_binary_result_object;
1885 }
1886 }
1887
1888 // nb_coerce took a reference.
1889 Py_DECREF(coerced1);
1890 Py_DECREF(coerced2);
1891 }
1892 }
1893 }
1894#endif
1895
1896 PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for >>: 'int' and '%s'", type2->tp_name);
1897 goto exit_binary_exception;
1898
1899exit_binary_result_object:
1900 if (unlikely(obj_result == NULL)) {
1901 return NUITKA_BOOL_EXCEPTION;
1902 }
1903
1904 {
1905 nuitka_bool r = CHECK_IF_TRUE(obj_result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
1906 Py_DECREF(obj_result);
1907 return r;
1908 }
1909
1910exit_binary_exception:
1911 return NUITKA_BOOL_EXCEPTION;
1912}
1913static nuitka_bool _BINARY_OPERATION_RSHIFT_NBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2) {
1914 CHECK_OBJECT(operand1);
1915 assert(PyInt_CheckExact(operand1));
1916 CHECK_OBJECT(operand2);
1917
1918 PyTypeObject *type2 = Py_TYPE(operand2);
1919
1920 if (&PyInt_Type == type2) {
1921 nuitka_bool result;
1922
1923 // return _BINARY_OPERATION_RSHIFT_NBOOL_INT_INT(operand1, operand2);
1924
1925 // Not every code path will make use of all possible results.
1926#if defined(_MSC_VER)
1927#pragma warning(push)
1928#pragma warning(disable : 4101)
1929#endif
1930 NUITKA_MAY_BE_UNUSED bool cbool_result;
1931 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
1932 NUITKA_MAY_BE_UNUSED long clong_result;
1933 NUITKA_MAY_BE_UNUSED double cfloat_result;
1934#if defined(_MSC_VER)
1935#pragma warning(pop)
1936#endif
1937
1938 CHECK_OBJECT(operand1);
1939 assert(PyInt_CheckExact(operand1));
1940 CHECK_OBJECT(operand2);
1941 assert(PyInt_CheckExact(operand2));
1942
1943 const long a = PyInt_AS_LONG(operand1);
1944 const long b = PyInt_AS_LONG(operand2);
1945
1946 if (unlikely(b < 0)) {
1947 PyThreadState *tstate = PyThreadState_GET();
1948
1949 SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_ValueError, "negative shift count");
1950 goto exit_result_exception;
1951 }
1952
1953 /* Short cut for zero shift or shifting zero. */
1954 if (a == 0 || b == 0) {
1955 goto exit_result_ok_left;
1956 } else if (b >= LONG_BIT) {
1957 if (a < 0) {
1958 goto exit_result_ok_const_int_neg_1;
1959 } else {
1960 goto exit_result_ok_const_int_0;
1961 }
1962 } else {
1963 long r = Py_ARITHMETIC_RIGHT_SHIFT(long, a, b);
1964
1965 clong_result = r;
1966 goto exit_result_ok_clong;
1967 }
1968
1969 exit_result_ok_clong:
1970 result = clong_result != 0 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
1971 goto exit_result_ok;
1972
1973 exit_result_ok_left:
1974 result = PyInt_AS_LONG(operand1) != 0 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
1975 goto exit_result_ok;
1976
1977 exit_result_ok_const_int_0:
1978 result = 0 != 0 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
1979 goto exit_result_ok;
1980
1981 exit_result_ok_const_int_neg_1:
1982 result = -1 != 0 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
1983 goto exit_result_ok;
1984
1985 exit_result_ok:
1986 return result;
1987
1988 exit_result_exception:
1989 return NUITKA_BOOL_EXCEPTION;
1990 }
1991
1992 return __BINARY_OPERATION_RSHIFT_NBOOL_INT_OBJECT(operand1, operand2);
1993}
1994
1995nuitka_bool BINARY_OPERATION_RSHIFT_NBOOL_INT_OBJECT(PyObject *operand1, PyObject *operand2) {
1996 return _BINARY_OPERATION_RSHIFT_NBOOL_INT_OBJECT(operand1, operand2);
1997}
1998#endif
1999
2000#if PYTHON_VERSION < 0x300
2001/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
2002static PyObject *_BINARY_OPERATION_RSHIFT_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2) {
2003 CHECK_OBJECT(operand1);
2004 assert(PyLong_CheckExact(operand1));
2005 CHECK_OBJECT(operand2);
2006 assert(PyInt_CheckExact(operand2));
2007
2008#if defined(_MSC_VER)
2009#pragma warning(push)
2010#pragma warning(disable : 4101)
2011#endif
2012 NUITKA_MAY_BE_UNUSED bool cbool_result;
2013 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
2014#if defined(_MSC_VER)
2015#pragma warning(pop)
2016#endif
2017
2018 binaryfunc slot1 = PyLong_Type.tp_as_number->nb_rshift;
2019 // Slot2 ignored on purpose, type1 takes precedence.
2020
2021 if (slot1 != NULL) {
2022 PyObject *x = slot1(operand1, operand2);
2023
2024 if (x != Py_NotImplemented) {
2025 obj_result = x;
2026 goto exit_binary_result_object;
2027 }
2028
2029 Py_DECREF_IMMORTAL(x);
2030 }
2031
2032 // Statically recognized that coercion is not possible with these types
2033
2034 PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for >>: 'long' and 'int'");
2035 goto exit_binary_exception;
2036
2037exit_binary_result_object:
2038 return obj_result;
2039
2040exit_binary_exception:
2041 return NULL;
2042}
2043
2044PyObject *BINARY_OPERATION_RSHIFT_OBJECT_LONG_INT(PyObject *operand1, PyObject *operand2) {
2045 return _BINARY_OPERATION_RSHIFT_OBJECT_LONG_INT(operand1, operand2);
2046}
2047#endif
2048
2049#if PYTHON_VERSION < 0x300
2050/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
2051static PyObject *_BINARY_OPERATION_RSHIFT_OBJECT_INT_LONG(PyObject *operand1, PyObject *operand2) {
2052 CHECK_OBJECT(operand1);
2053 assert(PyInt_CheckExact(operand1));
2054 CHECK_OBJECT(operand2);
2055 assert(PyLong_CheckExact(operand2));
2056
2057#if defined(_MSC_VER)
2058#pragma warning(push)
2059#pragma warning(disable : 4101)
2060#endif
2061 NUITKA_MAY_BE_UNUSED bool cbool_result;
2062 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
2063#if defined(_MSC_VER)
2064#pragma warning(pop)
2065#endif
2066
2067 // Slot1 ignored on purpose, type2 takes precedence.
2068 binaryfunc slot2 = NULL;
2069
2070 if (!(0)) {
2071 // Different types, need to consider second value slot.
2072
2073 slot2 = PyLong_Type.tp_as_number->nb_rshift;
2074 }
2075
2076 if (slot2 != NULL) {
2077 PyObject *x = slot2(operand1, operand2);
2078
2079 if (x != Py_NotImplemented) {
2080 obj_result = x;
2081 goto exit_binary_result_object;
2082 }
2083
2084 Py_DECREF_IMMORTAL(x);
2085 }
2086
2087 // Statically recognized that coercion is not possible with these types
2088
2089 PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for >>: 'int' and 'long'");
2090 goto exit_binary_exception;
2091
2092exit_binary_result_object:
2093 return obj_result;
2094
2095exit_binary_exception:
2096 return NULL;
2097}
2098
2099PyObject *BINARY_OPERATION_RSHIFT_OBJECT_INT_LONG(PyObject *operand1, PyObject *operand2) {
2100 return _BINARY_OPERATION_RSHIFT_OBJECT_INT_LONG(operand1, operand2);
2101}
2102#endif
2103
2104#if PYTHON_VERSION < 0x300
2105/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
2106static nuitka_bool _BINARY_OPERATION_RSHIFT_NBOOL_LONG_INT(PyObject *operand1, PyObject *operand2) {
2107 CHECK_OBJECT(operand1);
2108 assert(PyLong_CheckExact(operand1));
2109 CHECK_OBJECT(operand2);
2110 assert(PyInt_CheckExact(operand2));
2111
2112#if defined(_MSC_VER)
2113#pragma warning(push)
2114#pragma warning(disable : 4101)
2115#endif
2116 NUITKA_MAY_BE_UNUSED bool cbool_result;
2117 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
2118#if defined(_MSC_VER)
2119#pragma warning(pop)
2120#endif
2121
2122 binaryfunc slot1 = PyLong_Type.tp_as_number->nb_rshift;
2123 // Slot2 ignored on purpose, type1 takes precedence.
2124
2125 if (slot1 != NULL) {
2126 PyObject *x = slot1(operand1, operand2);
2127
2128 if (x != Py_NotImplemented) {
2129 obj_result = x;
2130 goto exit_binary_result_object;
2131 }
2132
2133 Py_DECREF_IMMORTAL(x);
2134 }
2135
2136 // Statically recognized that coercion is not possible with these types
2137
2138 PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for >>: 'long' and 'int'");
2139 goto exit_binary_exception;
2140
2141exit_binary_result_object:
2142 if (unlikely(obj_result == NULL)) {
2143 return NUITKA_BOOL_EXCEPTION;
2144 }
2145
2146 {
2147 nuitka_bool r = CHECK_IF_TRUE(obj_result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
2148 Py_DECREF(obj_result);
2149 return r;
2150 }
2151
2152exit_binary_exception:
2153 return NUITKA_BOOL_EXCEPTION;
2154}
2155
2156nuitka_bool BINARY_OPERATION_RSHIFT_NBOOL_LONG_INT(PyObject *operand1, PyObject *operand2) {
2157 return _BINARY_OPERATION_RSHIFT_NBOOL_LONG_INT(operand1, operand2);
2158}
2159#endif
2160
2161#if PYTHON_VERSION < 0x300
2162/* Code referring to "INT" corresponds to Python2 'int' and "LONG" to Python2 'long', Python3 'int'. */
2163static nuitka_bool _BINARY_OPERATION_RSHIFT_NBOOL_INT_LONG(PyObject *operand1, PyObject *operand2) {
2164 CHECK_OBJECT(operand1);
2165 assert(PyInt_CheckExact(operand1));
2166 CHECK_OBJECT(operand2);
2167 assert(PyLong_CheckExact(operand2));
2168
2169#if defined(_MSC_VER)
2170#pragma warning(push)
2171#pragma warning(disable : 4101)
2172#endif
2173 NUITKA_MAY_BE_UNUSED bool cbool_result;
2174 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
2175#if defined(_MSC_VER)
2176#pragma warning(pop)
2177#endif
2178
2179 // Slot1 ignored on purpose, type2 takes precedence.
2180 binaryfunc slot2 = NULL;
2181
2182 if (!(0)) {
2183 // Different types, need to consider second value slot.
2184
2185 slot2 = PyLong_Type.tp_as_number->nb_rshift;
2186 }
2187
2188 if (slot2 != NULL) {
2189 PyObject *x = slot2(operand1, operand2);
2190
2191 if (x != Py_NotImplemented) {
2192 obj_result = x;
2193 goto exit_binary_result_object;
2194 }
2195
2196 Py_DECREF_IMMORTAL(x);
2197 }
2198
2199 // Statically recognized that coercion is not possible with these types
2200
2201 PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for >>: 'int' and 'long'");
2202 goto exit_binary_exception;
2203
2204exit_binary_result_object:
2205 if (unlikely(obj_result == NULL)) {
2206 return NUITKA_BOOL_EXCEPTION;
2207 }
2208
2209 {
2210 nuitka_bool r = CHECK_IF_TRUE(obj_result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
2211 Py_DECREF(obj_result);
2212 return r;
2213 }
2214
2215exit_binary_exception:
2216 return NUITKA_BOOL_EXCEPTION;
2217}
2218
2219nuitka_bool BINARY_OPERATION_RSHIFT_NBOOL_INT_LONG(PyObject *operand1, PyObject *operand2) {
2220 return _BINARY_OPERATION_RSHIFT_NBOOL_INT_LONG(operand1, operand2);
2221}
2222#endif
2223
2224/* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
2225static PyObject *_BINARY_OPERATION_RSHIFT_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2) {
2226 CHECK_OBJECT(operand1);
2227 CHECK_OBJECT(operand2);
2228
2229#if PYTHON_VERSION < 0x300
2230 if (PyInt_CheckExact(operand1) && PyInt_CheckExact(operand2)) {
2231 PyObject *result;
2232
2233 // Not every code path will make use of all possible results.
2234#if defined(_MSC_VER)
2235#pragma warning(push)
2236#pragma warning(disable : 4101)
2237#endif
2238 NUITKA_MAY_BE_UNUSED bool cbool_result;
2239 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
2240 NUITKA_MAY_BE_UNUSED long clong_result;
2241 NUITKA_MAY_BE_UNUSED double cfloat_result;
2242#if defined(_MSC_VER)
2243#pragma warning(pop)
2244#endif
2245
2246 CHECK_OBJECT(operand1);
2247 assert(PyInt_CheckExact(operand1));
2248 CHECK_OBJECT(operand2);
2249 assert(PyInt_CheckExact(operand2));
2250
2251 const long a = PyInt_AS_LONG(operand1);
2252 const long b = PyInt_AS_LONG(operand2);
2253
2254 if (unlikely(b < 0)) {
2255 PyThreadState *tstate = PyThreadState_GET();
2256
2257 SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_ValueError, "negative shift count");
2258 goto exit_result_exception;
2259 }
2260
2261 /* Short cut for zero shift or shifting zero. */
2262 if (a == 0 || b == 0) {
2263 goto exit_result_ok_left;
2264 } else if (b >= LONG_BIT) {
2265 if (a < 0) {
2266 goto exit_result_ok_const_int_neg_1;
2267 } else {
2268 goto exit_result_ok_const_int_0;
2269 }
2270 } else {
2271 long r = Py_ARITHMETIC_RIGHT_SHIFT(long, a, b);
2272
2273 clong_result = r;
2274 goto exit_result_ok_clong;
2275 }
2276
2277 exit_result_ok_clong:
2278 result = Nuitka_PyInt_FromLong(clong_result);
2279 goto exit_result_ok;
2280
2281 exit_result_ok_left:
2282 result = operand1;
2283 Py_INCREF(result);
2284 goto exit_result_ok;
2285
2286 exit_result_ok_const_int_0:
2287 Py_INCREF(const_int_0);
2288 result = const_int_0;
2289 goto exit_result_ok;
2290
2291 exit_result_ok_const_int_neg_1:
2292 Py_INCREF(const_int_neg_1);
2293 result = const_int_neg_1;
2294 goto exit_result_ok;
2295
2296 exit_result_ok:
2297 return result;
2298
2299 exit_result_exception:
2300 return NULL;
2301 }
2302#endif
2303
2304 PyTypeObject *type1 = Py_TYPE(operand1);
2305 PyTypeObject *type2 = Py_TYPE(operand2);
2306
2307#if defined(_MSC_VER)
2308#pragma warning(push)
2309#pragma warning(disable : 4101)
2310#endif
2311 NUITKA_MAY_BE_UNUSED bool cbool_result;
2312 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
2313#if defined(_MSC_VER)
2314#pragma warning(pop)
2315#endif
2316
2317 binaryfunc slot1 =
2318 (type1->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type1)) ? type1->tp_as_number->nb_rshift : NULL;
2319 binaryfunc slot2 = NULL;
2320
2321 if (!(type1 == type2)) {
2322 // Different types, need to consider second value slot.
2323
2324 slot2 = (type2->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type2)) ? type2->tp_as_number->nb_rshift : NULL;
2325
2326 if (slot1 == slot2) {
2327 slot2 = NULL;
2328 }
2329 }
2330
2331 if (slot1 != NULL) {
2332 if (slot2 != NULL) {
2333 if (Nuitka_Type_IsSubtype(type2, type1)) {
2334 PyObject *x = slot2(operand1, operand2);
2335
2336 if (x != Py_NotImplemented) {
2337 obj_result = x;
2338 goto exit_binary_result_object;
2339 }
2340
2341 Py_DECREF_IMMORTAL(x);
2342 slot2 = NULL;
2343 }
2344 }
2345
2346 PyObject *x = slot1(operand1, operand2);
2347
2348 if (x != Py_NotImplemented) {
2349 obj_result = x;
2350 goto exit_binary_result_object;
2351 }
2352
2353 Py_DECREF_IMMORTAL(x);
2354 }
2355
2356 if (slot2 != NULL) {
2357 PyObject *x = slot2(operand1, operand2);
2358
2359 if (x != Py_NotImplemented) {
2360 obj_result = x;
2361 goto exit_binary_result_object;
2362 }
2363
2364 Py_DECREF_IMMORTAL(x);
2365 }
2366
2367#if PYTHON_VERSION < 0x300
2368 if (!NEW_STYLE_NUMBER_TYPE(type1) || !NEW_STYLE_NUMBER_TYPE(type2)) {
2369 coercion c1 =
2370 (type1->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type1)) ? type1->tp_as_number->nb_coerce : NULL;
2371
2372 if (c1 != NULL) {
2373 PyObject *coerced1 = operand1;
2374 PyObject *coerced2 = operand2;
2375
2376 int err = c1(&coerced1, &coerced2);
2377
2378 if (unlikely(err < 0)) {
2379 goto exit_binary_exception;
2380 }
2381
2382 if (err == 0) {
2383 PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
2384
2385 if (likely(mv == NULL)) {
2386 binaryfunc slot = mv->nb_rshift;
2387
2388 if (likely(slot != NULL)) {
2389 PyObject *x = slot(coerced1, coerced2);
2390
2391 Py_DECREF(coerced1);
2392 Py_DECREF(coerced2);
2393
2394 obj_result = x;
2395 goto exit_binary_result_object;
2396 }
2397 }
2398
2399 // nb_coerce took a reference.
2400 Py_DECREF(coerced1);
2401 Py_DECREF(coerced2);
2402 }
2403 }
2404 coercion c2 =
2405 (type2->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type2)) ? type2->tp_as_number->nb_coerce : NULL;
2406
2407 if (c2 != NULL) {
2408 PyObject *coerced1 = operand1;
2409 PyObject *coerced2 = operand2;
2410
2411 int err = c2(&coerced2, &coerced1);
2412
2413 if (unlikely(err < 0)) {
2414 goto exit_binary_exception;
2415 }
2416
2417 if (err == 0) {
2418 PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
2419
2420 if (likely(mv == NULL)) {
2421 binaryfunc slot = mv->nb_rshift;
2422
2423 if (likely(slot != NULL)) {
2424 PyObject *x = slot(coerced1, coerced2);
2425
2426 Py_DECREF(coerced1);
2427 Py_DECREF(coerced2);
2428
2429 obj_result = x;
2430 goto exit_binary_result_object;
2431 }
2432 }
2433
2434 // nb_coerce took a reference.
2435 Py_DECREF(coerced1);
2436 Py_DECREF(coerced2);
2437 }
2438 }
2439 }
2440#endif
2441
2442 PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for >>: '%s' and '%s'", type1->tp_name, type2->tp_name);
2443 goto exit_binary_exception;
2444
2445exit_binary_result_object:
2446 return obj_result;
2447
2448exit_binary_exception:
2449 return NULL;
2450}
2451
2452PyObject *BINARY_OPERATION_RSHIFT_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2) {
2453 return _BINARY_OPERATION_RSHIFT_OBJECT_OBJECT_OBJECT(operand1, operand2);
2454}
2455
2456/* Code referring to "OBJECT" corresponds to any Python object and "OBJECT" to any Python object. */
2457static nuitka_bool _BINARY_OPERATION_RSHIFT_NBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2) {
2458 CHECK_OBJECT(operand1);
2459 CHECK_OBJECT(operand2);
2460
2461#if PYTHON_VERSION < 0x300
2462 if (PyInt_CheckExact(operand1) && PyInt_CheckExact(operand2)) {
2463 nuitka_bool result;
2464
2465 // Not every code path will make use of all possible results.
2466#if defined(_MSC_VER)
2467#pragma warning(push)
2468#pragma warning(disable : 4101)
2469#endif
2470 NUITKA_MAY_BE_UNUSED bool cbool_result;
2471 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
2472 NUITKA_MAY_BE_UNUSED long clong_result;
2473 NUITKA_MAY_BE_UNUSED double cfloat_result;
2474#if defined(_MSC_VER)
2475#pragma warning(pop)
2476#endif
2477
2478 CHECK_OBJECT(operand1);
2479 assert(PyInt_CheckExact(operand1));
2480 CHECK_OBJECT(operand2);
2481 assert(PyInt_CheckExact(operand2));
2482
2483 const long a = PyInt_AS_LONG(operand1);
2484 const long b = PyInt_AS_LONG(operand2);
2485
2486 if (unlikely(b < 0)) {
2487 PyThreadState *tstate = PyThreadState_GET();
2488
2489 SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_ValueError, "negative shift count");
2490 goto exit_result_exception;
2491 }
2492
2493 /* Short cut for zero shift or shifting zero. */
2494 if (a == 0 || b == 0) {
2495 goto exit_result_ok_left;
2496 } else if (b >= LONG_BIT) {
2497 if (a < 0) {
2498 goto exit_result_ok_const_int_neg_1;
2499 } else {
2500 goto exit_result_ok_const_int_0;
2501 }
2502 } else {
2503 long r = Py_ARITHMETIC_RIGHT_SHIFT(long, a, b);
2504
2505 clong_result = r;
2506 goto exit_result_ok_clong;
2507 }
2508
2509 exit_result_ok_clong:
2510 result = clong_result != 0 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
2511 goto exit_result_ok;
2512
2513 exit_result_ok_left:
2514 result = PyInt_AS_LONG(operand1) != 0 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
2515 goto exit_result_ok;
2516
2517 exit_result_ok_const_int_0:
2518 result = 0 != 0 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
2519 goto exit_result_ok;
2520
2521 exit_result_ok_const_int_neg_1:
2522 result = -1 != 0 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
2523 goto exit_result_ok;
2524
2525 exit_result_ok:
2526 return result;
2527
2528 exit_result_exception:
2529 return NUITKA_BOOL_EXCEPTION;
2530 }
2531#endif
2532
2533 PyTypeObject *type1 = Py_TYPE(operand1);
2534 PyTypeObject *type2 = Py_TYPE(operand2);
2535
2536#if defined(_MSC_VER)
2537#pragma warning(push)
2538#pragma warning(disable : 4101)
2539#endif
2540 NUITKA_MAY_BE_UNUSED bool cbool_result;
2541 NUITKA_MAY_BE_UNUSED PyObject *obj_result;
2542#if defined(_MSC_VER)
2543#pragma warning(pop)
2544#endif
2545
2546 binaryfunc slot1 =
2547 (type1->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type1)) ? type1->tp_as_number->nb_rshift : NULL;
2548 binaryfunc slot2 = NULL;
2549
2550 if (!(type1 == type2)) {
2551 // Different types, need to consider second value slot.
2552
2553 slot2 = (type2->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type2)) ? type2->tp_as_number->nb_rshift : NULL;
2554
2555 if (slot1 == slot2) {
2556 slot2 = NULL;
2557 }
2558 }
2559
2560 if (slot1 != NULL) {
2561 if (slot2 != NULL) {
2562 if (Nuitka_Type_IsSubtype(type2, type1)) {
2563 PyObject *x = slot2(operand1, operand2);
2564
2565 if (x != Py_NotImplemented) {
2566 obj_result = x;
2567 goto exit_binary_result_object;
2568 }
2569
2570 Py_DECREF_IMMORTAL(x);
2571 slot2 = NULL;
2572 }
2573 }
2574
2575 PyObject *x = slot1(operand1, operand2);
2576
2577 if (x != Py_NotImplemented) {
2578 obj_result = x;
2579 goto exit_binary_result_object;
2580 }
2581
2582 Py_DECREF_IMMORTAL(x);
2583 }
2584
2585 if (slot2 != NULL) {
2586 PyObject *x = slot2(operand1, operand2);
2587
2588 if (x != Py_NotImplemented) {
2589 obj_result = x;
2590 goto exit_binary_result_object;
2591 }
2592
2593 Py_DECREF_IMMORTAL(x);
2594 }
2595
2596#if PYTHON_VERSION < 0x300
2597 if (!NEW_STYLE_NUMBER_TYPE(type1) || !NEW_STYLE_NUMBER_TYPE(type2)) {
2598 coercion c1 =
2599 (type1->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type1)) ? type1->tp_as_number->nb_coerce : NULL;
2600
2601 if (c1 != NULL) {
2602 PyObject *coerced1 = operand1;
2603 PyObject *coerced2 = operand2;
2604
2605 int err = c1(&coerced1, &coerced2);
2606
2607 if (unlikely(err < 0)) {
2608 goto exit_binary_exception;
2609 }
2610
2611 if (err == 0) {
2612 PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
2613
2614 if (likely(mv == NULL)) {
2615 binaryfunc slot = mv->nb_rshift;
2616
2617 if (likely(slot != NULL)) {
2618 PyObject *x = slot(coerced1, coerced2);
2619
2620 Py_DECREF(coerced1);
2621 Py_DECREF(coerced2);
2622
2623 obj_result = x;
2624 goto exit_binary_result_object;
2625 }
2626 }
2627
2628 // nb_coerce took a reference.
2629 Py_DECREF(coerced1);
2630 Py_DECREF(coerced2);
2631 }
2632 }
2633 coercion c2 =
2634 (type2->tp_as_number != NULL && NEW_STYLE_NUMBER_TYPE(type2)) ? type2->tp_as_number->nb_coerce : NULL;
2635
2636 if (c2 != NULL) {
2637 PyObject *coerced1 = operand1;
2638 PyObject *coerced2 = operand2;
2639
2640 int err = c2(&coerced2, &coerced1);
2641
2642 if (unlikely(err < 0)) {
2643 goto exit_binary_exception;
2644 }
2645
2646 if (err == 0) {
2647 PyNumberMethods *mv = Py_TYPE(coerced1)->tp_as_number;
2648
2649 if (likely(mv == NULL)) {
2650 binaryfunc slot = mv->nb_rshift;
2651
2652 if (likely(slot != NULL)) {
2653 PyObject *x = slot(coerced1, coerced2);
2654
2655 Py_DECREF(coerced1);
2656 Py_DECREF(coerced2);
2657
2658 obj_result = x;
2659 goto exit_binary_result_object;
2660 }
2661 }
2662
2663 // nb_coerce took a reference.
2664 Py_DECREF(coerced1);
2665 Py_DECREF(coerced2);
2666 }
2667 }
2668 }
2669#endif
2670
2671 PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for >>: '%s' and '%s'", type1->tp_name, type2->tp_name);
2672 goto exit_binary_exception;
2673
2674exit_binary_result_object:
2675 if (unlikely(obj_result == NULL)) {
2676 return NUITKA_BOOL_EXCEPTION;
2677 }
2678
2679 {
2680 nuitka_bool r = CHECK_IF_TRUE(obj_result) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
2681 Py_DECREF(obj_result);
2682 return r;
2683 }
2684
2685exit_binary_exception:
2686 return NUITKA_BOOL_EXCEPTION;
2687}
2688
2689nuitka_bool BINARY_OPERATION_RSHIFT_NBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *operand2) {
2690 return _BINARY_OPERATION_RSHIFT_NBOOL_OBJECT_OBJECT(operand1, operand2);
2691}
2692
2693// Part of "Nuitka", an optimizing Python compiler that is compatible and
2694// integrates with CPython, but also works on its own.
2695//
2696// Licensed under the Apache License, Version 2.0 (the "License");
2697// you may not use this file except in compliance with the License.
2698// You may obtain a copy of the License at
2699//
2700// http://www.apache.org/licenses/LICENSE-2.0
2701//
2702// Unless required by applicable law or agreed to in writing, software
2703// distributed under the License is distributed on an "AS IS" BASIS,
2704// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2705// See the License for the specific language governing permissions and
2706// limitations under the License.