Nuitka-winsvc 1.8__cp311-cp311-win_amd64.whl → 2.5.1__cp311-cp311-win_amd64.whl

nuitka/build/static_src/CompiledCodeHelpers.c

@@ -1,20 +1,5 @@
-//     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-//
-//     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.
-//
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
 /* Implementations of compiled code helpers.
 
  * The definition of a compiled code helper is that it's being used in
@@ -45,7 +30,7 @@ static void _initBuiltinTypeMethods(void) {
     _initListBuiltinMethods();
 }
 
-#if PYTHON_VERSION >= 0x3b0
+#if PYTHON_VERSION >= 0x350
 #include "HelpersAllocator.c"
 #endif
 
@@ -67,6 +52,7 @@ static void _initBuiltinTypeMethods(void) {
 #include "HelpersStrings.c"
 #include "HelpersTuples.c"
 
+#include "HelpersEnvironmentVariables.c"
 #include "HelpersFilesystemPaths.c"
 #include "HelpersSafeStrings.c"
 
@@ -95,12 +81,12 @@ static PyObject *_BUILTIN_RANGE_INT3(long low, long high, long step) {
         size = ESTIMATE_RANGE(high, low, -step);
     }
 
-    PyObject *result = MAKE_LIST_EMPTY(size);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, size);
 
     long current = low;
 
     for (int i = 0; i < size; i++) {
-        PyList_SET_ITEM(result, i, PyInt_FromLong(current));
+        PyList_SET_ITEM(result, i, Nuitka_PyInt_FromLong(current));
         current += step;
     }
 
@@ -110,10 +96,10 @@ static PyObject *_BUILTIN_RANGE_INT3(long low, long high, long step) {
 static PyObject *_BUILTIN_RANGE_INT2(long low, long high) { return _BUILTIN_RANGE_INT3(low, high, 1); }
 
 static PyObject *_BUILTIN_RANGE_INT(long boundary) {
-    PyObject *result = MAKE_LIST_EMPTY(boundary > 0 ? boundary : 0);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, boundary > 0 ? boundary : 0);
 
     for (int i = 0; i < boundary; i++) {
-        PyList_SET_ITEM(result, i, PyInt_FromLong(i));
+        PyList_SET_ITEM(result, i, Nuitka_PyInt_FromLong(i));
     }
 
     return result;
@@ -205,10 +191,10 @@ PyObject *BUILTIN_RANGE2(PyThreadState *tstate, PyObject *low, PyObject *high) {
 
     if (fallback) {
         // Transfers references to tuple.
-        PyObject *pos_args = MAKE_TUPLE2_0(low_temp, high_temp);
+        PyObject *pos_args = MAKE_TUPLE2_0(tstate, low_temp, high_temp);
         NUITKA_ASSIGN_BUILTIN(range);
 
-        PyObject *result = CALL_FUNCTION_WITH_POSARGS2(tstate, NUITKA_ACCESS_BUILTIN(range), pos_args);
+        PyObject *result = CALL_FUNCTION_WITH_POS_ARGS2(tstate, NUITKA_ACCESS_BUILTIN(range), pos_args);
 
         Py_DECREF(pos_args);
 
@@ -264,11 +250,11 @@ PyObject *BUILTIN_RANGE3(PyThreadState *tstate, PyObject *low, PyObject *high, P
     }
 
     if (fallback) {
-        PyObject *pos_args = MAKE_TUPLE3_0(low_temp, high_temp, step_temp);
+        PyObject *pos_args = MAKE_TUPLE3_0(tstate, low_temp, high_temp, step_temp);
 
         NUITKA_ASSIGN_BUILTIN(range);
 
-        PyObject *result = CALL_FUNCTION_WITH_POSARGS3(tstate, NUITKA_ACCESS_BUILTIN(range), pos_args);
+        PyObject *result = CALL_FUNCTION_WITH_POS_ARGS3(tstate, NUITKA_ACCESS_BUILTIN(range), pos_args);
 
         Py_DECREF(pos_args);
 
@@ -315,6 +301,8 @@ PyObject *MAKE_XRANGE(PyThreadState *tstate, long start, long stop, long step) {
         return NULL;
     }
 
+    // spell-checker: ignore rangeobject
+
     struct _rangeobject2 *result = (struct _rangeobject2 *)PyObject_New(struct _rangeobject2, &PyRange_Type);
     assert(result != NULL);
 
@@ -599,7 +587,7 @@ PyObject *BUILTIN_ALL(PyThreadState *tstate, PyObject *value) {
 
         if (cmp == 0) {
             Py_DECREF(it);
-            Py_INCREF(Py_False);
+            Py_INCREF_IMMORTAL(Py_False);
             return Py_False;
         }
     }
@@ -610,7 +598,7 @@ PyObject *BUILTIN_ALL(PyThreadState *tstate, PyObject *value) {
         return NULL;
     }
 
-    Py_INCREF(Py_True);
+    Py_INCREF_IMMORTAL(Py_True);
     return Py_True;
 }
 
@@ -649,7 +637,7 @@ PyObject *BUILTIN_ANY(PyThreadState *tstate, PyObject *value) {
         }
         if (cmp > 0) {
             Py_DECREF(it);
-            Py_INCREF(Py_True);
+            Py_INCREF_IMMORTAL(Py_True);
             return Py_True;
         }
     }
@@ -659,7 +647,7 @@ PyObject *BUILTIN_ANY(PyThreadState *tstate, PyObject *value) {
         return NULL;
     }
 
-    Py_INCREF(Py_False);
+    Py_INCREF_IMMORTAL(Py_False);
     return Py_False;
 }
 
@@ -688,7 +676,7 @@ PyObject *BUILTIN_FORMAT(PyThreadState *tstate, PyObject *value, PyObject *forma
 }
 
 // Helper functions for print. Need to play nice with Python softspace
-// behaviour.
+// behavior. spell-checker: ignore softspace
 
 #if PYTHON_VERSION >= 0x300
 NUITKA_DEFINE_BUILTIN(print);
@@ -724,10 +712,9 @@ bool PRINT_NEW_LINE_TO(PyObject *file) {
 #else
     NUITKA_ASSIGN_BUILTIN(print);
 
-    PyObject *exception_type, *exception_value;
-    PyTracebackObject *exception_tb;
+    struct Nuitka_ExceptionPreservationItem saved_exception_state;
 
-    FETCH_ERROR_OCCURRED_UNTRACED(tstate, &exception_type, &exception_value, &exception_tb);
+    FETCH_ERROR_OCCURRED_STATE_UNTRACED(tstate, &saved_exception_state);
 
     PyObject *result;
 
@@ -739,14 +726,14 @@ bool PRINT_NEW_LINE_TO(PyObject *file) {
 
         // TODO: This should use something that does not build a dictionary at all, and not
         // uses a tuple.
-        result = CALL_FUNCTION_WITH_KEYARGS(tstate, NUITKA_ACCESS_BUILTIN(print), kw_args);
+        result = CALL_FUNCTION_WITH_KW_ARGS(tstate, NUITKA_ACCESS_BUILTIN(print), kw_args);
 
         Py_DECREF(kw_args);
     }
 
     Py_XDECREF(result);
 
-    RESTORE_ERROR_OCCURRED_UNTRACED(tstate, exception_type, exception_value, exception_tb);
+    RESTORE_ERROR_OCCURRED_STATE_UNTRACED(tstate, &saved_exception_state);
 
     return result != NULL;
 #endif
@@ -818,13 +805,12 @@ bool PRINT_ITEM_TO(PyObject *file, PyObject *object) {
 #else
     NUITKA_ASSIGN_BUILTIN(print);
 
-    PyObject *exception_type, *exception_value;
-    PyTracebackObject *exception_tb;
+    struct Nuitka_ExceptionPreservationItem saved_exception_state;
 
-    FETCH_ERROR_OCCURRED_UNTRACED(tstate, &exception_type, &exception_value, &exception_tb);
+    FETCH_ERROR_OCCURRED_STATE_UNTRACED(tstate, &saved_exception_state);
 
     // TODO: Have a helper that creates a dictionary for PyObject **
-    PyObject *print_kw = MAKE_DICT_EMPTY();
+    PyObject *print_kw = MAKE_DICT_EMPTY(tstate);
     DICT_SET_ITEM(print_kw, const_str_plain_end, const_str_empty);
 
     if (file == NULL) {
@@ -833,7 +819,7 @@ bool PRINT_ITEM_TO(PyObject *file, PyObject *object) {
         DICT_SET_ITEM(print_kw, const_str_plain_file, file);
     }
 
-    PyObject *print_args = MAKE_TUPLE1(object);
+    PyObject *print_args = MAKE_TUPLE1(tstate, object);
 
     PyObject *result = CALL_FUNCTION(tstate, NUITKA_ACCESS_BUILTIN(print), print_args, print_kw);
 
@@ -842,7 +828,7 @@ bool PRINT_ITEM_TO(PyObject *file, PyObject *object) {
 
     Py_XDECREF(result);
 
-    RESTORE_ERROR_OCCURRED_UNTRACED(tstate, exception_type, exception_value, exception_tb);
+    RESTORE_ERROR_OCCURRED_STATE_UNTRACED(tstate, &saved_exception_state);
 
     return result != NULL;
 #endif
@@ -850,12 +836,18 @@ bool PRINT_ITEM_TO(PyObject *file, PyObject *object) {
 
 void PRINT_REFCOUNT(PyObject *object) {
     if (object) {
+#if PYTHON_VERSION >= 0x3c0
+        if (_Py_IsImmortal(object)) {
+            PRINT_STRING(" refcnt IMMORTAL");
+            return;
+        }
+#endif
         char buffer[1024];
         snprintf(buffer, sizeof(buffer) - 1, " refcnt %" PY_FORMAT_SIZE_T "d ", Py_REFCNT(object));
 
         PRINT_STRING(buffer);
     } else {
-        PRINT_STRING("<null>");
+        PRINT_STRING(" <null>");
     }
 }
 
@@ -870,6 +862,17 @@ bool PRINT_STRING(char const *str) {
     }
 }
 
+bool PRINT_STRING_W(wchar_t const *str) {
+    if (str) {
+        PyObject *tmp = NuitkaUnicode_FromWideChar(str, -1);
+        bool res = PRINT_ITEM(tmp);
+        Py_DECREF(tmp);
+        return res;
+    } else {
+        return PRINT_STRING("<nullstr>");
+    }
+}
+
 bool PRINT_FORMAT(char const *fmt, ...) {
     va_list args;
     va_start(args, fmt);
@@ -878,16 +881,17 @@ bool PRINT_FORMAT(char const *fmt, ...) {
     char buffer[4096];
 
     vsprintf(buffer, fmt, args);
+    va_end(args);
+
     return PRINT_STRING(buffer);
 }
 
 bool PRINT_REPR(PyObject *object) {
-    PyObject *exception_type, *exception_value;
-    PyTracebackObject *exception_tb;
-
     PyThreadState *tstate = PyThreadState_GET();
 
-    FETCH_ERROR_OCCURRED_UNTRACED(tstate, &exception_type, &exception_value, &exception_tb);
+    struct Nuitka_ExceptionPreservationItem saved_exception_state;
+
+    FETCH_ERROR_OCCURRED_STATE_UNTRACED(tstate, &saved_exception_state);
 
     bool res;
 
@@ -904,7 +908,7 @@ bool PRINT_REPR(PyObject *object) {
         res = PRINT_NULL();
     }
 
-    RESTORE_ERROR_OCCURRED_UNTRACED(tstate, exception_type, exception_value, exception_tb);
+    RESTORE_ERROR_OCCURRED_STATE_UNTRACED(tstate, &saved_exception_state);
 
     return res;
 }
@@ -913,50 +917,63 @@ bool PRINT_NULL(void) { return PRINT_STRING("<NULL>"); }
 
 bool PRINT_TYPE(PyObject *object) { return PRINT_ITEM((PyObject *)Py_TYPE(object)); }
 
-#if PYTHON_VERSION < 0x3b0
-void _PRINT_EXCEPTION(PyObject *exception_type, PyObject *exception_value, PyTracebackObject *exception_tb) {
-#else
-void _PRINT_EXCEPTION(PyObject *exception_value) {
-    PyObject *exception_type = exception_value ? PyExceptionInstance_Class(exception_value) : NULL;
-    PyTracebackObject *exception_tb = (exception_value && PyExceptionInstance_Check(exception_value))
-                                          ? GET_EXCEPTION_TRACEBACK(exception_value)
-                                          : NULL;
-#endif
+void _PRINT_EXCEPTION3(PyObject *exception_type, PyObject *exception_value, PyTracebackObject *exception_tb) {
     PRINT_REPR(exception_type);
-    if (exception_type) {
+    if (exception_type != NULL) {
         PRINT_REFCOUNT(exception_type);
     }
     PRINT_STRING("|");
     PRINT_REPR(exception_value);
-    if (exception_value) {
+    if (exception_value != NULL) {
         PRINT_REFCOUNT(exception_value);
     }
 #if PYTHON_VERSION >= 0x300
     if (exception_value != NULL && PyExceptionInstance_Check(exception_value)) {
         PRINT_STRING(" <- context ");
-        PyObject *context = PyException_GetContext(exception_value);
+        PyObject *context = Nuitka_Exception_GetContext(exception_value);
         PRINT_REPR(context);
-        Py_XDECREF(context);
     }
 #endif
     PRINT_STRING("|");
     PRINT_REPR((PyObject *)exception_tb);
+    if (exception_tb != NULL) {
+        PRINT_REFCOUNT((PyObject *)exception_tb);
+    }
 
     PRINT_NEW_LINE();
 }
 
+#if PYTHON_VERSION >= 0x3b0
+void _PRINT_EXCEPTION1(PyObject *exception_value) {
+    PyObject *exception_type = exception_value ? PyExceptionInstance_Class(exception_value) : NULL;
+    PyTracebackObject *exception_tb = (exception_value && PyExceptionInstance_Check(exception_value))
+                                          ? GET_EXCEPTION_TRACEBACK(exception_value)
+                                          : NULL;
+
+    _PRINT_EXCEPTION3(exception_type, exception_value, exception_tb);
+}
+#endif
+
 void PRINT_CURRENT_EXCEPTION(void) {
     PyThreadState *tstate = PyThreadState_GET();
 
     PRINT_STRING("current_exc=");
+#if PYTHON_VERSION < 0x3c0
     PRINT_EXCEPTION(tstate->curexc_type, tstate->curexc_value, (PyTracebackObject *)tstate->curexc_traceback);
+#else
+    _PRINT_EXCEPTION1(tstate->exc_info->exc_value);
+#endif
 }
 
 void PRINT_PUBLISHED_EXCEPTION(void) {
     PyThreadState *tstate = PyThreadState_GET();
 
     PRINT_STRING("thread_exc=");
+#if PYTHON_VERSION < 0x3b0
     PRINT_EXCEPTION(EXC_TYPE(tstate), EXC_VALUE(tstate), EXC_TRACEBACK(tstate));
+#else
+    PRINT_EXCEPTION(EXC_TYPE(tstate), EXC_VALUE(tstate), GET_EXCEPTION_TRACEBACK(EXC_VALUE(tstate)));
+#endif
 }
 
 // TODO: Could be ported, the "printf" stuff would need to be split. On Python3
@@ -974,7 +991,7 @@ void PRINT_TRACEBACK(PyTracebackObject *traceback) {
         PyFrameObject *frame = traceback->tb_frame;
 
         while (frame != NULL) {
-            printf("  Frame at %s\n", PyString_AsString(PyObject_Str((PyObject *)frame->f_code)));
+            printf("  Frame at %s\n", PyString_AsString(PyObject_Str((PyObject *)Nuitka_Frame_GetCodeObject(frame))));
 
             frame = frame->f_back;
         }
@@ -1023,6 +1040,8 @@ bool PRINT_ITEM(PyObject *object) {
     }
 }
 
+bool PRINT_ITEM_LINE(PyObject *object) { return PRINT_ITEM(object) && PRINT_NEW_LINE(); }
+
 #if PYTHON_VERSION < 0x300
 
 static void set_slot(PyObject **slot, PyObject *value) {
@@ -1032,26 +1051,26 @@ static void set_slot(PyObject **slot, PyObject *value) {
     Py_XDECREF(temp);
 }
 
-static void set_attr_slots(PyClassObject *klass) {
-    set_slot(&klass->cl_getattr, FIND_ATTRIBUTE_IN_CLASS(klass, const_str_plain___getattr__));
-    set_slot(&klass->cl_setattr, FIND_ATTRIBUTE_IN_CLASS(klass, const_str_plain___setattr__));
-    set_slot(&klass->cl_delattr, FIND_ATTRIBUTE_IN_CLASS(klass, const_str_plain___delattr__));
+static void set_attr_slots(PyClassObject *class_object) {
+    set_slot(&class_object->cl_getattr, FIND_ATTRIBUTE_IN_CLASS(class_object, const_str_plain___getattr__));
+    set_slot(&class_object->cl_setattr, FIND_ATTRIBUTE_IN_CLASS(class_object, const_str_plain___setattr__));
+    set_slot(&class_object->cl_delattr, FIND_ATTRIBUTE_IN_CLASS(class_object, const_str_plain___delattr__));
 }
 
-static bool set_dict(PyClassObject *klass, PyObject *value) {
+static bool set_dict(PyClassObject *class_object, PyObject *value) {
     if (value == NULL || !PyDict_Check(value)) {
         PyThreadState *tstate = PyThreadState_GET();
         SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "__dict__ must be a dictionary object");
         return false;
     } else {
-        set_slot(&klass->cl_dict, value);
-        set_attr_slots(klass);
+        set_slot(&class_object->cl_dict, value);
+        set_attr_slots(class_object);
 
         return true;
     }
 }
 
-static bool set_bases(PyClassObject *klass, PyObject *value) {
+static bool set_bases(PyClassObject *class_object, PyObject *value) {
     if (value == NULL || !PyTuple_Check(value)) {
 
         PyThreadState *tstate = PyThreadState_GET();
@@ -1071,7 +1090,7 @@ static bool set_bases(PyClassObject *klass, PyObject *value) {
                 return false;
             }
 
-            if (unlikely(PyClass_IsSubclass(base, (PyObject *)klass))) {
+            if (unlikely(PyClass_IsSubclass(base, (PyObject *)class_object))) {
                 PyThreadState *tstate = PyThreadState_GET();
 
                 SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError,
@@ -1080,14 +1099,14 @@ static bool set_bases(PyClassObject *klass, PyObject *value) {
             }
         }
 
-        set_slot(&klass->cl_bases, value);
-        set_attr_slots(klass);
+        set_slot(&class_object->cl_bases, value);
+        set_attr_slots(class_object);
 
         return true;
     }
 }
 
-static bool set_name(PyClassObject *klass, PyObject *value) {
+static bool set_name(PyClassObject *class_object, PyObject *value) {
     if (value == NULL || !PyDict_Check(value)) {
         PyThreadState *tstate = PyThreadState_GET();
 
@@ -1102,11 +1121,11 @@ static bool set_name(PyClassObject *klass, PyObject *value) {
         return false;
     }
 
-    set_slot(&klass->cl_name, value);
+    set_slot(&class_object->cl_name, value);
     return true;
 }
 
-static int nuitka_class_setattr(PyClassObject *klass, PyObject *attr_name, PyObject *value) {
+static int nuitka_class_setattr(PyClassObject *class_object, PyObject *attr_name, PyObject *value) {
     char const *sattr_name = PyString_AsString(attr_name);
 
     if (sattr_name[0] == '_' && sattr_name[1] == '_') {
@@ -1114,72 +1133,72 @@ static int nuitka_class_setattr(PyClassObject *klass, PyObject *attr_name, PyObj
 
         if (sattr_name[n - 2] == '_' && sattr_name[n - 1] == '_') {
             if (strcmp(sattr_name, "__dict__") == 0) {
-                if (set_dict(klass, value) == false) {
+                if (set_dict(class_object, value) == false) {
                     return -1;
                 } else {
                     return 0;
                 }
             } else if (strcmp(sattr_name, "__bases__") == 0) {
-                if (set_bases(klass, value) == false) {
+                if (set_bases(class_object, value) == false) {
                     return -1;
                 } else {
                     return 0;
                 }
             } else if (strcmp(sattr_name, "__name__") == 0) {
-                if (set_name(klass, value) == false) {
+                if (set_name(class_object, value) == false) {
                     return -1;
                 } else {
                     return 0;
                 }
             } else if (strcmp(sattr_name, "__getattr__") == 0) {
-                set_slot(&klass->cl_getattr, value);
+                set_slot(&class_object->cl_getattr, value);
             } else if (strcmp(sattr_name, "__setattr__") == 0) {
-                set_slot(&klass->cl_setattr, value);
+                set_slot(&class_object->cl_setattr, value);
             } else if (strcmp(sattr_name, "__delattr__") == 0) {
-                set_slot(&klass->cl_delattr, value);
+                set_slot(&class_object->cl_delattr, value);
             }
         }
     }
 
     if (value == NULL) {
-        int status = DICT_REMOVE_ITEM(klass->cl_dict, attr_name);
+        int status = DICT_REMOVE_ITEM(class_object->cl_dict, attr_name);
 
         if (status < 0) {
-            PyErr_Format(PyExc_AttributeError, "class %s has no attribute '%s'", PyString_AS_STRING(klass->cl_name),
-                         sattr_name);
+            PyErr_Format(PyExc_AttributeError, "class %s has no attribute '%s'",
+                         PyString_AS_STRING(class_object->cl_name), sattr_name);
         }
 
         return status;
     } else {
-        return DICT_SET_ITEM(klass->cl_dict, attr_name, value) ? 0 : -1;
+        return DICT_SET_ITEM(class_object->cl_dict, attr_name, value) ? 0 : -1;
     }
 }
 
-static PyObject *nuitka_class_getattr(PyClassObject *klass, PyObject *attr_name) {
+static PyObject *nuitka_class_getattr(PyClassObject *class_object, PyObject *attr_name) {
     char const *sattr_name = PyString_AsString(attr_name);
 
     if (sattr_name[0] == '_' && sattr_name[1] == '_') {
         if (strcmp(sattr_name, "__dict__") == 0) {
-            Py_INCREF(klass->cl_dict);
-            return klass->cl_dict;
+            Py_INCREF(class_object->cl_dict);
+            return class_object->cl_dict;
         } else if (strcmp(sattr_name, "__bases__") == 0) {
-            Py_INCREF(klass->cl_bases);
-            return klass->cl_bases;
+            Py_INCREF(class_object->cl_bases);
+            return class_object->cl_bases;
         } else if (strcmp(sattr_name, "__name__") == 0) {
-            if (klass->cl_name == NULL) {
-                Py_INCREF(Py_None);
+            if (class_object->cl_name == NULL) {
+                Py_INCREF_IMMORTAL(Py_None);
                 return Py_None;
             } else {
-                Py_INCREF(klass->cl_name);
-                return klass->cl_name;
+                Py_INCREF(class_object->cl_name);
+                return class_object->cl_name;
             }
         }
     }
 
-    PyObject *value = FIND_ATTRIBUTE_IN_CLASS(klass, attr_name);
+    PyObject *value = FIND_ATTRIBUTE_IN_CLASS(class_object, attr_name);
 
     if (unlikely(value == NULL)) {
-        PyErr_Format(PyExc_AttributeError, "class %s has no attribute '%s'", PyString_AS_STRING(klass->cl_name),
+        PyErr_Format(PyExc_AttributeError, "class %s has no attribute '%s'", PyString_AS_STRING(class_object->cl_name),
                      sattr_name);
         return NULL;
     }
@@ -1192,7 +1211,7 @@ static PyObject *nuitka_class_getattr(PyClassObject *klass, PyObject *attr_name)
         Py_INCREF(value);
         return value;
     } else {
-        return tp_descr_get(value, (PyObject *)NULL, (PyObject *)klass);
+        return tp_descr_get(value, (PyObject *)NULL, (PyObject *)class_object);
     }
 }
 
@@ -1269,7 +1288,7 @@ static PyObject *QUICK_ITERATOR_NEXT(PyThreadState *tstate, struct Nuitka_QuickI
 
     switch (qiter->iterator_mode) {
     case ITERATOR_GENERIC:
-        result = ITERATOR_NEXT(qiter->iterator_data.iter);
+        result = ITERATOR_NEXT_ITERATOR(qiter->iterator_data.iter);
 
         if (result == NULL) {
             Py_DECREF(qiter->iterator_data.iter);
@@ -1341,11 +1360,7 @@ PyObject *BUILTIN_SUM1(PyThreadState *tstate, PyObject *sequence) {
         item = QUICK_ITERATOR_NEXT(tstate, &qiter, &finished);
 
         if (finished) {
-#if PYTHON_VERSION < 0x300
-            return PyInt_FromLong(int_result);
-#else
-            return PyLong_FromLong(int_result);
-#endif
+            return Nuitka_PyInt_FromLong(int_result);
         } else if (item == NULL) {
             return NULL;
         }
@@ -1389,7 +1404,7 @@ PyObject *BUILTIN_SUM1(PyThreadState *tstate, PyObject *sequence) {
 #endif
 
         if (item == Py_False) {
-            Py_DECREF(item);
+            Py_DECREF_IMMORTAL(item);
             continue;
         }
 
@@ -1409,12 +1424,8 @@ PyObject *BUILTIN_SUM1(PyThreadState *tstate, PyObject *sequence) {
         break;
     }
 
-/* Switch over to objects, and redo last step. */
-#if PYTHON_VERSION < 0x300
-    result = PyInt_FromLong(int_result);
-#else
-    result = PyLong_FromLong(int_result);
-#endif
+    /* Switch over to objects, and redo last step. */
+    result = Nuitka_PyInt_FromLong(int_result);
     CHECK_OBJECT(result);
 
     PyObject *temp = PyNumber_Add(result, item);
@@ -1466,9 +1477,9 @@ PyObject *BUILTIN_SUM2(PyThreadState *tstate, PyObject *sequence, PyObject *star
     CHECK_OBJECT(sequence);
     CHECK_OBJECT(start);
 
-    PyObject *pos_args = MAKE_TUPLE2(sequence, start);
+    PyObject *pos_args = MAKE_TUPLE2(tstate, sequence, start);
 
-    PyObject *result = CALL_FUNCTION_WITH_POSARGS2(tstate, NUITKA_ACCESS_BUILTIN(sum), pos_args);
+    PyObject *result = CALL_FUNCTION_WITH_POS_ARGS2(tstate, NUITKA_ACCESS_BUILTIN(sum), pos_args);
 
     Py_DECREF(pos_args);
 
@@ -1709,8 +1720,8 @@ char const *getBinaryDirectoryHostEncoded(bool resolve_symlinks) {
 
 #endif
 
-#ifdef _NUITKA_STANDALONE
-static PyObject *getBinaryFilenameObject(bool resolve_symlinks) {
+#ifdef _NUITKA_EXE
+PyObject *getBinaryFilenameObject(bool resolve_symlinks) {
     static PyObject *binary_filename = NULL;
     static PyObject *binary_filename_resolved = NULL;
 
@@ -1753,7 +1764,7 @@ static PyObject *getBinaryFilenameObject(bool resolve_symlinks) {
 }
 #endif
 
-static PyObject *getBinaryDirectoryObject(bool resolve_symlinks) {
+PyObject *getBinaryDirectoryObject(bool resolve_symlinks) {
     static PyObject *binary_directory = NULL;
     static PyObject *binary_directory_resolved = NULL;
 
@@ -1808,7 +1819,7 @@ PyObject *getStandaloneSysExecutablePath(PyObject *basename) {
 #else
 
 #if defined(_WIN32)
-/* Small helper function to get current DLL handle. */
+// Small helper function to get current DLL handle, spell-checker: ignore lpcstr
 static HMODULE getDllModuleHandle(void) {
     static HMODULE hm = NULL;
 
@@ -1824,58 +1835,127 @@ static HMODULE getDllModuleHandle(void) {
 }
 #endif
 
+filename_char_t const *getDllDirectory(void) {
 #if defined(_WIN32)
-// Replacement for RemoveFileSpecA, slightly smaller.
-static void stripFilenameA(char *path) {
-    char *last_slash = NULL;
+    static WCHAR path[MAXPATHLEN + 1];
+    path[0] = 0;
 
-    while (*path != 0) {
-        if (*path == '\\') {
-            last_slash = path;
-        }
+    int res = GetModuleFileNameW(getDllModuleHandle(), path, MAXPATHLEN);
+    assert(res != 0);
 
-        path++;
+    stripFilenameW(path);
+
+    return path;
+#else
+    Dl_info where;
+
+    {
+        NUITKA_MAY_BE_UNUSED int res = dladdr((void *)getDllDirectory, &where);
+        assert(res != 0);
     }
 
-    if (last_slash != NULL) {
-        *last_slash = 0;
+    return dirname((char *)where.dli_fname);
+#endif
+}
+static PyObject *getDllDirectoryObject(void) {
+    static PyObject *dll_directory = NULL;
+
+    if (dll_directory == NULL) {
+        filename_char_t const *dll_directory_filename = getDllDirectory();
+
+        dll_directory = Nuitka_String_FromFilename(dll_directory_filename);
+
+#if PYTHON_VERSION < 0x300
+        // Avoid unnecessary unicode values.
+        PyObject *decoded_dll_directory = PyObject_Str(dll_directory);
+
+        if (decoded_dll_directory == NULL) {
+            PyThreadState *tstate = PyThreadState_GET();
+            DROP_ERROR_OCCURRED(tstate);
+        } else {
+            Py_DECREF(dll_directory);
+            dll_directory = decoded_dll_directory;
+        }
+#endif
     }
+
+    CHECK_OBJECT(dll_directory);
+
+    return dll_directory;
 }
 #endif
 
-static char const *getDllDirectory(void) {
+#if defined(_NUITKA_MODULE)
+static filename_char_t const *getDllFilename(void) {
 #if defined(_WIN32)
-    static char path[MAXPATHLEN + 1];
-    path[0] = '\0';
-
-#if PYTHON_VERSION >= 0x300
-    WCHAR path2[MAXPATHLEN + 1];
-    path2[0] = 0;
+    static WCHAR path[MAXPATHLEN + 1];
+    path[0] = 0;
 
-    int res = GetModuleFileNameW(getDllModuleHandle(), path2, MAXPATHLEN + 1);
+    int res = GetModuleFileNameW(getDllModuleHandle(), path, MAXPATHLEN);
     assert(res != 0);
 
-    int res2 = WideCharToMultiByte(CP_UTF8, 0, path2, -1, path, MAXPATHLEN + 1, NULL, NULL);
-    assert(res2 != 0);
+    return path;
 #else
-    int res = GetModuleFileNameA(getDllModuleHandle(), path, MAXPATHLEN + 1);
-    assert(res != 0);
+    Dl_info where;
+
+    {
+        NUITKA_MAY_BE_UNUSED int res = dladdr((void *)getDllDirectory, &where);
+        assert(res != 0);
+    }
+
+    return where.dli_fname;
 #endif
+}
 
-    stripFilenameA(path);
+PyObject *getDllFilenameObject(void) {
+    static PyObject *dll_filename = NULL;
 
-    return path;
+    if (dll_filename == NULL) {
+        filename_char_t const *dll_filename_str = getDllFilename();
 
-#else
-    Dl_info where;
-    int res = dladdr((void *)getDllDirectory, &where);
-    assert(res != 0);
+        dll_filename = Nuitka_String_FromFilename(dll_filename_str);
 
-    return dirname((char *)where.dli_fname);
+#if PYTHON_VERSION < 0x300
+        // Avoid unnecessary unicode values.
+        PyObject *decoded_dll_filename = PyObject_Str(dll_filename);
+
+        if (decoded_dll_filename == NULL) {
+            PyThreadState *tstate = PyThreadState_GET();
+            DROP_ERROR_OCCURRED(tstate);
+        } else {
+            Py_DECREF(dll_filename);
+            dll_filename = decoded_dll_filename;
+        }
 #endif
+    }
+
+    CHECK_OBJECT(dll_filename);
+
+    return dll_filename;
 }
 #endif
 
+PyObject *getContainingDirectoryObject(bool resolve_symlinks) {
+#if defined(_NUITKA_EXE)
+#if defined(_NUITKA_ONEFILE_MODE)
+    environment_char_t const *onefile_binary = getEnvironmentVariable("NUITKA_ONEFILE_BINARY");
+    if (onefile_binary != NULL) {
+        PyObject *result = Nuitka_String_FromFilename(onefile_binary);
+        unsetEnvironmentVariable("NUITKA_ONEFILE_BINARY");
+
+        PyThreadState *tstate = PyThreadState_GET();
+        return OS_PATH_DIRNAME(tstate, result);
+    }
+
+    return getBinaryDirectoryObject(resolve_symlinks);
+#else
+    return getBinaryDirectoryObject(resolve_symlinks);
+#endif
+#else
+    return getDllDirectoryObject();
+#endif
+}
+
 static void _initDeepCopy(void);
 
 void _initBuiltinModule(void) {
@@ -1902,10 +1982,13 @@ void _initBuiltinModule(void) {
     assert(PyDict_Check(dict_builtin));
 
 #ifdef _NUITKA_STANDALONE
-    int res = PyDict_SetItemString((PyObject *)dict_builtin, "__nuitka_binary_dir", getBinaryDirectoryObject(true));
-    assert(res == 0);
-    PyDict_SetItemString((PyObject *)dict_builtin, "__nuitka_binary_exe", getBinaryFilenameObject(true));
-    assert(res == 0);
+    {
+        NUITKA_MAY_BE_UNUSED int res =
+            PyDict_SetItemString((PyObject *)dict_builtin, "__nuitka_binary_dir", getBinaryDirectoryObject(true));
+        assert(res == 0);
+        PyDict_SetItemString((PyObject *)dict_builtin, "__nuitka_binary_exe", getBinaryFilenameObject(true));
+        assert(res == 0);
+    }
 #endif
 
     // init Nuitka_BuiltinModule_Type, PyType_Ready won't copy all member from
@@ -1927,7 +2010,7 @@ void _initBuiltinModule(void) {
     Nuitka_BuiltinModule_Type.tp_alloc = PyModule_Type.tp_alloc;
     Nuitka_BuiltinModule_Type.tp_new = PyModule_Type.tp_new;
     Nuitka_BuiltinModule_Type.tp_free = PyModule_Type.tp_free;
-    int res2 = PyType_Ready(&Nuitka_BuiltinModule_Type);
+    NUITKA_MAY_BE_UNUSED int res2 = PyType_Ready(&Nuitka_BuiltinModule_Type);
     assert(res2 >= 0);
 
     // Replace type of builtin module to take over.
@@ -1943,11 +2026,7 @@ PyObject *MAKE_RELATIVE_PATH(PyObject *relative) {
     static PyObject *our_path_object = NULL;
 
     if (our_path_object == NULL) {
-#if defined(_NUITKA_EXE)
-        our_path_object = getBinaryDirectoryObject(true);
-#else
-        our_path_object = Nuitka_String_FromString(getDllDirectory());
-#endif
+        our_path_object = getContainingDirectoryObject(true);
     }
 
     return JOIN_PATH2(our_path_object, relative);
@@ -1991,7 +2070,9 @@ volatile int _Py_Ticker = _Py_CheckInterval;
 iternextfunc default_iternext;
 
 void _initSlotIterNext(void) {
-    PyObject *pos_args = MAKE_TUPLE1((PyObject *)&PyBaseObject_Type);
+    PyThreadState *tstate = PyThreadState_GET();
+
+    PyObject *pos_args = MAKE_TUPLE1(tstate, (PyObject *)&PyBaseObject_Type);
 
     // Note: Not using MAKE_DICT_EMPTY on purpose, this is called early on.
     PyObject *kw_args = PyDict_New();
@@ -2061,6 +2142,8 @@ PyObject *MAKE_UNION_TYPE(PyObject *args) {
 #include "HelpersOperationBinaryMatmult.c"
 #endif
 
+#include "HelpersOperationBinaryDualAdd.c"
+
 #include "HelpersOperationInplaceAdd.c"
 #include "HelpersOperationInplaceBitand.c"
 #include "HelpersOperationInplaceBitor.c"
@@ -2081,12 +2164,21 @@ PyObject *MAKE_UNION_TYPE(PyObject *args) {
 #endif
 
 #include "HelpersComparisonEq.c"
-#include "HelpersComparisonGe.c"
-#include "HelpersComparisonGt.c"
 #include "HelpersComparisonLe.c"
 #include "HelpersComparisonLt.c"
+
+#include "HelpersComparisonGe.c"
+#include "HelpersComparisonGt.c"
 #include "HelpersComparisonNe.c"
 
+#include "HelpersComparisonDualEq.c"
+#include "HelpersComparisonDualLe.c"
+#include "HelpersComparisonDualLt.c"
+
+#include "HelpersComparisonDualGe.c"
+#include "HelpersComparisonDualGt.c"
+#include "HelpersComparisonDualNe.c"
+
 #include "HelpersChecksumTools.c"
 #include "HelpersConstantsBlob.c"
 
@@ -2099,3 +2191,28 @@ PyObject *MAKE_UNION_TYPE(PyObject *args) {
 #endif
 
 #include "MetaPathBasedLoader.c"
+
+#ifdef _NUITKA_EXPERIMENTAL_DUMP_C_TRACEBACKS
+#include "HelpersDumpBacktraces.c"
+#endif
+
+#ifdef _NUITKA_INLINE_COPY_HACL
+#include "Hacl_Hash_SHA2.c"
+#endif
+
+#include "HelpersJitSources.c"
+
+//     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.