Nuitka-winsvc 1.8__cp311-cp311-win_amd64.whl → 2.4.8__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,7 +81,7 @@ 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;
 
@@ -110,7 +96,7 @@ 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));
@@ -205,7 +191,7 @@ 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);
@@ -264,7 +250,7 @@ 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);
 
@@ -599,7 +585,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 +596,7 @@ PyObject *BUILTIN_ALL(PyThreadState *tstate, PyObject *value) {
         return NULL;
     }
 
-    Py_INCREF(Py_True);
+    Py_INCREF_IMMORTAL(Py_True);
     return Py_True;
 }
 
@@ -649,7 +635,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 +645,7 @@ PyObject *BUILTIN_ANY(PyThreadState *tstate, PyObject *value) {
         return NULL;
     }
 
-    Py_INCREF(Py_False);
+    Py_INCREF_IMMORTAL(Py_False);
     return Py_False;
 }
 
@@ -688,7 +674,7 @@ PyObject *BUILTIN_FORMAT(PyThreadState *tstate, PyObject *value, PyObject *forma
 }
 
 // Helper functions for print. Need to play nice with Python softspace
-// behaviour.
+// behavior.
 
 #if PYTHON_VERSION >= 0x300
 NUITKA_DEFINE_BUILTIN(print);
@@ -724,10 +710,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;
 
@@ -746,7 +731,7 @@ bool PRINT_NEW_LINE_TO(PyObject *file) {
 
     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 +803,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 +817,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 +826,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 +834,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(" recnf 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 +860,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 +879,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 +906,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;
 }
@@ -949,7 +951,11 @@ 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_EXCEPTION(tstate->exc_info->exc_value);
+#endif
 }
 
 void PRINT_PUBLISHED_EXCEPTION(void) {
@@ -974,7 +980,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 +1029,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 +1040,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 +1079,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 +1088,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 +1110,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 +1122,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 +1200,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);
     }
 }
 
@@ -1389,7 +1397,7 @@ PyObject *BUILTIN_SUM1(PyThreadState *tstate, PyObject *sequence) {
 #endif
 
         if (item == Py_False) {
-            Py_DECREF(item);
+            Py_DECREF_IMMORTAL(item);
             continue;
         }
 
@@ -1466,7 +1474,7 @@ 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);
 
@@ -1753,7 +1761,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;
 
@@ -1824,57 +1832,76 @@ static HMODULE getDllModuleHandle(void) {
 }
 #endif
 
+static 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);
 
-    if (last_slash != NULL) {
-        *last_slash = 0;
+    return path;
+#else
+    Dl_info where;
+
+    {
+        NUITKA_MAY_BE_UNUSED int res = dladdr((void *)getDllDirectory, &where);
+        assert(res != 0);
     }
-}
+
+    return dirname((char *)where.dli_fname);
 #endif
+}
+static PyObject *getDllDirectoryObject(void) {
+    static PyObject *dll_directory = NULL;
 
-static char const *getDllDirectory(void) {
-#if defined(_WIN32)
-    static char path[MAXPATHLEN + 1];
-    path[0] = '\0';
+    if (dll_directory == NULL) {
+        filename_char_t const *dll_directory_filename = getDllDirectory();
 
-#if PYTHON_VERSION >= 0x300
-    WCHAR path2[MAXPATHLEN + 1];
-    path2[0] = 0;
+        dll_directory = Nuitka_String_FromFilename(dll_directory_filename);
 
-    int res = GetModuleFileNameW(getDllModuleHandle(), path2, MAXPATHLEN + 1);
-    assert(res != 0);
+#if PYTHON_VERSION < 0x300
+        // Avoid unnecessary unicode values.
+        PyObject *decoded_dll_directory = PyObject_Str(dll_directory);
 
-    int res2 = WideCharToMultiByte(CP_UTF8, 0, path2, -1, path, MAXPATHLEN + 1, NULL, NULL);
-    assert(res2 != 0);
-#else
-    int res = GetModuleFileNameA(getDllModuleHandle(), path, MAXPATHLEN + 1);
-    assert(res != 0);
+        if (decoded_dll_directory == NULL) {
+            PyThreadState *tstate = PyThreadState_GET();
+            DROP_ERROR_OCCURRED(tstate);
+        } else {
+            Py_DECREF(dll_directory);
+            dll_directory = decoded_dll_directory;
+        }
 #endif
+    }
 
-    stripFilenameA(path);
+    CHECK_OBJECT(dll_directory);
 
-    return path;
+    return dll_directory;
+}
+#endif
 
-#else
-    Dl_info where;
-    int res = dladdr((void *)getDllDirectory, &where);
-    assert(res != 0);
+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");
 
-    return dirname((char *)where.dli_fname);
+        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);
 
@@ -1902,10 +1929,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 +1957,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 +1973,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 +2017,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();
@@ -2099,3 +2127,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.