Nuitka-winsvc 2.1.5__cp311-cp311-win_amd64.whl → 2.2.1__cp311-cp311-win_amd64.whl

nuitka/build/static_src/CompiledGeneratorTypeUncompiledIntegration.c

@@ -19,6 +19,11 @@
 #undef Py_BUILD_CORE
 #endif
 
+#if PYTHON_VERSION >= 0x300
+static PyObject *Nuitka_CallGeneratorThrowMethod(PyObject *throw_method,
+                                                 struct Nuitka_ExceptionPreservationItem *exception_state);
+#endif
+
 // This function takes no reference to value, and publishes a StopIteration
 // exception with it.
 #if PYTHON_VERSION >= 0x300
@@ -32,8 +37,7 @@ static void Nuitka_SetStopIterationValue(PyThreadState *tstate, PyObject *value)
         return;
     }
 
-    Py_INCREF(PyExc_StopIteration);
-    RESTORE_ERROR_OCCURRED(tstate, PyExc_StopIteration, stop_value, NULL);
+    SET_CURRENT_EXCEPTION_TYPE0_VALUE1(tstate, PyExc_StopIteration, stop_value);
 #else
     if (likely(!PyTuple_Check(value) && !PyExceptionInstance_Check(value))) {
         Py_INCREF(PyExc_StopIteration);
@@ -41,14 +45,13 @@ static void Nuitka_SetStopIterationValue(PyThreadState *tstate, PyObject *value)
 
         RESTORE_ERROR_OCCURRED(tstate, PyExc_StopIteration, value, NULL);
     } else {
-        PyObject *stop_value = CALL_FUNCTION_WITH_SINGLE_ARG(tstate, PyExc_StopIteration, value);
+        PyObject *stop_value = CALL_FUNCTION_WITH_SINGLE_ARG(tstate, (PyObject *)PyExc_StopIteration, value);
 
         if (unlikely(stop_value == NULL)) {
             return;
         }
 
         Py_INCREF(PyExc_StopIteration);
-
         RESTORE_ERROR_OCCURRED(tstate, PyExc_StopIteration, stop_value, NULL);
     }
 #endif
@@ -256,10 +259,11 @@ static PyObject *Nuitka_PyGen_Send(PyThreadState *tstate, PyGenObject *gen, PyOb
         if (result == Py_None) {
             SET_CURRENT_EXCEPTION_TYPE0(tstate, PyExc_StopIteration);
         } else {
-            PyObject *e = PyObject_CallFunctionObjArgs(PyExc_StopIteration, result, NULL);
+            PyObject *e = CALL_FUNCTION_WITH_SINGLE_ARG(tstate, (PyObject *)PyExc_StopIteration, result);
 
-            if (e != NULL) {
-                SET_CURRENT_EXCEPTION_TYPE0_VALUE1(tstate, PyExc_StopIteration, e);
+            if (likely(e != NULL)) {
+                Py_INCREF(PyExc_StopIteration);
+                RESTORE_ERROR_OCCURRED(tstate, PyExc_StopIteration, e, NULL);
             }
         }
 
@@ -349,8 +353,8 @@ static PyObject *Nuitka_PyGen_Send(PyThreadState *tstate, PyGenObject *gen, PyOb
 
 #if NUITKA_UNCOMPILED_THROW_INTEGRATION
 
-static bool _Nuitka_Generator_check_throw2(PyThreadState *tstate, PyObject **exception_type, PyObject **exception_value,
-                                           PyTracebackObject **exception_tb);
+static bool _Nuitka_Generator_check_throw(PyThreadState *tstate,
+                                          struct Nuitka_ExceptionPreservationItem *exception_state);
 
 #if PYTHON_VERSION < 0x3b0
 #include <opcode.h>
@@ -785,17 +789,15 @@ static PyFrameObject *_Nuitka_PyFrame_New_NoTrack(PyCodeObject *code) {
 static PyFrameObject *_Nuitka_PyFrame_MakeAndSetFrameObject(PyThreadState *tstate, _PyInterpreterFrame *frame) {
     assert(frame->frame_obj == NULL);
 
-    PyObject *error_type, *error_value;
-    PyTracebackObject *error_traceback;
-
-    FETCH_ERROR_OCCURRED(tstate, &error_type, &error_value, &error_traceback);
+    struct Nuitka_ExceptionPreservationItem saved_exception_state;
+    FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
 
     PyFrameObject *f = _Nuitka_PyFrame_New_NoTrack(frame->f_code);
 
     // Out of memory should be rare.
     assert(f != NULL);
 
-    RESTORE_ERROR_OCCURRED(tstate, error_type, error_value, error_traceback);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
 
     // Apparently there are situations where there is a race with what code creates the
     // frame, and this time it's not us.
@@ -1037,12 +1039,11 @@ static PyObject *Nuitka_PyGen_gen_send_ex(PyThreadState *tstate, PyGenObject *ge
 //   value of exception_type will not be NULL, but the actual exception will not necessarily
 //   be normalized.
 static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenObject *gen, int close_on_genexit,
-                                                  PyObject *exception_type, PyObject *exception_value,
-                                                  PyTracebackObject *exception_tb) {
+                                                  struct Nuitka_ExceptionPreservationItem *exception_state) {
 #if _DEBUG_GENERATOR
     PRINT_STRING("Nuitka_UncompiledGenerator_throw: Enter ");
     PRINT_ITEM((PyObject *)gen);
-    PRINT_EXCEPTION(exception_type, exception_value, exception_tb);
+    PRINT_EXCEPTION_STATE(exception_state);
     PRINT_NEW_LINE();
 #endif
 
@@ -1051,7 +1052,8 @@ static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenOb
     if (yf != NULL) {
         _PyInterpreterFrame *frame = (_PyInterpreterFrame *)gen->gi_iframe;
 
-        if (close_on_genexit && EXCEPTION_MATCH_BOOL_SINGLE(tstate, exception_type, PyExc_GeneratorExit)) {
+        if (close_on_genexit &&
+            EXCEPTION_MATCH_BOOL_SINGLE(tstate, exception_state->exception_type, PyExc_GeneratorExit)) {
             PyFrameState state = (PyFrameState)gen->gi_frame_state;
             gen->gi_frame_state = FRAME_EXECUTING;
 
@@ -1064,9 +1066,7 @@ static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenOb
             if (err < 0) {
                 // Releasing exception, we are done with it, raising instead the error just
                 // occurred.
-                Py_DECREF(exception_type);
-                Py_XDECREF(exception_value);
-                Py_XDECREF(exception_tb);
+                RELEASE_ERROR_OCCURRED_STATE(exception_state);
 
                 return Nuitka_PyGen_gen_send_ex(tstate, gen, Py_None, 1, 0);
             }
@@ -1085,8 +1085,7 @@ static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenOb
             gen->gi_frame_state = FRAME_EXECUTING;
 
             // Handing exception ownership to "Nuitka_UncompiledGenerator_throw".
-            ret = Nuitka_UncompiledGenerator_throw(tstate, (PyGenObject *)yf, close_on_genexit, exception_type,
-                                                   exception_value, exception_tb);
+            ret = Nuitka_UncompiledGenerator_throw(tstate, (PyGenObject *)yf, close_on_genexit, exception_state);
             gen->gi_frame_state = state;
             tstate->cframe->current_frame = prev;
             frame->previous = NULL;
@@ -1114,15 +1113,12 @@ static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenOb
             PyFrameState state = (PyFrameState)gen->gi_frame_state;
             gen->gi_frame_state = FRAME_EXECUTING;
 
-            // TODO: Faster call code should be used.
-            ret = PyObject_CallFunctionObjArgs(meth, exception_type, exception_value, exception_tb, NULL);
+            ret = Nuitka_CallGeneratorThrowMethod(meth, exception_state);
 
             gen->gi_frame_state = state;
 
             // Releasing exception, we are done with it.
-            Py_DECREF(exception_type);
-            Py_XDECREF(exception_value);
-            Py_XDECREF(exception_tb);
+            RELEASE_ERROR_OCCURRED_STATE(exception_state);
 
             Py_DECREF(meth);
         }
@@ -1150,51 +1146,51 @@ static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenOb
     }
 
 throw_here:
-    if (exception_tb == (PyTracebackObject *)Py_None) {
-        exception_tb = NULL;
-        Py_DECREF(exception_tb);
-    } else if (exception_tb != NULL && !PyTraceBack_Check(exception_tb)) {
+    if (exception_state->exception_tb == (PyTracebackObject *)Py_None) {
+        exception_state->exception_tb = NULL;
+        Py_DECREF(exception_state->exception_tb);
+    } else if (exception_state->exception_tb != NULL && !PyTraceBack_Check(exception_state->exception_tb)) {
         SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "throw() third argument must be a traceback object");
         goto failed_throw;
     }
 
     tstate = _PyThreadState_GET();
 
-    if (PyExceptionClass_Check(exception_type)) {
-        Nuitka_Err_NormalizeException(tstate, &exception_type, &exception_value, &exception_tb);
-    } else if (PyExceptionInstance_Check(exception_type)) {
-        if (exception_value && exception_value != Py_None) {
+    if (PyExceptionClass_Check(exception_state->exception_type)) {
+        Nuitka_Err_NormalizeException(tstate, &exception_state->exception_type, &exception_state->exception_value,
+                                      &exception_state->exception_tb);
+    } else if (PyExceptionInstance_Check(exception_state->exception_type)) {
+        if (exception_state->exception_value && exception_state->exception_value != Py_None) {
             SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError,
                                             "instance exception may not have a separate value");
             goto failed_throw;
         } else {
             // Normalize manually here via APIs
-            Py_XDECREF(exception_value);
-            exception_value = exception_type;
-            exception_type = PyExceptionInstance_Class(exception_type);
-            Py_INCREF(exception_type);
+            Py_XDECREF(exception_state->exception_value);
+            exception_state->exception_value = exception_state->exception_type;
+            exception_state->exception_type = PyExceptionInstance_Class(exception_state->exception_type);
+            Py_INCREF(exception_state->exception_type);
 
-            if (exception_tb == NULL) {
+            if (exception_state->exception_tb == NULL) {
                 // Can remain NULL if no traceback is available.
-                exception_tb = GET_EXCEPTION_TRACEBACK(exception_value);
-                Py_XINCREF(exception_tb);
+                exception_state->exception_tb = GET_EXCEPTION_TRACEBACK(exception_state->exception_value);
+                Py_XINCREF(exception_state->exception_tb);
             }
         }
     } else {
         // Raisable
         SET_CURRENT_EXCEPTION_TYPE_COMPLAINT(
-            "exceptions must be classes or instances deriving from BaseException, not %s", exception_type);
+            "exceptions must be classes or instances deriving from BaseException, not %s",
+            exception_state->exception_type);
         goto failed_throw;
     }
 
-    RESTORE_ERROR_OCCURRED(tstate, exception_type, exception_value, exception_tb);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, exception_state);
 
     return Nuitka_PyGen_gen_send_ex(tstate, gen, Py_None, 1, 1);
 
 failed_throw:
-    Py_DECREF(exception_type);
-    Py_XDECREF(exception_value);
-    Py_XDECREF(exception_tb);
+    RELEASE_ERROR_OCCURRED_STATE(exception_state);
 
     return NULL;
 }
@@ -1467,19 +1463,19 @@ static PyObject *Nuitka_PyGen_gen_send_ex(PyThreadState *tstate, PyGenObject *ge
 //   value of exception_type will not be NULL, but the actual exception will not necessarily
 //   be normalized.
 static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenObject *gen, int close_on_genexit,
-                                                  PyObject *exception_type, PyObject *exception_value,
-                                                  PyTracebackObject *exception_tb) {
+                                                  struct Nuitka_ExceptionPreservationItem *exception_state) {
 #if _DEBUG_GENERATOR
     PRINT_STRING("Nuitka_UncompiledGenerator_throw: Enter ");
     PRINT_ITEM((PyObject *)gen);
-    PRINT_EXCEPTION(exception_type, exception_value, exception_tb);
+    PRINT_EXCEPTION_STATE(exception_state);
     PRINT_NEW_LINE();
 #endif
 
     PyObject *yf = Nuitka_PyGen_yf(gen);
 
     if (yf != NULL) {
-        if (close_on_genexit && EXCEPTION_MATCH_BOOL_SINGLE(tstate, exception_type, PyExc_GeneratorExit)) {
+        if (close_on_genexit &&
+            EXCEPTION_MATCH_BOOL_SINGLE(tstate, exception_state->exception_type, PyExc_GeneratorExit)) {
 #if PYTHON_VERSION < 0x3a0
             gen->gi_running = 1;
 #else
@@ -1498,9 +1494,7 @@ static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenOb
             if (err < 0) {
                 // Releasing exception, we are done with it, raising instead the error just
                 // occurred.
-                Py_DECREF(exception_type);
-                Py_XDECREF(exception_value);
-                Py_XDECREF(exception_tb);
+                RELEASE_ERROR_OCCURRED_STATE(exception_state);
 
                 return Nuitka_PyGen_gen_send_ex(tstate, gen, Py_None, 1, 0);
             }
@@ -1524,8 +1518,7 @@ static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenOb
 #endif
 
             // Handing exception ownership to "Nuitka_UncompiledGenerator_throw".
-            ret = Nuitka_UncompiledGenerator_throw(tstate, (PyGenObject *)yf, close_on_genexit, exception_type,
-                                                   exception_value, exception_tb);
+            ret = Nuitka_UncompiledGenerator_throw(tstate, (PyGenObject *)yf, close_on_genexit, exception_state);
 
 #if PYTHON_VERSION < 0x3a0
             gen->gi_running = 0;
@@ -1547,9 +1540,7 @@ static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenOb
                     Py_DECREF(yf);
 
                     // Releasing exception, we are done with it.
-                    Py_DECREF(exception_type);
-                    Py_XDECREF(exception_value);
-                    Py_XDECREF(exception_tb);
+                    RELEASE_ERROR_OCCURRED_STATE(exception_state);
 
                     return NULL;
                 }
@@ -1568,7 +1559,8 @@ static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenOb
             gen->gi_frame->f_state = FRAME_EXECUTING;
 #endif
             // TODO: Faster call code should be used.
-            ret = PyObject_CallFunctionObjArgs(meth, exception_type, exception_value, exception_tb, NULL);
+            ret = Nuitka_CallGeneratorThrowMethod(meth, exception_state);
+
 #if PYTHON_VERSION < 0x3a0
             gen->gi_running = 0;
 #else
@@ -1576,9 +1568,7 @@ static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenOb
 #endif
 
             // Releasing exception, we are done with it.
-            Py_DECREF(exception_type);
-            Py_XDECREF(exception_value);
-            Py_XDECREF(exception_tb);
+            RELEASE_ERROR_OCCURRED_STATE(exception_state);
 
             Py_DECREF(meth);
         }
@@ -1601,10 +1591,10 @@ static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenOb
             gen->gi_frame->f_lasti += 1;
 #endif
 
-            if (_PyGen_FetchStopIterationValue(&exception_value) == 0) {
-                ret = Nuitka_PyGen_gen_send_ex(tstate, gen, exception_value, 0, 0);
+            if (_PyGen_FetchStopIterationValue(&exception_state->exception_value) == 0) {
+                ret = Nuitka_PyGen_gen_send_ex(tstate, gen, exception_state->exception_value, 0, 0);
 
-                Py_DECREF(exception_value);
+                Py_DECREF(exception_state->exception_value);
             } else {
                 ret = Nuitka_PyGen_gen_send_ex(tstate, gen, Py_None, 1, 0);
             }
@@ -1614,13 +1604,13 @@ static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenOb
 
 throw_here:
     // We continue to have exception ownership here.
-    if (unlikely(_Nuitka_Generator_check_throw2(tstate, &exception_type, &exception_value, &exception_tb) == false)) {
-        // Exception was released by _Nuitka_Generator_check_throw2 already.
+    if (unlikely(_Nuitka_Generator_check_throw(tstate, exception_state) == false)) {
+        // Exception was released by _Nuitka_Generator_check_throw already.
         return NULL;
     }
 
     // Transfer exception ownership to published exception.
-    RESTORE_ERROR_OCCURRED(tstate, exception_type, exception_value, (PyTracebackObject *)exception_tb);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, exception_state);
 
     return Nuitka_PyGen_gen_send_ex(tstate, gen, Py_None, 1, 1);
 }

nuitka/build/static_src/CompiledMethodType.c

@@ -417,10 +417,9 @@ static void Nuitka_Method_tp_dealloc(struct Nuitka_MethodObject *method) {
     // Save the current exception, if any, we must to not corrupt it.
     PyThreadState *tstate = PyThreadState_GET();
 
-    PyObject *save_exception_type, *save_exception_value;
-    PyTracebackObject *save_exception_tb;
-    FETCH_ERROR_OCCURRED(tstate, &save_exception_type, &save_exception_value, &save_exception_tb);
-    RESTORE_ERROR_OCCURRED(tstate, save_exception_type, save_exception_value, save_exception_tb);
+    struct Nuitka_ExceptionPreservationItem saved_exception_state1;
+    FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state1);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state1);
 #endif
 
     Nuitka_GC_UnTrack(method);
@@ -438,9 +437,11 @@ static void Nuitka_Method_tp_dealloc(struct Nuitka_MethodObject *method) {
     releaseToFreeList(free_list_methods, method, MAX_METHOD_FREE_LIST_COUNT);
 
 #ifndef __NUITKA_NO_ASSERT__
-    assert(tstate->curexc_type == save_exception_type);
-    assert(tstate->curexc_value == save_exception_value);
-    assert((PyTracebackObject *)tstate->curexc_traceback == save_exception_tb);
+    struct Nuitka_ExceptionPreservationItem saved_exception_state2;
+    FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state2);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state2);
+
+    ASSERT_SAME_EXCEPTION_STATE(&saved_exception_state1, &saved_exception_state2);
 #endif
 }
 

nuitka/build/static_src/HelpersAttributes.c

@@ -1228,19 +1228,7 @@ PyObject *GET_MODULE_VARIABLE_VALUE_FALLBACK(PyThreadState *tstate, PyObject *va
     PyObject *result = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)variable_name);
 
     if (unlikely(result == NULL)) {
-        PyObject *exception_type;
-        PyObject *exception_value;
-
-        // TODO: Do this in one go, once FORMAT_NAME_ERROR becomes unused in code generation.
-        FORMAT_NAME_ERROR(&exception_type, &exception_value, variable_name);
-
-#if PYTHON_VERSION >= 0x300
-        // TODO: FORMAT_NAME_ERROR for Python3 should already produce this normalized and chained.
-        NORMALIZE_EXCEPTION(tstate, &exception_type, &exception_value, NULL);
-        CHAIN_EXCEPTION(tstate, exception_value);
-#endif
-
-        RESTORE_ERROR_OCCURRED(tstate, exception_type, exception_value, NULL);
+        SET_CURRENT_EXCEPTION_NAME_ERROR(tstate, variable_name);
     }
 
     return result;
@@ -1251,12 +1239,7 @@ PyObject *GET_MODULE_VARIABLE_VALUE_FALLBACK_IN_FUNCTION(PyThreadState *tstate,
     PyObject *result = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)variable_name);
 
     if (unlikely(result == NULL)) {
-        PyObject *exception_type;
-        PyObject *exception_value;
-
-        FORMAT_GLOBAL_NAME_ERROR(&exception_type, &exception_value, variable_name);
-
-        RESTORE_ERROR_OCCURRED(tstate, exception_type, exception_value, NULL);
+        SET_CURRENT_EXCEPTION_GLOBAL_NAME_ERROR(tstate, variable_name);
     }
 
     return result;

nuitka/build/static_src/HelpersBuiltin.c

@@ -20,8 +20,9 @@ PyObject *CALL_BUILTIN_KW_ARGS(PyThreadState *tstate, PyObject *callable, PyObje
     int i = 0;
 
     while (i < max_args) {
-        if (args[i] == NULL)
+        if (args[i] == NULL) {
             break;
+        }
 
         CHECK_OBJECT(args[i]);
 

nuitka/build/static_src/HelpersComparisonEq.c

@@ -2135,20 +2135,24 @@ static PyObject *COMPARE_EQ_OBJECT_UNICODE_UNICODE(PyObject *operand1, PyObject
         r = false;
     } else {
         int kind1 = PyUnicode_KIND(a);
+#if PYTHON_VERSION < 0x3c0
         if (unlikely(kind1 == 0)) {
             NUITKA_MAY_BE_UNUSED int res = _PyUnicode_Ready((PyObject *)a);
             assert(res != -1);
             kind1 = PyUnicode_KIND(a);
             assert(kind1 != 0);
         }
+#endif
 
         int kind2 = PyUnicode_KIND(b);
+#if PYTHON_VERSION < 0x3c0
         if (unlikely(kind2 == 0)) {
             NUITKA_MAY_BE_UNUSED int res = _PyUnicode_Ready((PyObject *)b);
             assert(res != -1);
             kind2 = PyUnicode_KIND(b);
             assert(kind2 != 0);
         }
+#endif
 
         if (kind1 != kind2) {
             r = false;
@@ -2805,20 +2809,24 @@ static bool COMPARE_EQ_CBOOL_UNICODE_UNICODE(PyObject *operand1, PyObject *opera
         r = false;
     } else {
         int kind1 = PyUnicode_KIND(a);
+#if PYTHON_VERSION < 0x3c0
         if (unlikely(kind1 == 0)) {
             NUITKA_MAY_BE_UNUSED int res = _PyUnicode_Ready((PyObject *)a);
             assert(res != -1);
             kind1 = PyUnicode_KIND(a);
             assert(kind1 != 0);
         }
+#endif
 
         int kind2 = PyUnicode_KIND(b);
+#if PYTHON_VERSION < 0x3c0
         if (unlikely(kind2 == 0)) {
             NUITKA_MAY_BE_UNUSED int res = _PyUnicode_Ready((PyObject *)b);
             assert(res != -1);
             kind2 = PyUnicode_KIND(b);
             assert(kind2 != 0);
         }
+#endif
 
         if (kind1 != kind2) {
             r = false;
@@ -6276,14 +6284,16 @@ static PyObject *COMPARE_EQ_OBJECT_LONG_LONG(PyObject *operand1, PyObject *opera
 
     if (operand1_long_object == operand2_long_object) {
         r = true;
-    } else if (Py_SIZE(operand1_long_object) != Py_SIZE(operand2_long_object)) {
+    } else if (Nuitka_LongGetSignedDigitSize(operand1_long_object) !=
+               Nuitka_LongGetSignedDigitSize(operand2_long_object)) {
         r = false;
     } else {
-        Py_ssize_t i = Py_ABS(Py_SIZE(operand1_long_object));
+        Py_ssize_t i = Nuitka_LongGetDigitSize(operand1_long_object);
         r = true;
 
         while (--i >= 0) {
-            if (operand1_long_object->ob_digit[i] != operand2_long_object->ob_digit[i]) {
+            if (Nuitka_LongGetDigitPointer(operand1_long_object)[i] !=
+                Nuitka_LongGetDigitPointer(operand2_long_object)[i]) {
                 r = false;
                 break;
             }
@@ -6903,14 +6913,16 @@ static bool COMPARE_EQ_CBOOL_LONG_LONG(PyObject *operand1, PyObject *operand2) {
 
     if (operand1_long_object == operand2_long_object) {
         r = true;
-    } else if (Py_SIZE(operand1_long_object) != Py_SIZE(operand2_long_object)) {
+    } else if (Nuitka_LongGetSignedDigitSize(operand1_long_object) !=
+               Nuitka_LongGetSignedDigitSize(operand2_long_object)) {
         r = false;
     } else {
-        Py_ssize_t i = Py_ABS(Py_SIZE(operand1_long_object));
+        Py_ssize_t i = Nuitka_LongGetDigitSize(operand1_long_object);
         r = true;
 
         while (--i >= 0) {
-            if (operand1_long_object->ob_digit[i] != operand2_long_object->ob_digit[i]) {
+            if (Nuitka_LongGetDigitPointer(operand1_long_object)[i] !=
+                Nuitka_LongGetDigitPointer(operand2_long_object)[i]) {
                 r = false;
                 break;
             }
@@ -11784,14 +11796,14 @@ static PyObject *COMPARE_EQ_OBJECT_LONG_CLONG(PyObject *operand1, long operand2)
 
     bool r;
 
-    if (Py_SIZE(operand1_long_object) != operand2_size) {
+    if (Nuitka_LongGetSignedDigitSize(operand1_long_object) != operand2_size) {
         r = false;
     } else {
-        Py_ssize_t i = Py_ABS(Py_SIZE(operand1_long_object));
+        Py_ssize_t i = Nuitka_LongGetDigitSize(operand1_long_object);
         r = true;
 
         while (--i >= 0) {
-            if (operand1_long_object->ob_digit[i] != operand2_digits[i]) {
+            if (Nuitka_LongGetDigitPointer(operand1_long_object)[i] != operand2_digits[i]) {
                 r = false;
                 break;
             }
@@ -11846,14 +11858,14 @@ static bool COMPARE_EQ_CBOOL_LONG_CLONG(PyObject *operand1, long operand2) {
 
     bool r;
 
-    if (Py_SIZE(operand1_long_object) != operand2_size) {
+    if (Nuitka_LongGetSignedDigitSize(operand1_long_object) != operand2_size) {
         r = false;
     } else {
-        Py_ssize_t i = Py_ABS(Py_SIZE(operand1_long_object));
+        Py_ssize_t i = Nuitka_LongGetDigitSize(operand1_long_object);
         r = true;
 
         while (--i >= 0) {
-            if (operand1_long_object->ob_digit[i] != operand2_digits[i]) {
+            if (Nuitka_LongGetDigitPointer(operand1_long_object)[i] != operand2_digits[i]) {
                 r = false;
                 break;
             }
@@ -11925,14 +11937,15 @@ static PyObject *COMPARE_EQ_OBJECT_LONG_DIGIT(PyObject *operand1, long operand2)
 
     bool r;
 
-    if (Py_SIZE(operand1_long_object) != (Py_ssize_t)((operand2 == 0) ? 0 : ((operand2 < 0) ? -1 : 1))) {
+    if (Nuitka_LongGetSignedDigitSize(operand1_long_object) !=
+        (Py_ssize_t)((operand2 == 0) ? 0 : ((operand2 < 0) ? -1 : 1))) {
         r = false;
     } else {
-        Py_ssize_t i = Py_ABS(Py_SIZE(operand1_long_object));
+        Py_ssize_t i = Nuitka_LongGetDigitSize(operand1_long_object);
         r = true;
 
         while (--i >= 0) {
-            if (operand1_long_object->ob_digit[i] != (digit)Py_ABS(operand2)) {
+            if (Nuitka_LongGetDigitPointer(operand1_long_object)[i] != (digit)Py_ABS(operand2)) {
                 r = false;
                 break;
             }
@@ -11960,14 +11973,15 @@ static bool COMPARE_EQ_CBOOL_LONG_DIGIT(PyObject *operand1, long operand2) {
 
     bool r;
 
-    if (Py_SIZE(operand1_long_object) != (Py_ssize_t)((operand2 == 0) ? 0 : ((operand2 < 0) ? -1 : 1))) {
+    if (Nuitka_LongGetSignedDigitSize(operand1_long_object) !=
+        (Py_ssize_t)((operand2 == 0) ? 0 : ((operand2 < 0) ? -1 : 1))) {
         r = false;
     } else {
-        Py_ssize_t i = Py_ABS(Py_SIZE(operand1_long_object));
+        Py_ssize_t i = Nuitka_LongGetDigitSize(operand1_long_object);
         r = true;
 
         while (--i >= 0) {
-            if (operand1_long_object->ob_digit[i] != (digit)Py_ABS(operand2)) {
+            if (Nuitka_LongGetDigitPointer(operand1_long_object)[i] != (digit)Py_ABS(operand2)) {
                 r = false;
                 break;
             }