Nuitka-winsvc 2.4.11__cp311-cp311-win_amd64.whl → 2.5.6__cp311-cp311-win_amd64.whl

nuitka/build/include/nuitka/helper/ints.h

@@ -3,63 +3,112 @@
 #ifndef __NUITKA_HELPER_INTS_H__
 #define __NUITKA_HELPER_INTS_H__
 
-typedef enum {
-    NUITKA_INT_UNASSIGNED = 0,
-    NUITKA_INT_OBJECT_VALID = 1,
-    NUITKA_INT_VALUE_VALID = 2,
-    NUITKA_INT_BOTH_VALID = 3
-} nuitka_int_validity;
-
-typedef struct {
-    nuitka_int_validity validity;
+// Our "PyLong_FromLong" replacement.
+extern PyObject *Nuitka_PyLong_FromLong(long ival);
 
-    PyObject *int_object;
-    long int_value;
-} nuitka_int;
-
-typedef enum {
-    NUITKA_LONG_UNASSIGNED = 0,
-    NUITKA_LONG_OBJECT_VALID = 1,
-    NUITKA_LONG_VALUE_VALID = 2,
-    NUITKA_LONG_BOTH_VALID = 3 // NUITKA_LONG_VALUE_VALID | NUITKA_LONG_OBJECT_VALID
-} nuitka_long_validity;
-
-typedef struct {
-    nuitka_long_validity validity;
+// Our "PyInt_FromLong" replacement, not done (yet?).
+#if PYTHON_VERSION >= 0x300
+#define Nuitka_PyInt_FromLong(ival) Nuitka_PyLong_FromLong(ival)
+#else
+#define Nuitka_PyInt_FromLong(ival) PyInt_FromLong(ival)
+#endif
 
-    PyObject *long_object;
-    long long_value;
-} nuitka_long;
+// We are using this mixed type for both Python2 and Python3, since then we
+// avoid the complexity of overflowed integers for Python2 to switch over.
 
-#if PYTHON_VERSION < 0x300
 typedef enum {
     NUITKA_ILONG_UNASSIGNED = 0,
     NUITKA_ILONG_OBJECT_VALID = 1,
-    NUITKA_ILONG_VALUE_VALID = 2,
-    NUITKA_ILONG_BOTH_VALID = 3
+    NUITKA_ILONG_CLONG_VALID = 2,
+    NUITKA_ILONG_BOTH_VALID = 3,
+    NUITKA_ILONG_EXCEPTION = 4
 } nuitka_ilong_validity;
 
 typedef struct {
     nuitka_ilong_validity validity;
 
-    PyObject *ilong_object;
-    long ilong_value;
+    PyObject *python_value;
+    long c_value;
 } nuitka_ilong;
 
-NUITKA_MAY_BE_UNUSED static void ENFORCE_ILONG_OBJECT_VALUE(nuitka_ilong *value) {
-    assert(value->validity != NUITKA_ILONG_UNASSIGNED);
+#define IS_NILONG_OBJECT_VALUE_VALID(value) (((value)->validity & NUITKA_ILONG_OBJECT_VALID) != 0)
+#define IS_NILONG_C_VALUE_VALID(value) (((value)->validity & NUITKA_ILONG_CLONG_VALID) != 0)
 
-    if ((value->validity & NUITKA_ILONG_OBJECT_VALID) == 0) {
-        value->ilong_object = PyLong_FromLong(value->ilong_value);
+NUITKA_MAY_BE_UNUSED static void SET_NILONG_OBJECT_VALUE(nuitka_ilong *dual_value, PyObject *python_value) {
+    dual_value->validity = NUITKA_ILONG_OBJECT_VALID;
+    dual_value->python_value = python_value;
+}
 
-        value->validity = NUITKA_ILONG_BOTH_VALID;
+NUITKA_MAY_BE_UNUSED static void SET_NILONG_C_VALUE(nuitka_ilong *dual_value, long c_value) {
+    dual_value->validity = NUITKA_ILONG_CLONG_VALID;
+    dual_value->c_value = c_value;
+}
+
+NUITKA_MAY_BE_UNUSED static void SET_NILONG_OBJECT_AND_C_VALUE(nuitka_ilong *dual_value, PyObject *python_value,
+                                                               long c_value) {
+    dual_value->validity = NUITKA_ILONG_BOTH_VALID;
+    dual_value->python_value = python_value;
+    dual_value->c_value = c_value;
+}
+
+NUITKA_MAY_BE_UNUSED static void RELEASE_NILONG_VALUE(nuitka_ilong *dual_value) {
+    if (IS_NILONG_OBJECT_VALUE_VALID(dual_value)) {
+        CHECK_OBJECT(dual_value);
+        Py_DECREF(dual_value->python_value);
     }
+
+    dual_value->validity = NUITKA_ILONG_UNASSIGNED;
 }
 
-#endif
+NUITKA_MAY_BE_UNUSED static void INCREF_NILONG_VALUE(nuitka_ilong *dual_value) {
+    if (IS_NILONG_OBJECT_VALUE_VALID(dual_value)) {
+        CHECK_OBJECT(dual_value);
+        Py_INCREF(dual_value->python_value);
+    }
+}
+
+NUITKA_MAY_BE_UNUSED static long GET_NILONG_C_VALUE(nuitka_ilong const *dual_value) {
+    assert(IS_NILONG_C_VALUE_VALID(dual_value));
+    return dual_value->c_value;
+}
+
+NUITKA_MAY_BE_UNUSED static PyObject *GET_NILONG_OBJECT_VALUE(nuitka_ilong const *dual_value) {
+    assert(IS_NILONG_OBJECT_VALUE_VALID(dual_value));
+    return dual_value->python_value;
+}
+
+NUITKA_MAY_BE_UNUSED static void ENFORCE_NILONG_OBJECT_VALUE(nuitka_ilong *dual_value) {
+    assert(dual_value->validity != NUITKA_ILONG_UNASSIGNED);
+
+    if (!IS_NILONG_OBJECT_VALUE_VALID(dual_value)) {
+        dual_value->python_value = Nuitka_PyLong_FromLong(dual_value->c_value);
+
+        dual_value->validity = NUITKA_ILONG_BOTH_VALID;
+    }
+}
+
+NUITKA_MAY_BE_UNUSED static void CHECK_NILONG_OBJECT(nuitka_ilong const *dual_value) {
+    assert(dual_value->validity != NUITKA_ILONG_UNASSIGNED);
+
+    if (IS_NILONG_OBJECT_VALUE_VALID(dual_value)) {
+        CHECK_OBJECT(dual_value);
+    }
+}
+
+NUITKA_MAY_BE_UNUSED static void PRINT_NILONG(nuitka_ilong const *dual_value) {
+    PRINT_FORMAT("NILONG: %d", dual_value->validity);
+    if (IS_NILONG_C_VALUE_VALID(dual_value)) {
+        PRINT_FORMAT("C=%d", dual_value->c_value);
+    }
+    if (IS_NILONG_OBJECT_VALUE_VALID(dual_value)) {
+        PRINT_STRING("Python=");
+        PRINT_ITEM(dual_value->python_value);
+    }
+}
 
 #if PYTHON_VERSION < 0x3c0
-// Convert single digit to sdigit (int32_t)
+// Convert single digit to sdigit (int32_t),
+// spell-checker: ignore sdigit,stwodigits
 typedef long medium_result_value_t;
 #define MEDIUM_VALUE(x)                                                                                                \
     (Py_SIZE(x) < 0 ? -(sdigit)((PyLongObject *)(x))->ob_digit[0]                                                      \

nuitka/build/include/nuitka/helper/iterators.h

@@ -32,10 +32,10 @@ NUITKA_MAY_BE_UNUSED static inline bool HAS_ITERNEXT(PyObject *value) {
 }
 
 // Taken from CPython implementation, so we can access and create it, needs to match
-// their definition exactly.
+// their definition exactly. spell-checker: ignore seqiterobject
 typedef struct {
     PyObject_HEAD
-#if PYTHON_VERSION < 0x340
+#if PYTHON_VERSION < 0x300
         long it_index;
 #else
         Py_ssize_t it_index;
@@ -166,6 +166,20 @@ NUITKA_MAY_BE_UNUSED static PyObject *MAKE_UNPACK_ITERATOR(PyObject *iterated) {
 
 #endif
 
+NUITKA_MAY_BE_UNUSED static PyObject *ITERATOR_NEXT_ITERATOR(PyObject *iterator) {
+    CHECK_OBJECT(iterator);
+    iternextfunc iternext = Py_TYPE(iterator)->tp_iternext;
+    assert(iternext != NULL);
+
+#if _NUITKA_EXPERIMENTAL_DISABLE_ITERATOR_OPT
+    return PyIter_Next(iterator);
+#else
+    PyObject *result = (*iternext)(iterator);
+    CHECK_OBJECT_X(result);
+    return result;
+#endif
+}
+
 NUITKA_MAY_BE_UNUSED static PyObject *ITERATOR_NEXT(PyObject *iterator) {
     CHECK_OBJECT(iterator);
 
@@ -175,13 +189,13 @@ NUITKA_MAY_BE_UNUSED static PyObject *ITERATOR_NEXT(PyObject *iterator) {
     iternextfunc iternext = Py_TYPE(iterator)->tp_iternext;
 
     if (unlikely(iternext == NULL)) {
-        PyErr_Format(PyExc_TypeError,
+        SET_CURRENT_EXCEPTION_TYPE_COMPLAINT(
 #if PYTHON_VERSION < 0x300 && defined(_NUITKA_FULL_COMPAT)
-                     "%s object is not an iterator",
+            "%s object is not an iterator",
 #else
-                     "'%s' object is not an iterator",
+            "'%s' object is not an iterator",
 #endif
-                     Py_TYPE(iterator)->tp_name);
+            iterator);
 
         return NULL;
     }
@@ -227,10 +241,13 @@ NUITKA_MAY_BE_UNUSED static PyObject *UNPACK_NEXT_INFALLIBLE(PyObject *iterator)
 }
 
 #if PYTHON_VERSION < 0x350
-NUITKA_MAY_BE_UNUSED static PyObject *UNPACK_NEXT(PyThreadState *tstate, PyObject *iterator, int seq_size_so_far)
+NUITKA_MAY_BE_UNUSED static PyObject *UNPACK_NEXT(PyThreadState *tstate,
+                                                  struct Nuitka_ExceptionPreservationItem *exception_state,
+                                                  PyObject *iterator, int seq_size_so_far)
 #else
-NUITKA_MAY_BE_UNUSED static PyObject *UNPACK_NEXT(PyThreadState *tstate, PyObject *iterator, int seq_size_so_far,
-                                                  int expected)
+NUITKA_MAY_BE_UNUSED static PyObject *UNPACK_NEXT(PyThreadState *tstate,
+                                                  struct Nuitka_ExceptionPreservationItem *exception_state,
+                                                  PyObject *iterator, int seq_size_so_far, int expected)
 #endif
 {
     CHECK_OBJECT(iterator);
@@ -239,24 +256,35 @@ NUITKA_MAY_BE_UNUSED static PyObject *UNPACK_NEXT(PyThreadState *tstate, PyObjec
     PyObject *result = (*Py_TYPE(iterator)->tp_iternext)(iterator);
 
     if (unlikely(result == NULL)) {
+        bool had_stop_iteration = true;
+
         PyObject *error = GET_ERROR_OCCURRED(tstate);
 
-#if PYTHON_VERSION < 0x300
-        if (unlikely(error == NULL))
-#else
-        if (unlikely((error == NULL) || EXCEPTION_MATCH_BOOL_SINGLE(tstate, error, PyExc_StopIteration)))
-#endif
-        {
+        if (error != NULL) {
+            if (EXCEPTION_MATCH_BOOL_SINGLE(tstate, error, PyExc_StopIteration)) {
+                CLEAR_ERROR_OCCURRED(tstate);
+            } else {
+                had_stop_iteration = false;
+            }
+        }
+
+        if (had_stop_iteration) {
 #if PYTHON_VERSION < 0x350
             if (seq_size_so_far == 1) {
-                SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_ValueError, "need more than 1 value to unpack");
+                SET_EXCEPTION_PRESERVATION_STATE_FROM_TYPE0_STR(tstate, exception_state, PyExc_ValueError,
+                                                                "need more than 1 value to unpack");
             } else {
-                PyErr_Format(PyExc_ValueError, "need more than %d values to unpack", seq_size_so_far);
+                SET_EXCEPTION_PRESERVATION_STATE_FROM_TYPE0_FORMAT1(
+                    tstate, exception_state, PyExc_ValueError, "need more than %d values to unpack", seq_size_so_far);
             }
 #else
-            PyErr_Format(PyExc_ValueError, "not enough values to unpack (expected %d, got %d)", expected,
-                         seq_size_so_far);
+            SET_EXCEPTION_PRESERVATION_STATE_FROM_TYPE0_FORMAT2(tstate, exception_state, PyExc_ValueError,
+                                                                "not enough values to unpack (expected %d, got %d)",
+                                                                expected, seq_size_so_far);
 #endif
+        } else {
+            assert(HAS_ERROR_OCCURRED(tstate));
+            FETCH_ERROR_OCCURRED_STATE(tstate, exception_state);
         }
 
         return NULL;
@@ -269,19 +297,24 @@ NUITKA_MAY_BE_UNUSED static PyObject *UNPACK_NEXT(PyThreadState *tstate, PyObjec
 
 #if PYTHON_VERSION >= 0x350
 // Different error message for starred unpacks
-NUITKA_MAY_BE_UNUSED static PyObject *UNPACK_NEXT_STARRED(PyThreadState *tstate, PyObject *iterator,
-                                                          int seq_size_so_far, int expected) {
+NUITKA_MAY_BE_UNUSED static PyObject *UNPACK_NEXT_STARRED(PyThreadState *tstate,
+                                                          struct Nuitka_ExceptionPreservationItem *exception_state,
+                                                          PyObject *iterator, int seq_size_so_far, int expected) {
     CHECK_OBJECT(iterator);
     assert(HAS_ITERNEXT(iterator));
 
     PyObject *result = (*Py_TYPE(iterator)->tp_iternext)(iterator);
 
     if (unlikely(result == NULL)) {
-        PyObject *error = GET_ERROR_OCCURRED(tstate);
-
-        if (unlikely((error == NULL) || EXCEPTION_MATCH_BOOL_SINGLE(tstate, error, PyExc_StopIteration))) {
-            PyErr_Format(PyExc_ValueError, "not enough values to unpack (expected at least %d, got %d)", expected,
-                         seq_size_so_far);
+        FETCH_ERROR_OCCURRED_STATE(tstate, exception_state);
+
+        // TODO: Specialize more for StopIteration and maybe derived ones do not
+        // count or do they?
+        if (!HAS_EXCEPTION_STATE(exception_state) ||
+            EXCEPTION_STATE_MATCH_BOOL_SINGLE(tstate, exception_state, PyExc_StopIteration)) {
+            SET_EXCEPTION_PRESERVATION_STATE_FROM_TYPE0_FORMAT2(
+                tstate, exception_state, PyExc_ValueError, "not enough values to unpack (expected at least %d, got %d)",
+                expected, seq_size_so_far);
         }
 
         return NULL;
@@ -293,19 +326,34 @@ NUITKA_MAY_BE_UNUSED static PyObject *UNPACK_NEXT_STARRED(PyThreadState *tstate,
 }
 #endif
 
-// TODO: How come this is unused code.
-NUITKA_MAY_BE_UNUSED static bool UNPACK_ITERATOR_CHECK(PyThreadState *tstate, PyObject *iterator) {
-    CHECK_OBJECT(iterator);
-    assert(HAS_ITERNEXT(iterator));
-
-    PyObject *attempt = (*Py_TYPE(iterator)->tp_iternext)(iterator);
+NUITKA_MAY_BE_UNUSED static bool UNPACK_ITERATOR_CHECK(PyThreadState *tstate,
+                                                       struct Nuitka_ExceptionPreservationItem *exception_state,
+                                                       PyObject *iterator, int expected) {
+    PyObject *attempt = (*(Py_TYPE(iterator)->tp_iternext))(iterator);
 
     if (likely(attempt == NULL)) {
-        return CHECK_AND_CLEAR_STOP_ITERATION_OCCURRED(tstate);
+        PyObject *error = GET_ERROR_OCCURRED(tstate);
+
+        if (error != NULL) {
+            if (EXCEPTION_MATCH_BOOL_SINGLE(tstate, error, PyExc_StopIteration)) {
+                CLEAR_ERROR_OCCURRED(tstate);
+            } else {
+                FETCH_ERROR_OCCURRED_STATE(tstate, exception_state);
+                return false;
+            }
+        }
+
+        return true;
     } else {
         Py_DECREF(attempt);
 
-        SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_ValueError, "too many values to unpack");
+#if PYTHON_VERSION < 0x300
+        SET_EXCEPTION_PRESERVATION_STATE_FROM_TYPE0_STR(tstate, exception_state, PyExc_ValueError,
+                                                        "too many values to unpack");
+#else
+        SET_EXCEPTION_PRESERVATION_STATE_FROM_TYPE0_FORMAT1(tstate, exception_state, PyExc_ValueError,
+                                                            "too many values to unpack (expected %d)", expected);
+#endif
         return false;
     }
 }

nuitka/build/include/nuitka/helper/operations.h

@@ -56,6 +56,9 @@ NUITKA_MAY_BE_UNUSED static PyObject *UNARY_OPERATION(unary_api api, PyObject *o
 #include "nuitka/helper/operations_binary_sub.h"
 #include "nuitka/helper/operations_binary_truediv.h"
 
+// Generated helpers to execute operations on dual types.
+#include "nuitka/helper/operations_binary_dual_add.h"
+
 #include "nuitka/helper/operations_inplace_add.h"
 #include "nuitka/helper/operations_inplace_bitand.h"
 #include "nuitka/helper/operations_inplace_bitor.h"

nuitka/build/include/nuitka/helper/operations_binary_add.h

@@ -119,6 +119,12 @@ extern PyObject *BINARY_OPERATION_ADD_OBJECT_LONG_DIGIT(PyObject *operand1, long
  * Python objects. */
 extern nuitka_bool BINARY_OPERATION_ADD_NBOOL_LONG_DIGIT(PyObject *operand1, long operand2);
 
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "CLONG" to C platform long value. */
+extern PyObject *BINARY_OPERATION_ADD_OBJECT_LONG_CLONG(PyObject *operand1, long operand2);
+
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "CLONG" to C platform long value. */
+extern nuitka_bool BINARY_OPERATION_ADD_NBOOL_LONG_CLONG(PyObject *operand1, long operand2);
+
 /* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
 extern PyObject *BINARY_OPERATION_ADD_OBJECT_FLOAT_CFLOAT(PyObject *operand1, double operand2);
 

nuitka/build/include/nuitka/helper/operations_binary_dual_add.h

@@ -0,0 +1,34 @@
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+/* WARNING, this code is GENERATED. Modify the template HelperOperationBinaryDual.c.j2 instead! */
+
+/* This file is included from another C file, help IDEs to still parse it on its own. */
+#ifdef __IDE_ONLY__
+#include "nuitka/prelude.h"
+#endif
+
+/* C helpers for type specialized "+" (ADD) operations */
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "NILONG" to Nuitka int/long/C long value.
+ */
+extern bool BINARY_OPERATION_ADD_NILONG_NILONG_NILONG(nuitka_ilong *result, nuitka_ilong *operand1,
+                                                      nuitka_ilong *operand2);
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern bool BINARY_OPERATION_ADD_NILONG_NILONG_DIGIT(nuitka_ilong *result, nuitka_ilong *operand1, long operand2);
+
+//     Part of "Nuitka", an optimizing Python compiler that is compatible and
+//     integrates with CPython, but also works on its own.
+//
+//     Licensed under the Apache License, Version 2.0 (the "License");
+//     you may not use this file except in compliance with the License.
+//     You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//     Unless required by applicable law or agreed to in writing, software
+//     distributed under the License is distributed on an "AS IS" BASIS,
+//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//     See the License for the specific language governing permissions and
+//     limitations under the License.

nuitka/build/include/nuitka/helper/operations_binary_sub.h

@@ -86,6 +86,12 @@ extern PyObject *BINARY_OPERATION_SUB_OBJECT_LONG_DIGIT(PyObject *operand1, long
  * Python3 'int'. */
 extern PyObject *BINARY_OPERATION_SUB_OBJECT_DIGIT_LONG(long operand1, PyObject *operand2);
 
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "CLONG" to C platform long value. */
+extern PyObject *BINARY_OPERATION_SUB_OBJECT_LONG_CLONG(PyObject *operand1, long operand2);
+
+/* Code referring to "CLONG" corresponds to C platform long value and "LONG" to Python2 'long', Python3 'int'. */
+extern PyObject *BINARY_OPERATION_SUB_OBJECT_CLONG_LONG(long operand1, PyObject *operand2);
+
 /* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
 extern PyObject *BINARY_OPERATION_SUB_OBJECT_FLOAT_CFLOAT(PyObject *operand1, double operand2);
 

nuitka/build/include/nuitka/helper/operations_inplace_add.h

@@ -77,6 +77,9 @@ extern bool INPLACE_OPERATION_ADD_INT_CLONG(PyObject **operand1, long operand2);
  * Python objects. */
 extern bool INPLACE_OPERATION_ADD_LONG_DIGIT(PyObject **operand1, long operand2);
 
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "CLONG" to C platform long value. */
+extern bool INPLACE_OPERATION_ADD_LONG_CLONG(PyObject **operand1, long operand2);
+
 /* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
 extern bool INPLACE_OPERATION_ADD_FLOAT_CFLOAT(PyObject **operand1, double operand2);
 

nuitka/build/include/nuitka/helper/operations_inplace_sub.h

@@ -77,6 +77,9 @@ extern bool INPLACE_OPERATION_SUB_INT_CLONG(PyObject **operand1, long operand2);
  * Python objects. */
 extern bool INPLACE_OPERATION_SUB_LONG_DIGIT(PyObject **operand1, long operand2);
 
+/* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "CLONG" to C platform long value. */
+extern bool INPLACE_OPERATION_SUB_LONG_CLONG(PyObject **operand1, long operand2);
+
 /* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */
 extern bool INPLACE_OPERATION_SUB_FLOAT_CFLOAT(PyObject **operand1, double operand2);
 

nuitka/build/include/nuitka/helper/raising.h

@@ -7,9 +7,14 @@
 NUITKA_MAY_BE_UNUSED static void CHAIN_EXCEPTION(PyThreadState *tstate, PyObject *exception_value) {
     // Implicit chain of exception already existing.
 
-    // Normalize existing exception first.
+    // Normalize existing published exception first.
 #if PYTHON_VERSION < 0x3b0
-    NORMALIZE_EXCEPTION(tstate, &EXC_TYPE(tstate), &EXC_VALUE(tstate), EXC_TRACEBACK_PTR(tstate));
+    {
+        // TODO: Revert to using NORMALIZE_EXCEPTION
+        struct Nuitka_ExceptionPreservationItem *exception_state =
+            (struct Nuitka_ExceptionPreservationItem *)&EXC_TYPE(tstate);
+        NORMALIZE_EXCEPTION_STATE(tstate, exception_state);
+    }
 #endif
 
     PyObject *old_exc_value = EXC_VALUE(tstate);
@@ -17,17 +22,15 @@ NUITKA_MAY_BE_UNUSED static void CHAIN_EXCEPTION(PyThreadState *tstate, PyObject
     if (old_exc_value != NULL && old_exc_value != Py_None && old_exc_value != exception_value) {
         PyObject *current = old_exc_value;
         while (true) {
-            PyObject *context = PyException_GetContext(current);
+            PyObject *context = Nuitka_Exception_GetContext(current);
             if (context == NULL) {
                 break;
             }
 
-            CHECK_OBJECT(context);
-            Py_DECREF(context);
             CHECK_OBJECT(context);
 
             if (context == exception_value) {
-                PyException_SetContext(current, NULL);
+                Nuitka_Exception_DeleteContext(current);
                 break;
             }
 
@@ -35,8 +38,7 @@ NUITKA_MAY_BE_UNUSED static void CHAIN_EXCEPTION(PyThreadState *tstate, PyObject
         }
 
         CHECK_OBJECT(old_exc_value);
-        Py_INCREF(old_exc_value);
-        PyException_SetContext(exception_value, old_exc_value);
+        Nuitka_Exception_SetContext(exception_value, old_exc_value);
 
 #if PYTHON_VERSION < 0x3b0
         CHECK_OBJECT(EXC_TRACEBACK(tstate));
@@ -46,36 +48,53 @@ NUITKA_MAY_BE_UNUSED static void CHAIN_EXCEPTION(PyThreadState *tstate, PyObject
 }
 #endif
 
-extern void RAISE_EXCEPTION_WITH_TYPE(PyThreadState *tstate, PyObject **exception_type, PyObject **exception_value,
-                                      PyTracebackObject **exception_tb);
+#if PYTHON_VERSION < 0x3c0
+extern void RAISE_EXCEPTION_WITH_TYPE(PyThreadState *tstate, struct Nuitka_ExceptionPreservationItem *exception_state);
+extern void RAISE_EXCEPTION_WITH_TYPE_AND_VALUE(PyThreadState *tstate,
+                                                struct Nuitka_ExceptionPreservationItem *exception_state);
+#else
+extern void RAISE_EXCEPTION_WITH_VALUE(PyThreadState *tstate, struct Nuitka_ExceptionPreservationItem *exception_state);
+#endif
 
-#if PYTHON_VERSION >= 0x300
-extern void RAISE_EXCEPTION_WITH_CAUSE(PyThreadState *tstate, PyObject **exception_type, PyObject **exception_value,
-                                       PyTracebackObject **exception_tb, PyObject *exception_cause);
+#if PYTHON_VERSION < 0x300
+extern void RAISE_EXCEPTION_WITH_TRACEBACK(PyThreadState *tstate,
+                                           struct Nuitka_ExceptionPreservationItem *exception_state);
+#else
+extern void RAISE_EXCEPTION_WITH_CAUSE(PyThreadState *tstate, struct Nuitka_ExceptionPreservationItem *exception_state,
+                                       PyObject *exception_cause);
 #endif
 
-extern void RAISE_EXCEPTION_WITH_VALUE(PyThreadState *tstate, PyObject **exception_type, PyObject **exception_value,
-                                       PyTracebackObject **exception_tb);
+extern bool RERAISE_EXCEPTION(PyThreadState *tstate, struct Nuitka_ExceptionPreservationItem *exception_state);
 
-extern void RAISE_EXCEPTION_IMPLICIT(PyThreadState *tstate, PyObject **exception_type, PyObject **exception_value,
-                                     PyTracebackObject **exception_tb);
+extern void RAISE_CURRENT_EXCEPTION_NAME_ERROR(PyThreadState *tstate,
+                                               struct Nuitka_ExceptionPreservationItem *exception_state,
+                                               PyObject *variable_name);
 
-extern void RAISE_EXCEPTION_WITH_TRACEBACK(PyThreadState *tstate, PyObject **exception_type, PyObject **exception_value,
-                                           PyTracebackObject **exception_tb);
+#if PYTHON_VERSION < 0x300
+extern void RAISE_CURRENT_EXCEPTION_GLOBAL_NAME_ERROR(PyThreadState *tstate,
+                                                      struct Nuitka_ExceptionPreservationItem *exception_state,
+                                                      PyObject *variable_name);
+#endif
 
-extern bool RERAISE_EXCEPTION(PyObject **exception_type, PyObject **exception_value, PyTracebackObject **exception_tb);
+extern PyObject *NORMALIZE_EXCEPTION_VALUE_FOR_RAISE(PyThreadState *tstate, PyObject *exception_type);
 
-extern void RAISE_CURRENT_EXCEPTION_NAME_ERROR(PyThreadState *tstate, PyObject *variable_name,
-                                               PyObject **exception_type, PyObject **exception_value);
+#if PYTHON_VERSION >= 0x300
+extern PyObject *MAKE_STOP_ITERATION_EMPTY(void);
+extern PyObject *MAKE_BASE_EXCEPTION_DERIVED_EMPTY(PyObject *exception_type);
+#endif
 
-#if PYTHON_VERSION < 0x340
-extern void RAISE_CURRENT_EXCEPTION_GLOBAL_NAME_ERROR(PyThreadState *tstate, PyObject *variable_name,
-                                                      PyObject **exception_type, PyObject **exception_value);
+NUITKA_MAY_BE_UNUSED static inline void
+SET_EXCEPTION_PRESERVATION_STATE_STOP_ITERATION_EMPTY(PyThreadState *tstate,
+                                                      struct Nuitka_ExceptionPreservationItem *exception_state) {
+#if PYTHON_VERSION < 0x3c0
+    SET_EXCEPTION_PRESERVATION_STATE_FROM_TYPE0(tstate, exception_state, PyExc_StopIteration);
+#else
+    exception_state->exception_value = MAKE_STOP_ITERATION_EMPTY();
 #endif
+}
 
-extern void RAISE_EXCEPTION_WITH_CAUSE_STATE(PyThreadState *tstate,
-                                             struct Nuitka_ExceptionPreservationItem *exception_state,
-                                             PyObject *exception_cause);
+// Create an exception value object from type and value input.
+extern PyObject *MAKE_EXCEPTION_WITH_VALUE(PyThreadState *tstate, PyObject *exception_type, PyObject *value);
 
 #endif
 

nuitka/build/include/nuitka/helper/richcomparisons.h

@@ -10,6 +10,13 @@
 #include "nuitka/helper/comparisons_lt.h"
 #include "nuitka/helper/comparisons_ne.h"
 
+#include "nuitka/helper/comparisons_dual_eq.h"
+#include "nuitka/helper/comparisons_dual_ge.h"
+#include "nuitka/helper/comparisons_dual_gt.h"
+#include "nuitka/helper/comparisons_dual_le.h"
+#include "nuitka/helper/comparisons_dual_lt.h"
+#include "nuitka/helper/comparisons_dual_ne.h"
+
 #endif
 
 //     Part of "Nuitka", an optimizing Python compiler that is compatible and

nuitka/build/include/nuitka/helper/tuples.h

@@ -34,6 +34,7 @@ extern PyObject *MAKE_TUPLE_EMPTY_VAR(PyThreadState *tstate, Py_ssize_t size);
 #endif
 
 NUITKA_MAY_BE_UNUSED static PyObject *MAKE_TUPLE(PyThreadState *tstate, PyObject *const *elements, Py_ssize_t size) {
+    assert(size > 0);
     PyObject *result = MAKE_TUPLE_EMPTY(tstate, size);
 
     for (Py_ssize_t i = 0; i < size; i++) {
@@ -43,6 +44,17 @@ NUITKA_MAY_BE_UNUSED static PyObject *MAKE_TUPLE(PyThreadState *tstate, PyObject
     return result;
 }
 
+NUITKA_MAY_BE_UNUSED static PyObject *MAKE_TUPLE_VAR(PyThreadState *tstate, PyObject *const *elements,
+                                                     Py_ssize_t size) {
+    PyObject *result = MAKE_TUPLE_EMPTY_VAR(tstate, size);
+
+    for (Py_ssize_t i = 0; i < size; i++) {
+        PyTuple_SET_ITEM0(result, i, elements[i]);
+    }
+
+    return result;
+}
+
 NUITKA_MAY_BE_UNUSED static PyObject *MAKE_TUPLE1(PyThreadState *tstate, PyObject *element1) {
     PyObject *result = MAKE_TUPLE_EMPTY(tstate, 1);
 

nuitka/build/include/nuitka/helpers.h

@@ -88,6 +88,7 @@ extern void stopProfiling(void);
 
 #include "nuitka/helper/raising.h"
 
+#include "nuitka/helper/ints.h"
 #include "nuitka/helper/richcomparisons.h"
 #include "nuitka/helper/sequences.h"
 
@@ -101,7 +102,6 @@ static inline PyObject *Nuitka_Generator_GetName(PyObject *object);
 #include "nuitka/helper/bytes.h"
 #include "nuitka/helper/complex.h"
 #include "nuitka/helper/floats.h"
-#include "nuitka/helper/ints.h"
 
 NUITKA_MAY_BE_UNUSED static PyObject *LOOKUP_VARS(PyThreadState *tstate, PyObject *source) {
     CHECK_OBJECT(source);
@@ -172,9 +172,13 @@ extern PyObject *OS_PATH_FILE_EXISTS(PyThreadState *tstate, PyObject *filename);
 extern PyObject *OS_PATH_FILE_ISFILE(PyThreadState *tstate, PyObject *filename);
 extern PyObject *OS_PATH_FILE_ISDIR(PyThreadState *tstate, PyObject *filename);
 
-// Small helper to list a directory.
+// Small helper to list a directory (like "os.listdir")
 extern PyObject *OS_LISTDIR(PyThreadState *tstate, PyObject *path);
 
+// Small helper to get stat structure of a path (like "os.stat" and "os.lstat)
+extern PyObject *OS_STAT(PyThreadState *tstate, PyObject *path, PyObject *dir_fd, PyObject *follow_symlinks);
+extern PyObject *OS_LSTAT(PyThreadState *tstate, PyObject *path, PyObject *dir_fd);
+
 // Platform standard slash for filenames
 #if defined(_WIN32)
 #define const_platform_sep const_str_backslash
@@ -374,6 +378,12 @@ extern char const *getBinaryDirectoryHostEncoded(bool resolve_symlinks);
 // Get the containing directory as an object with symlinks resolved or not.
 extern PyObject *getContainingDirectoryObject(bool resolve_symlinks);
 
+// Get the original argv[0] as recorded by the bootstrap stage. Returns
+// None, if not available, in module mode.
+#if defined(_NUITKA_EXE)
+extern PyObject *getOriginalArgv0Object(void);
+#endif
+
 #ifdef _NUITKA_STANDALONE
 extern void setEarlyFrozenModulesFileAttribute(PyThreadState *tstate);
 #endif