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

nuitka/build/static_src/HelpersOperationBinaryAdd.c

@@ -1030,8 +1030,8 @@ static PyObject *_BINARY_OPERATION_ADD_OBJECT_LONG_LONG(PyObject *operand1, PyOb
 
     PyLongObject *operand2_long_object = (PyLongObject *)operand2;
 
-    if (Py_ABS(Py_SIZE(operand1_long_object)) <= 1 && Py_ABS(Py_SIZE(operand2_long_object)) <= 1) {
-        long r = MEDIUM_VALUE(operand1_long_object) + MEDIUM_VALUE(operand2_long_object);
+    if (Nuitka_LongGetDigitSize(operand1_long_object) <= 1 && Nuitka_LongGetDigitSize(operand2_long_object) <= 1) {
+        long r = (long)(MEDIUM_VALUE(operand1_long_object) + MEDIUM_VALUE(operand2_long_object));
 
         clong_result = r;
         goto exit_result_ok_clong;
@@ -1040,17 +1040,17 @@ static PyObject *_BINARY_OPERATION_ADD_OBJECT_LONG_LONG(PyObject *operand1, PyOb
     {
         PyLongObject *z;
 
-        digit const *a_digits = operand1_long_object->ob_digit;
-        Py_ssize_t a_digit_count = Py_ABS(Py_SIZE(operand1_long_object));
-        bool a_negative = Py_SIZE(operand1_long_object) < 0;
-        digit const *b_digits = operand2_long_object->ob_digit;
-        Py_ssize_t b_digit_count = Py_ABS(Py_SIZE(operand2_long_object));
-        bool b_negative = Py_SIZE(operand2_long_object) < 0;
+        digit const *a_digits = Nuitka_LongGetDigitPointer(operand1_long_object);
+        Py_ssize_t a_digit_count = Nuitka_LongGetDigitSize(operand1_long_object);
+        bool a_negative = Nuitka_LongIsNegative(operand1_long_object);
+        digit const *b_digits = Nuitka_LongGetDigitPointer(operand2_long_object);
+        Py_ssize_t b_digit_count = Nuitka_LongGetDigitSize(operand2_long_object);
+        bool b_negative = Nuitka_LongIsNegative(operand2_long_object);
 
         if (a_negative) {
             if (b_negative) {
                 z = _Nuitka_LongAddDigits(a_digits, a_digit_count, b_digits, b_digit_count);
-                Py_SET_SIZE(z, -(Py_SIZE(z)));
+                Nuitka_LongFlipSign(z);
             } else {
                 z = _Nuitka_LongSubDigits(b_digits, b_digit_count, a_digits, a_digit_count);
             }
@@ -1264,8 +1264,8 @@ static PyObject *_BINARY_OPERATION_ADD_OBJECT_OBJECT_LONG(PyObject *operand1, Py
 
         PyLongObject *operand2_long_object = (PyLongObject *)operand2;
 
-        if (Py_ABS(Py_SIZE(operand1_long_object)) <= 1 && Py_ABS(Py_SIZE(operand2_long_object)) <= 1) {
-            long r = MEDIUM_VALUE(operand1_long_object) + MEDIUM_VALUE(operand2_long_object);
+        if (Nuitka_LongGetDigitSize(operand1_long_object) <= 1 && Nuitka_LongGetDigitSize(operand2_long_object) <= 1) {
+            long r = (long)(MEDIUM_VALUE(operand1_long_object) + MEDIUM_VALUE(operand2_long_object));
 
             clong_result = r;
             goto exit_result_ok_clong;
@@ -1274,17 +1274,17 @@ static PyObject *_BINARY_OPERATION_ADD_OBJECT_OBJECT_LONG(PyObject *operand1, Py
         {
             PyLongObject *z;
 
-            digit const *a_digits = operand1_long_object->ob_digit;
-            Py_ssize_t a_digit_count = Py_ABS(Py_SIZE(operand1_long_object));
-            bool a_negative = Py_SIZE(operand1_long_object) < 0;
-            digit const *b_digits = operand2_long_object->ob_digit;
-            Py_ssize_t b_digit_count = Py_ABS(Py_SIZE(operand2_long_object));
-            bool b_negative = Py_SIZE(operand2_long_object) < 0;
+            digit const *a_digits = Nuitka_LongGetDigitPointer(operand1_long_object);
+            Py_ssize_t a_digit_count = Nuitka_LongGetDigitSize(operand1_long_object);
+            bool a_negative = Nuitka_LongIsNegative(operand1_long_object);
+            digit const *b_digits = Nuitka_LongGetDigitPointer(operand2_long_object);
+            Py_ssize_t b_digit_count = Nuitka_LongGetDigitSize(operand2_long_object);
+            bool b_negative = Nuitka_LongIsNegative(operand2_long_object);
 
             if (a_negative) {
                 if (b_negative) {
                     z = _Nuitka_LongAddDigits(a_digits, a_digit_count, b_digits, b_digit_count);
-                    Py_SET_SIZE(z, -(Py_SIZE(z)));
+                    Nuitka_LongFlipSign(z);
                 } else {
                     z = _Nuitka_LongSubDigits(b_digits, b_digit_count, a_digits, a_digit_count);
                 }
@@ -1506,8 +1506,8 @@ static PyObject *_BINARY_OPERATION_ADD_OBJECT_LONG_OBJECT(PyObject *operand1, Py
 
         PyLongObject *operand2_long_object = (PyLongObject *)operand2;
 
-        if (Py_ABS(Py_SIZE(operand1_long_object)) <= 1 && Py_ABS(Py_SIZE(operand2_long_object)) <= 1) {
-            long r = MEDIUM_VALUE(operand1_long_object) + MEDIUM_VALUE(operand2_long_object);
+        if (Nuitka_LongGetDigitSize(operand1_long_object) <= 1 && Nuitka_LongGetDigitSize(operand2_long_object) <= 1) {
+            long r = (long)(MEDIUM_VALUE(operand1_long_object) + MEDIUM_VALUE(operand2_long_object));
 
             clong_result = r;
             goto exit_result_ok_clong;
@@ -1516,17 +1516,17 @@ static PyObject *_BINARY_OPERATION_ADD_OBJECT_LONG_OBJECT(PyObject *operand1, Py
         {
             PyLongObject *z;
 
-            digit const *a_digits = operand1_long_object->ob_digit;
-            Py_ssize_t a_digit_count = Py_ABS(Py_SIZE(operand1_long_object));
-            bool a_negative = Py_SIZE(operand1_long_object) < 0;
-            digit const *b_digits = operand2_long_object->ob_digit;
-            Py_ssize_t b_digit_count = Py_ABS(Py_SIZE(operand2_long_object));
-            bool b_negative = Py_SIZE(operand2_long_object) < 0;
+            digit const *a_digits = Nuitka_LongGetDigitPointer(operand1_long_object);
+            Py_ssize_t a_digit_count = Nuitka_LongGetDigitSize(operand1_long_object);
+            bool a_negative = Nuitka_LongIsNegative(operand1_long_object);
+            digit const *b_digits = Nuitka_LongGetDigitPointer(operand2_long_object);
+            Py_ssize_t b_digit_count = Nuitka_LongGetDigitSize(operand2_long_object);
+            bool b_negative = Nuitka_LongIsNegative(operand2_long_object);
 
             if (a_negative) {
                 if (b_negative) {
                     z = _Nuitka_LongAddDigits(a_digits, a_digit_count, b_digits, b_digit_count);
-                    Py_SET_SIZE(z, -(Py_SIZE(z)));
+                    Nuitka_LongFlipSign(z);
                 } else {
                     z = _Nuitka_LongSubDigits(b_digits, b_digit_count, a_digits, a_digit_count);
                 }
@@ -1591,8 +1591,8 @@ static nuitka_bool _BINARY_OPERATION_ADD_NBOOL_LONG_LONG(PyObject *operand1, PyO
 
     PyLongObject *operand2_long_object = (PyLongObject *)operand2;
 
-    if (Py_ABS(Py_SIZE(operand1_long_object)) <= 1 && Py_ABS(Py_SIZE(operand2_long_object)) <= 1) {
-        long r = MEDIUM_VALUE(operand1_long_object) + MEDIUM_VALUE(operand2_long_object);
+    if (Nuitka_LongGetDigitSize(operand1_long_object) <= 1 && Nuitka_LongGetDigitSize(operand2_long_object) <= 1) {
+        long r = (long)(MEDIUM_VALUE(operand1_long_object) + MEDIUM_VALUE(operand2_long_object));
 
         clong_result = r;
         goto exit_result_ok_clong;
@@ -1601,17 +1601,17 @@ static nuitka_bool _BINARY_OPERATION_ADD_NBOOL_LONG_LONG(PyObject *operand1, PyO
     {
         PyLongObject *z;
 
-        digit const *a_digits = operand1_long_object->ob_digit;
-        Py_ssize_t a_digit_count = Py_ABS(Py_SIZE(operand1_long_object));
-        bool a_negative = Py_SIZE(operand1_long_object) < 0;
-        digit const *b_digits = operand2_long_object->ob_digit;
-        Py_ssize_t b_digit_count = Py_ABS(Py_SIZE(operand2_long_object));
-        bool b_negative = Py_SIZE(operand2_long_object) < 0;
+        digit const *a_digits = Nuitka_LongGetDigitPointer(operand1_long_object);
+        Py_ssize_t a_digit_count = Nuitka_LongGetDigitSize(operand1_long_object);
+        bool a_negative = Nuitka_LongIsNegative(operand1_long_object);
+        digit const *b_digits = Nuitka_LongGetDigitPointer(operand2_long_object);
+        Py_ssize_t b_digit_count = Nuitka_LongGetDigitSize(operand2_long_object);
+        bool b_negative = Nuitka_LongIsNegative(operand2_long_object);
 
         if (a_negative) {
             if (b_negative) {
                 z = _Nuitka_LongAddDigits(a_digits, a_digit_count, b_digits, b_digit_count);
-                Py_SET_SIZE(z, -(Py_SIZE(z)));
+                Nuitka_LongFlipSign(z);
             } else {
                 z = _Nuitka_LongSubDigits(b_digits, b_digit_count, a_digits, a_digit_count);
             }
@@ -1835,8 +1835,8 @@ static nuitka_bool _BINARY_OPERATION_ADD_NBOOL_OBJECT_LONG(PyObject *operand1, P
 
         PyLongObject *operand2_long_object = (PyLongObject *)operand2;
 
-        if (Py_ABS(Py_SIZE(operand1_long_object)) <= 1 && Py_ABS(Py_SIZE(operand2_long_object)) <= 1) {
-            long r = MEDIUM_VALUE(operand1_long_object) + MEDIUM_VALUE(operand2_long_object);
+        if (Nuitka_LongGetDigitSize(operand1_long_object) <= 1 && Nuitka_LongGetDigitSize(operand2_long_object) <= 1) {
+            long r = (long)(MEDIUM_VALUE(operand1_long_object) + MEDIUM_VALUE(operand2_long_object));
 
             clong_result = r;
             goto exit_result_ok_clong;
@@ -1845,17 +1845,17 @@ static nuitka_bool _BINARY_OPERATION_ADD_NBOOL_OBJECT_LONG(PyObject *operand1, P
         {
             PyLongObject *z;
 
-            digit const *a_digits = operand1_long_object->ob_digit;
-            Py_ssize_t a_digit_count = Py_ABS(Py_SIZE(operand1_long_object));
-            bool a_negative = Py_SIZE(operand1_long_object) < 0;
-            digit const *b_digits = operand2_long_object->ob_digit;
-            Py_ssize_t b_digit_count = Py_ABS(Py_SIZE(operand2_long_object));
-            bool b_negative = Py_SIZE(operand2_long_object) < 0;
+            digit const *a_digits = Nuitka_LongGetDigitPointer(operand1_long_object);
+            Py_ssize_t a_digit_count = Nuitka_LongGetDigitSize(operand1_long_object);
+            bool a_negative = Nuitka_LongIsNegative(operand1_long_object);
+            digit const *b_digits = Nuitka_LongGetDigitPointer(operand2_long_object);
+            Py_ssize_t b_digit_count = Nuitka_LongGetDigitSize(operand2_long_object);
+            bool b_negative = Nuitka_LongIsNegative(operand2_long_object);
 
             if (a_negative) {
                 if (b_negative) {
                     z = _Nuitka_LongAddDigits(a_digits, a_digit_count, b_digits, b_digit_count);
-                    Py_SET_SIZE(z, -(Py_SIZE(z)));
+                    Nuitka_LongFlipSign(z);
                 } else {
                     z = _Nuitka_LongSubDigits(b_digits, b_digit_count, a_digits, a_digit_count);
                 }
@@ -2087,8 +2087,8 @@ static nuitka_bool _BINARY_OPERATION_ADD_NBOOL_LONG_OBJECT(PyObject *operand1, P
 
         PyLongObject *operand2_long_object = (PyLongObject *)operand2;
 
-        if (Py_ABS(Py_SIZE(operand1_long_object)) <= 1 && Py_ABS(Py_SIZE(operand2_long_object)) <= 1) {
-            long r = MEDIUM_VALUE(operand1_long_object) + MEDIUM_VALUE(operand2_long_object);
+        if (Nuitka_LongGetDigitSize(operand1_long_object) <= 1 && Nuitka_LongGetDigitSize(operand2_long_object) <= 1) {
+            long r = (long)(MEDIUM_VALUE(operand1_long_object) + MEDIUM_VALUE(operand2_long_object));
 
             clong_result = r;
             goto exit_result_ok_clong;
@@ -2097,17 +2097,17 @@ static nuitka_bool _BINARY_OPERATION_ADD_NBOOL_LONG_OBJECT(PyObject *operand1, P
         {
             PyLongObject *z;
 
-            digit const *a_digits = operand1_long_object->ob_digit;
-            Py_ssize_t a_digit_count = Py_ABS(Py_SIZE(operand1_long_object));
-            bool a_negative = Py_SIZE(operand1_long_object) < 0;
-            digit const *b_digits = operand2_long_object->ob_digit;
-            Py_ssize_t b_digit_count = Py_ABS(Py_SIZE(operand2_long_object));
-            bool b_negative = Py_SIZE(operand2_long_object) < 0;
+            digit const *a_digits = Nuitka_LongGetDigitPointer(operand1_long_object);
+            Py_ssize_t a_digit_count = Nuitka_LongGetDigitSize(operand1_long_object);
+            bool a_negative = Nuitka_LongIsNegative(operand1_long_object);
+            digit const *b_digits = Nuitka_LongGetDigitPointer(operand2_long_object);
+            Py_ssize_t b_digit_count = Nuitka_LongGetDigitSize(operand2_long_object);
+            bool b_negative = Nuitka_LongIsNegative(operand2_long_object);
 
             if (a_negative) {
                 if (b_negative) {
                     z = _Nuitka_LongAddDigits(a_digits, a_digit_count, b_digits, b_digit_count);
-                    Py_SET_SIZE(z, -(Py_SIZE(z)));
+                    Nuitka_LongFlipSign(z);
                 } else {
                     z = _Nuitka_LongSubDigits(b_digits, b_digit_count, a_digits, a_digit_count);
                 }
@@ -3543,8 +3543,8 @@ static PyObject *_BINARY_OPERATION_ADD_OBJECT_LONG_DIGIT(PyObject *operand1, lon
 
     PyLongObject *operand1_long_object = (PyLongObject *)operand1;
 
-    if (Py_ABS(Py_SIZE(operand1_long_object)) <= 1 && (operand2 == 0 ? 0 : 1) <= 1) {
-        long r = MEDIUM_VALUE(operand1_long_object) + (sdigit)operand2;
+    if (Nuitka_LongGetDigitSize(operand1_long_object) <= 1 && (operand2 == 0 ? 0 : 1) <= 1) {
+        long r = (long)(MEDIUM_VALUE(operand1_long_object) + (sdigit)operand2);
 
         clong_result = r;
         goto exit_result_ok_clong;
@@ -3553,9 +3553,9 @@ static PyObject *_BINARY_OPERATION_ADD_OBJECT_LONG_DIGIT(PyObject *operand1, lon
     {
         PyLongObject *z;
 
-        digit const *a_digits = operand1_long_object->ob_digit;
-        Py_ssize_t a_digit_count = Py_ABS(Py_SIZE(operand1_long_object));
-        bool a_negative = Py_SIZE(operand1_long_object) < 0;
+        digit const *a_digits = Nuitka_LongGetDigitPointer(operand1_long_object);
+        Py_ssize_t a_digit_count = Nuitka_LongGetDigitSize(operand1_long_object);
+        bool a_negative = Nuitka_LongIsNegative(operand1_long_object);
         digit const *b_digits = (digit *)&operand2;
         Py_ssize_t b_digit_count = (operand2 == 0 ? 0 : 1);
         bool b_negative = operand2 < 0;
@@ -3563,7 +3563,7 @@ static PyObject *_BINARY_OPERATION_ADD_OBJECT_LONG_DIGIT(PyObject *operand1, lon
         if (a_negative) {
             if (b_negative) {
                 z = _Nuitka_LongAddDigits(a_digits, a_digit_count, b_digits, b_digit_count);
-                Py_SET_SIZE(z, -(Py_SIZE(z)));
+                Nuitka_LongFlipSign(z);
             } else {
                 z = _Nuitka_LongSubDigits(b_digits, b_digit_count, a_digits, a_digit_count);
             }
@@ -3623,8 +3623,8 @@ static nuitka_bool _BINARY_OPERATION_ADD_NBOOL_LONG_DIGIT(PyObject *operand1, lo
 
     PyLongObject *operand1_long_object = (PyLongObject *)operand1;
 
-    if (Py_ABS(Py_SIZE(operand1_long_object)) <= 1 && (operand2 == 0 ? 0 : 1) <= 1) {
-        long r = MEDIUM_VALUE(operand1_long_object) + (sdigit)operand2;
+    if (Nuitka_LongGetDigitSize(operand1_long_object) <= 1 && (operand2 == 0 ? 0 : 1) <= 1) {
+        long r = (long)(MEDIUM_VALUE(operand1_long_object) + (sdigit)operand2);
 
         clong_result = r;
         goto exit_result_ok_clong;
@@ -3633,9 +3633,9 @@ static nuitka_bool _BINARY_OPERATION_ADD_NBOOL_LONG_DIGIT(PyObject *operand1, lo
     {
         PyLongObject *z;
 
-        digit const *a_digits = operand1_long_object->ob_digit;
-        Py_ssize_t a_digit_count = Py_ABS(Py_SIZE(operand1_long_object));
-        bool a_negative = Py_SIZE(operand1_long_object) < 0;
+        digit const *a_digits = Nuitka_LongGetDigitPointer(operand1_long_object);
+        Py_ssize_t a_digit_count = Nuitka_LongGetDigitSize(operand1_long_object);
+        bool a_negative = Nuitka_LongIsNegative(operand1_long_object);
         digit const *b_digits = (digit *)&operand2;
         Py_ssize_t b_digit_count = (operand2 == 0 ? 0 : 1);
         bool b_negative = operand2 < 0;
@@ -3643,7 +3643,7 @@ static nuitka_bool _BINARY_OPERATION_ADD_NBOOL_LONG_DIGIT(PyObject *operand1, lo
         if (a_negative) {
             if (b_negative) {
                 z = _Nuitka_LongAddDigits(a_digits, a_digit_count, b_digits, b_digit_count);
-                Py_SET_SIZE(z, -(Py_SIZE(z)));
+                Nuitka_LongFlipSign(z);
             } else {
                 z = _Nuitka_LongSubDigits(b_digits, b_digit_count, a_digits, a_digit_count);
             }

nuitka/build/static_src/HelpersOperationBinaryAddUtils.c

@@ -43,26 +43,59 @@ static PyObject *LIST_CONCAT(PyObject *operand1, PyObject *operand2) {
     return (PyObject *)result;
 }
 
-// Convert single digit to sdigit (int32_t)
-#define MEDIUM_VALUE(x)                                                                                                \
-    (Py_SIZE(x) < 0 ? -(sdigit)((PyLongObject *)(x))->ob_digit[0]                                                      \
-                    : (Py_SIZE(x) == 0 ? (sdigit)0 : (sdigit)((PyLongObject *)(x))->ob_digit[0]))
-
 // Needed for offsetof
 #include <stddef.h>
 
+#if PYTHON_VERSION < 0x3c0
 #define MAX_LONG_DIGITS ((PY_SSIZE_T_MAX - offsetof(PyLongObject, ob_digit)) / sizeof(digit))
 #define Nuitka_LongGetDigitPointer(value) (&(((PyLongObject *)value)->ob_digit[0]))
 #define Nuitka_LongGetDigitSize(value) (Py_ABS(Py_SIZE(value)))
+#define Nuitka_LongGetSignedDigitSize(value) (Py_SIZE(value))
+#define Nuitka_LongIsNegative(value) (Py_SIZE(value) < 0)
+#define Nuitka_LongSetSignNegative(value) Py_SET_SIZE(value, -Py_ABS(Py_SIZE(value)))
+#define Nuitka_LongSetSign(value, positive) Py_SET_SIZE(value, (((positive) ? 1 : -1) * Py_ABS(Py_SIZE(value))))
+#define Nuitka_LongFlipSign(value) Py_SET_SIZE(value, -Py_SIZE(value))
+#define Nuitka_LongSetDigitSizeAndNegative(value, count, negative) Py_SET_SIZE(value, negative ? -count : count)
+#else
+#define MAX_LONG_DIGITS ((PY_SSIZE_T_MAX - offsetof(PyLongObject, long_value.ob_digit)) / sizeof(digit))
+
+#define Nuitka_LongGetDigitPointer(value) (&(((PyLongObject *)value)->long_value.ob_digit[0]))
+#define Nuitka_LongGetDigitSize(value) (_PyLong_DigitCount((PyLongObject const *)(value)))
+#define Nuitka_LongGetSignedDigitSize(value) (_PyLong_SignedDigitCount((PyLongObject const *)(value)))
+#define Nuitka_LongIsNegative(value) (((PyLongObject *)value)->long_value.lv_tag & SIGN_NEGATIVE)
+#define Nuitka_LongSetSignNegative(value)                                                                              \
+    ((PyLongObject *)value)->long_value.lv_tag = ((PyLongObject *)value)->long_value.lv_tag | SIGN_NEGATIVE;
+#define Nuitka_LongSetSignPositive(value)                                                                              \
+    ((PyLongObject *)value)->long_value.lv_tag = ((PyLongObject *)value)->long_value.lv_tag & ~(SIGN_NEGATIVE);
+#define Nuitka_LongSetSign(value, positive)                                                                            \
+    if (positive) {                                                                                                    \
+        Nuitka_LongSetSignPositive(value);                                                                             \
+    } else {                                                                                                           \
+        Nuitka_LongSetSignNegative(value);                                                                             \
+    }
+#define Nuitka_LongSetDigitSizeAndNegative(value, count, negative)                                                     \
+    _PyLong_SetSignAndDigitCount(value, negative ? -1 : 1, count)
+#define Nuitka_LongFlipSign(value) _PyLong_FlipSign(value)
+#endif
 
 // Our version of _PyLong_New(size);
 static PyLongObject *Nuitka_LongNew(Py_ssize_t size) {
+    // TODO: The assertion may be a bit to strong, could be <= for at least < 3.12
     assert(size < (Py_ssize_t)MAX_LONG_DIGITS);
+    assert(size >= 0);
 
-#if PYTHON_VERSION >= 0x300
-    PyLongObject *result;
+#if PYTHON_VERSION >= 0x3c0
+    // The zero now is a single digit number.
+    Py_ssize_t ndigits = size ? size : 1;
 
-    result = (PyLongObject *)PyObject_MALLOC(offsetof(PyLongObject, ob_digit) + size * sizeof(digit));
+    PyLongObject *result =
+        (PyLongObject *)PyObject_MALLOC(offsetof(PyLongObject, long_value.ob_digit) + ndigits * sizeof(digit));
+    _PyLong_SetSignAndDigitCount(result, size != 0, size);
+    PyObject_INIT(result, &PyLong_Type);
+    result->long_value.ob_digit[0] = 0;
+    return result;
+#elif PYTHON_VERSION >= 0x300
+    PyLongObject *result = (PyLongObject *)PyObject_MALLOC(offsetof(PyLongObject, ob_digit) + size * sizeof(digit));
     return (PyLongObject *)PyObject_INIT_VAR(result, &PyLong_Type, size);
 #else
     return (PyLongObject *)PyObject_NEW_VAR(PyLongObject, &PyLong_Type, size);
@@ -70,8 +103,10 @@ static PyLongObject *Nuitka_LongNew(Py_ssize_t size) {
 }
 
 static PyObject *Nuitka_LongRealloc(PyObject *value, Py_ssize_t size) {
+    assert(size >= 0);
+
     PyLongObject *result = Nuitka_LongNew(size);
-    Py_SET_SIZE(result, size);
+    Nuitka_LongSetDigitSizeAndNegative(result, size, false);
     Py_DECREF(value);
 
     return (PyObject *)result;
@@ -111,10 +146,11 @@ static PyObject *Nuitka_LongFromCLong(long ival) {
         PyLongObject *result = Nuitka_LongNew(1);
         assert(result != NULL);
         if (negative) {
-            Py_SET_SIZE(result, -1);
+            Nuitka_LongSetSignNegative(result);
         }
 
-        result->ob_digit[0] = (digit)abs_ival;
+        digit *digits = Nuitka_LongGetDigitPointer(result);
+        digits[0] = (digit)abs_ival;
 
         return (PyObject *)result;
     }
@@ -125,11 +161,13 @@ static PyObject *Nuitka_LongFromCLong(long ival) {
         PyLongObject *result = Nuitka_LongNew(2);
         assert(result != NULL);
         if (negative) {
-            Py_SIZE(result) = -2;
+            Nuitka_LongSetSignNegative(result);
         }
 
-        result->ob_digit[0] = (digit)(abs_ival & PyLong_MASK);
-        result->ob_digit[1] = (digit)(abs_ival >> PyLong_SHIFT);
+        digit *digits = Nuitka_LongGetDigitPointer(result);
+
+        digits[0] = (digit)(abs_ival & PyLong_MASK);
+        digits[1] = (digit)(abs_ival >> PyLong_SHIFT);
 
         return (PyObject *)result;
     }
@@ -148,9 +186,9 @@ static PyObject *Nuitka_LongFromCLong(long ival) {
     PyLongObject *result = _PyLong_New(ndigits);
     assert(result != NULL);
 
-    Py_SET_SIZE(result, negative ? -ndigits : ndigits);
+    Nuitka_LongSetDigitSizeAndNegative(result, ndigits, negative);
 
-    digit *d = result->ob_digit;
+    digit *d = Nuitka_LongGetDigitPointer(result);
 
     // Now copy the digits
     t = abs_ival;
@@ -204,18 +242,22 @@ static void Nuitka_LongUpdateFromCLong(PyObject **value, long ival) {
     if (!(abs_ival >> PyLong_SHIFT)) {
         PyLongObject *result;
 
+#if PYTHON_VERSION < 0x3c0
         if (unlikely(Py_SIZE(*value) == 0)) {
             *value = Nuitka_LongRealloc(*value, 1);
             CHECK_OBJECT(*value);
 
             result = (PyLongObject *)*value;
-        } else {
+        } else
+#endif
+        {
             result = (PyLongObject *)(*value);
         }
 
-        Py_SET_SIZE(result, negative ? -1 : 1);
+        Nuitka_LongSetSign(result, !negative);
 
-        result->ob_digit[0] = (digit)abs_ival;
+        digit *digits = Nuitka_LongGetDigitPointer(result);
+        digits[0] = (digit)abs_ival;
 
         return;
     }
@@ -233,10 +275,14 @@ static void Nuitka_LongUpdateFromCLong(PyObject **value, long ival) {
             result = (PyLongObject *)(*value);
         }
 
-        Py_SIZE(result) = negative ? -2 : 2;
+        if (negative) {
+            Nuitka_LongSetSignNegative(result);
+        }
+
+        digit *digits = Nuitka_LongGetDigitPointer(result);
 
-        result->ob_digit[0] = (digit)(abs_ival & PyLong_MASK);
-        result->ob_digit[1] = (digit)(abs_ival >> PyLong_SHIFT);
+        digits[0] = (digit)(abs_ival & PyLong_MASK);
+        digits[1] = (digit)(abs_ival >> PyLong_SHIFT);
 
         return;
     }
@@ -258,9 +304,9 @@ static void Nuitka_LongUpdateFromCLong(PyObject **value, long ival) {
 
     CHECK_OBJECT(*value);
 
-    Py_SET_SIZE(*value, negative ? -ndigits : ndigits);
+    Nuitka_LongSetDigitSizeAndNegative((PyLongObject *)*value, ndigits, negative);
 
-    digit *d = ((PyLongObject *)(*value))->ob_digit;
+    digit *d = Nuitka_LongGetDigitPointer(*value);
 
     // Now copy the digits
     t = abs_ival;
@@ -310,7 +356,7 @@ static PyLongObject *_Nuitka_LongAddDigits(digit const *a, Py_ssize_t size_a, di
     PyLongObject *result = Nuitka_LongNew(size_a + 1);
     CHECK_OBJECT(result);
 
-    digit *r = &result->ob_digit[0];
+    digit *r = Nuitka_LongGetDigitPointer(result);
 
     digit carry = 0;
 
@@ -332,7 +378,8 @@ static PyLongObject *_Nuitka_LongAddDigits(digit const *a, Py_ssize_t size_a, di
     if (carry) {
         r[i] = carry;
     } else {
-        Py_SET_SIZE(result, Py_SIZE(result) - 1);
+        // Note: Beware, this looses the sign value.
+        Nuitka_LongSetDigitSizeAndNegative(result, Nuitka_LongGetDigitSize(result) - 1, false);
     }
 
     return result;
@@ -417,9 +464,9 @@ static PyObject *_Nuitka_LongAddInplaceDigits(PyObject *left, digit const *b, Py
     if (carry != 0) {
         r[i] = carry;
 
-        Py_SET_SIZE(left, i + 1);
+        Nuitka_LongSetDigitSizeAndNegative((PyLongObject *)left, i + 1, false);
     } else {
-        Py_SET_SIZE(left, i);
+        Nuitka_LongSetDigitSizeAndNegative((PyLongObject *)left, i, false);
     }
 
     // Release reference to old value
@@ -480,7 +527,7 @@ static PyLongObject *_Nuitka_LongSubDigits(digit const *a, Py_ssize_t size_a, di
     PyLongObject *result = Nuitka_LongNew(size_a);
     CHECK_OBJECT(result);
 
-    digit *r = &result->ob_digit[0];
+    digit *r = Nuitka_LongGetDigitPointer(result);
 
     digit borrow = 0;
 
@@ -506,12 +553,12 @@ static PyLongObject *_Nuitka_LongSubDigits(digit const *a, Py_ssize_t size_a, di
         i -= 1;
     }
 
-    Py_SET_SIZE(result, (sign < 0) ? -i : i);
+    Nuitka_LongSetDigitSizeAndNegative(result, i, sign < 0);
 
 #if PYTHON_VERSION >= 0x300
     // Normalize small integers.
     if (i <= 1) {
-        long ival = MEDIUM_VALUE(result);
+        medium_result_value_t ival = MEDIUM_VALUE(result);
 
         if (ival >= NUITKA_STATIC_SMALLINT_VALUE_MIN && ival < NUITKA_STATIC_SMALLINT_VALUE_MAX) {
             Py_DECREF(result);
@@ -615,7 +662,7 @@ static PyObject *_Nuitka_LongSubInplaceDigits(PyObject *left, digit const *b, Py
         i -= 1;
     }
 
-    Py_SET_SIZE(left, (sign < 0) ? -i : i);
+    Nuitka_LongSetDigitSizeAndNegative((PyLongObject *)left, i, (sign < 0));
 
     // Release reference to old value
     Py_DECREF(old);
@@ -623,7 +670,7 @@ static PyObject *_Nuitka_LongSubInplaceDigits(PyObject *left, digit const *b, Py
 #if PYTHON_VERSION >= 0x300
     // Normalize small integers.
     if (i <= 1) {
-        long ival = MEDIUM_VALUE(left);
+        medium_result_value_t ival = MEDIUM_VALUE(left);
 
         if (ival >= NUITKA_STATIC_SMALLINT_VALUE_MIN && ival < NUITKA_STATIC_SMALLINT_VALUE_MAX) {
             Py_DECREF(left);

nuitka/build/static_src/HelpersOperationBinaryMultUtils.c

@@ -14,28 +14,31 @@
 
 static Py_ssize_t CONVERT_LONG_TO_REPEAT_FACTOR(PyObject *value) {
     /* Inline PyLong_AsSsize_t here for our special purpose. */
-    Py_ssize_t i = Py_SIZE(value);
+    assert(PyLong_Check(value));
+
+    Py_ssize_t digits_count = Nuitka_LongGetDigitSize(value);
 
-    if (i == 0) {
+    if (digits_count == 0) {
         return 0;
     }
 
+    bool is_negative = Nuitka_LongIsNegative(value);
+
     PyLongObject *long_value = (PyLongObject *)value;
 
-    if (i == 1) {
-        return long_value->ob_digit[0];
+    digit *digits = Nuitka_LongGetDigitPointer(long_value);
+
+    if ((digits_count == 1) && (is_negative == false)) {
+        return digits[0];
     }
 
     Py_ssize_t result = 0;
 
-    bool is_negative = i < 0;
-    if (is_negative) {
-        i = -i;
-    }
-
-    while (--i >= 0) {
+    while (--digits_count >= 0) {
         Py_ssize_t prev = result;
-        result = (result << PyLong_SHIFT) | long_value->ob_digit[i];
+        result = (result << PyLong_SHIFT) | digits[digits_count];
+
+        // Overflow detection.
         if ((result >> PyLong_SHIFT) != prev) {
             return (Py_ssize_t)-1;
         }
@@ -43,9 +46,9 @@ static Py_ssize_t CONVERT_LONG_TO_REPEAT_FACTOR(PyObject *value) {
 
     if (is_negative) {
         return 0;
-    } else {
-        return result;
     }
+
+    return result;
 }
 
 static Py_ssize_t CONVERT_TO_REPEAT_FACTOR(PyObject *value) {