Nuitka-winsvc 2.3.9__cp311-cp311-win_amd64.whl → 2.4.1__cp311-cp311-win_amd64.whl

nuitka/build/static_src/MainProgram.c

@@ -850,7 +850,7 @@ static void setInputOutputHandles(PyThreadState *tstate) {
 #else
         PyObject *filename = getExpandedTemplatePath(NUITKA_FORCED_STDOUT_PATH);
 #endif
-        PyObject *stdout_file = BUILTIN_OPEN_SIMPLE(tstate, filename, "w", SYSFLAG_UNBUFFERED != 1, encoding);
+        PyObject *stdout_file = BUILTIN_OPEN_SIMPLE(tstate, filename, "w", SYSFLAG_UNBUFFERED != 1, encoding, false);
         if (unlikely(stdout_file == NULL)) {
             PyErr_PrintEx(1);
             Py_Exit(1);
@@ -867,7 +867,7 @@ static void setInputOutputHandles(PyThreadState *tstate) {
 #else
         PyObject *filename = getExpandedTemplatePath(NUITKA_FORCED_STDERR_PATH);
 #endif
-        PyObject *stderr_file = BUILTIN_OPEN_SIMPLE(tstate, filename, "w", false, encoding);
+        PyObject *stderr_file = BUILTIN_OPEN_SIMPLE(tstate, filename, "w", false, encoding, false);
         if (unlikely(stderr_file == NULL)) {
             PyErr_PrintEx(1);
             Py_Exit(1);
@@ -888,19 +888,19 @@ static void setInputOutputHandles(PyThreadState *tstate) {
         if (shallSetOutputHandleToNull("stdin")) {
             // CPython core requires stdin to be buffered due to methods usage, and it won't matter
             // here much.
-            PyObject *stdin_file = BUILTIN_OPEN_SIMPLE(tstate, devnull_filename, "r", true, encoding);
+            PyObject *stdin_file = BUILTIN_OPEN_SIMPLE(tstate, devnull_filename, "r", true, encoding, false);
 
             setStdinHandle(tstate, stdin_file);
         }
 
         if (shallSetOutputHandleToNull("stdout")) {
-            PyObject *stdout_file = BUILTIN_OPEN_SIMPLE(tstate, devnull_filename, "w", false, encoding);
+            PyObject *stdout_file = BUILTIN_OPEN_SIMPLE(tstate, devnull_filename, "w", false, encoding, false);
 
             setStdoutHandle(tstate, stdout_file);
         }
 
         if (shallSetOutputHandleToNull("stderr")) {
-            PyObject *stderr_file = BUILTIN_OPEN_SIMPLE(tstate, devnull_filename, "w", false, encoding);
+            PyObject *stderr_file = BUILTIN_OPEN_SIMPLE(tstate, devnull_filename, "w", false, encoding, false);
 
             setStderrHandle(tstate, stderr_file);
         }
@@ -1121,10 +1121,17 @@ static void nuitka_segfault_handler(int sig) {
     puts("have multiple reasons. Please check https://nuitka.net/info/segfault.html");
     puts("for solutions.");
 
-    exit(-SIGSEGV);
+    signal(SIGSEGV, SIG_DFL);
+    raise(SIGSEGV);
 }
 #endif
 
+#if _NUITKA_NATIVE_WCHAR_ARGV == 1
+extern wchar_t const *getBinaryFilenameWideChars(bool resolve_symlinks);
+#else
+extern char const *getBinaryFilenameHostEncoded(bool resolve_symlinks);
+#endif
+
 #ifdef _NUITKA_WINMAIN_ENTRY_POINT
 int __stdcall wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, wchar_t *lpCmdLine, int nCmdShow) {
     /* MSVC, MINGW64 */
@@ -1272,15 +1279,26 @@ int main(int argc, char **argv) {
 
     /* Initial command line handling only. */
 
+// Make sure, we use the absolute program path for argv[0]
+#if !defined(_NUITKA_ONEFILE_MODE) && _NUITKA_NATIVE_WCHAR_ARGV == 0
+    argv[0] = (char *)getBinaryFilenameHostEncoded(false);
+#endif
+
 #if PYTHON_VERSION >= 0x300 && _NUITKA_NATIVE_WCHAR_ARGV == 0
     NUITKA_PRINT_TRACE("main(): Calling convertCommandLineParameters.");
     orig_argv = convertCommandLineParameters(argc, argv);
 #elif PYTHON_VERSION < 0x300 && _NUITKA_NATIVE_WCHAR_ARGV == 1
+    NUITKA_PRINT_TRACE("main(): Calling getCommandLineToArgvA.");
     orig_argv = getCommandLineToArgvA(GetCommandLineA());
 #else
 orig_argv = argv;
 #endif
 
+// Make sure, we use the absolute program path for argv[0]
+#if !defined(_NUITKA_ONEFILE_MODE) && _NUITKA_NATIVE_WCHAR_ARGV == 1 && PYTHON_VERSION >= 0x300
+    orig_argv[0] = (wchar_t *)getBinaryFilenameWideChars(false);
+#endif
+
     // Make sure the compiled path of Python is replaced.
     Py_SetProgramName(orig_argv[0]);
 
@@ -1452,7 +1470,7 @@ orig_argv = argv;
         // platform ones in the future.
         PyObject *encoding = NULL;
 
-        PyObject *stdout_file = BUILTIN_OPEN_SIMPLE(tstate, filename, "w", SYSFLAG_UNBUFFERED != 1, encoding);
+        PyObject *stdout_file = BUILTIN_OPEN_SIMPLE(tstate, filename, "w", SYSFLAG_UNBUFFERED != 1, encoding, false);
         if (unlikely(stdout_file == NULL)) {
             PyErr_PrintEx(1);
             Py_Exit(1);
@@ -1469,7 +1487,7 @@ orig_argv = argv;
         // platform ones in the future.
         PyObject *encoding = NULL;
 
-        PyObject *stderr_file = BUILTIN_OPEN_SIMPLE(tstate, filename, "w", SYSFLAG_UNBUFFERED != 1, encoding);
+        PyObject *stderr_file = BUILTIN_OPEN_SIMPLE(tstate, filename, "w", SYSFLAG_UNBUFFERED != 1, encoding, false);
         if (unlikely(stderr_file == NULL)) {
             PyErr_PrintEx(1);
             Py_Exit(1);
@@ -1488,7 +1506,7 @@ orig_argv = argv;
 
         // CPython core requires stdin to be buffered due to methods usage, and it won't matter
         // here much.
-        PyObject *stdin_file = BUILTIN_OPEN_SIMPLE(tstate, filename, "r", true, encoding);
+        PyObject *stdin_file = BUILTIN_OPEN_SIMPLE(tstate, filename, "r", true, encoding, false);
 
         Py_DECREF(filename);
 
@@ -1685,6 +1703,7 @@ orig_argv = argv;
         }
 #endif
         PyDict_DelItemString(Nuitka_GetSysModules(), NUITKA_MAIN_MODULE_NAME);
+        DROP_ERROR_OCCURRED(tstate);
 
 #if _NUITKA_PLUGIN_WINDOWS_SERVICE_ENABLED
         NUITKA_PRINT_TRACE("main(): Calling plugin SvcLaunchService() entry point.");

nuitka/build/static_src/MetaPathBasedLoader.c

@@ -174,11 +174,7 @@ static PyObject *_makeDunderPathObject(PyThreadState *tstate, PyObject *module_p
         return NULL;
     }
 
-    int res = PyList_SetItem(path_list, 0, module_path_entry);
-    if (unlikely(res != 0)) {
-        return NULL;
-    }
-    Py_INCREF(module_path_entry);
+    PyList_SET_ITEM0(path_list, 0, module_path_entry);
 
     CHECK_OBJECT(path_list);
     return path_list;
@@ -256,7 +252,7 @@ static struct Nuitka_MetaPathBasedLoaderEntry *findEntry(char const *name) {
 
     while (current->name != NULL) {
         if ((current->flags & NUITKA_TRANSLATED_FLAG) != 0) {
-            current->name = UNTRANSLATE(current->name);
+            current->name = UN_TRANSLATE(current->name);
             current->flags -= NUITKA_TRANSLATED_FLAG;
         }
 
@@ -284,7 +280,7 @@ static struct Nuitka_MetaPathBasedLoaderEntry *findContainingPackageEntry(char c
 
     while (current->name != NULL) {
         if ((current->flags & NUITKA_TRANSLATED_FLAG) != 0) {
-            current->name = UNTRANSLATE(current->name);
+            current->name = UN_TRANSLATE(current->name);
             current->flags -= NUITKA_TRANSLATED_FLAG;
         }
 
@@ -590,46 +586,18 @@ static PyObject *_nuitka_loader_get_data(PyObject *self, PyObject *args, PyObjec
     return GET_FILE_BYTES(tstate, filename);
 }
 
-#ifdef _WIN32
-static void setModuleFileValue(PyThreadState *tstate, PyObject *module, wchar_t const *filename) {
-#else
-static void setModuleFileValue(PyThreadState *tstate, PyObject *module, char const *filename) {
-#endif
-    bool needs_update = false;
-
-    PyObject *existing_file_value = LOOKUP_ATTRIBUTE(tstate, module, const_str_plain___file__);
-
-#if PYTHON_VERSION < 0x300
-    if (existing_file_value != NULL) {
-        if (PyCObject_Check(existing_file_value)) {
-            PyObject_DelAttr(module, const_str_plain___file__);
-            existing_file_value = LOOKUP_ATTRIBUTE(tstate, module, const_str_plain___file__);
-        }
-    }
-#endif
+static void setModuleFileValue(PyThreadState *tstate, PyObject *module, filename_char_t const *filename) {
+    CHECK_OBJECT(module);
+    assert(filename != NULL);
 
-    if (existing_file_value == NULL) {
-        CLEAR_ERROR_OCCURRED(tstate);
-        needs_update = true;
-    } else {
-        if (existing_file_value == Py_None) {
-            needs_update = true;
-        }
+    assert(PyModule_Check(module));
 
-        Py_DECREF(existing_file_value);
-    }
+    PyObject *dict = PyModule_GetDict(module);
 
-    if (needs_update) {
-#ifdef _WIN32
-        int res = SET_ATTRIBUTE(tstate, module, const_str_plain___file__, NuitkaUnicode_FromWideChar(filename, -1));
-#else
-        int res = SET_ATTRIBUTE(tstate, module, const_str_plain___file__, PyUnicode_FromString(filename));
-#endif
-        if (unlikely(res < 0)) {
-            // Might be refuted, which wouldn't be harmful.
-            CLEAR_ERROR_OCCURRED(tstate);
-        }
-    }
+    // TODO: We should have DICT_SET_ITEM0/1 for these things.
+    PyObject *new_file_value = Nuitka_String_FromFilename(filename);
+    DICT_SET_ITEM(dict, const_str_plain___file__, new_file_value);
+    Py_DECREF(new_file_value);
 }
 
 #if PYTHON_VERSION < 0x300
@@ -689,21 +657,55 @@ static void _fillExtensionModuleDllEntryFunctionName(PyThreadState *tstate, char
 // Append the the entry name from full path module name with dots,
 // and translate these into directory separators.
 static void _makeModuleCFilenameValue(filename_char_t *filename, size_t filename_size, char const *module_name_cstr,
-                                      PyObject *module_name) {
+                                      PyObject *module_name, bool is_package) {
 #ifdef _WIN32
     appendWStringSafeW(filename, getBinaryDirectoryWideChars(true), filename_size);
-    appendCharSafeW(filename, SEP, filename_size);
+    appendWCharSafeW(filename, SEP_L, filename_size);
     appendModuleNameAsPathW(filename, module_name, filename_size);
+    if (is_package) {
+        appendWCharSafeW(filename, SEP_L, filename_size);
+        appendStringSafeW(filename, "__init__", filename_size);
+    }
     appendStringSafeW(filename, ".pyd", filename_size);
 #else
     appendStringSafe(filename, getBinaryDirectoryHostEncoded(true), filename_size);
     appendCharSafe(filename, SEP, filename_size);
     appendModuleNameAsPath(filename, module_name_cstr, filename_size);
+    if (is_package) {
+        appendCharSafe(filename, SEP, filename_size);
+        appendStringSafe(filename, "__init__", filename_size);
+    }
     appendStringSafe(filename, ".so", filename_size);
 #endif
 }
 #endif
 
+#if PYTHON_VERSION >= 0x3c0 && defined(_NUITKA_USE_UNEXPOSED_API)
+extern _Thread_local const char *pkgcontext;
+#endif
+
+static const char *NuitkaImport_SwapPackageContext(const char *new_context) {
+// TODO: The locking APIs for 3.13 give errors here that are not explained
+// yet.
+#if PYTHON_VERSION >= 0x3c0 && PYTHON_VERSION < 0x3d0
+    // spell-checker: ignore pkgcontext
+    const char *old_context = _PyRuntime.imports.pkgcontext;
+    _PyRuntime.imports.pkgcontext = new_context;
+#if PYTHON_VERSION >= 0x3c0 && defined(_NUITKA_USE_UNEXPOSED_API)
+    pkgcontext = new_context;
+#endif
+    return old_context;
+#elif PYTHON_VERSION >= 0x370
+    char const *old_context = _Py_PackageContext;
+    _Py_PackageContext = (char *)new_context;
+    return old_context;
+#else
+    char *old_context = _Py_PackageContext;
+    _Py_PackageContext = (char *)new_context;
+    return (char const *)old_context;
+#endif
+}
+
 static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full_name, const filename_char_t *filename,
                                          bool is_package) {
     // Determine the package name and basename of the module to load.
@@ -729,6 +731,8 @@ static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full
     }
 
 #ifndef _NUITKA_EXPERIMENTAL_DEBUG_STANDALONE
+    // Disable all but critical errors, prevents dialogs from showing.
+    // spell-checker: ignore SEM_FAILCRITICALERRORS
     unsigned int old_mode = SetErrorMode(SEM_FAILCRITICALERRORS);
 #endif
 
@@ -782,6 +786,13 @@ static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full
     // structure internals of 3.8 or higher.
     // spell-checker: ignore getdlopenflags,dlopenflags
 
+#ifdef __wasi__
+    const char *error = "dynamic libraries are not implemented in wasi";
+    SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_ImportError, error);
+    return NULL;
+
+    entrypoint_t entrypoint = NULL;
+#else
     static PyObject *dlopenflags_object = NULL;
     if (dlopenflags_object == NULL) {
         dlopenflags_object = CALL_FUNCTION_NO_ARGS(tstate, Nuitka_SysGetObject("getdlopenflags"));
@@ -806,16 +817,11 @@ static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full
     }
 
     entrypoint_t entrypoint = (entrypoint_t)dlsym(handle, entry_function_name);
+#endif // __wasi__
 #endif
     assert(entrypoint);
 
-#if PYTHON_VERSION < 0x370
-    char *old_context = _Py_PackageContext;
-#else
-    char const *old_context = _Py_PackageContext;
-#endif
-
-    _Py_PackageContext = (char *)package;
+    char const *old_context = NuitkaImport_SwapPackageContext(package);
 
     // Finally call into the DLL.
     PGO_onModuleEntered(full_name);
@@ -836,7 +842,13 @@ static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full
         PySys_WriteStderr("import %s # return from entrypoint\n", full_name);
     }
 
-    _Py_PackageContext = old_context;
+#if 0
+    PRINT_STRING("FRESH");
+    PRINT_ITEM(module);
+    PRINT_NEW_LINE();
+#endif
+
+    NuitkaImport_SwapPackageContext(old_context);
 
 #if PYTHON_VERSION < 0x300
     PyObject *module = Nuitka_GetModuleString(tstate, full_name);
@@ -918,6 +930,8 @@ static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full
     } else {
         def = PyModule_GetDef(module);
 
+        def->m_base.m_init = entrypoint;
+
         // Set "__spec__" and "__file__" after load.
         setModuleFileValue(tstate, module, filename);
         PyObject *full_name_obj = Nuitka_String_FromString(full_name);
@@ -976,11 +990,8 @@ static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full
 #else
     PyObject *full_name_obj = PyUnicode_FromString(full_name);
     CHECK_OBJECT(full_name_obj);
-#ifdef _WIN32
-    PyObject *filename_obj = NuitkaUnicode_FromWideChar(filename, -1);
-#else
-    PyObject *filename_obj = PyUnicode_FromString(filename);
-#endif
+    PyObject *filename_obj = Nuitka_String_FromFilename(filename);
+
     CHECK_OBJECT(filename_obj);
 
 #if PYTHON_VERSION < 0x3d0
@@ -1052,20 +1063,11 @@ static PyObject *loadModule(PyThreadState *tstate, PyObject *module, PyObject *m
                             struct Nuitka_MetaPathBasedLoaderEntry const *entry) {
 #ifdef _NUITKA_STANDALONE
     if ((entry->flags & NUITKA_EXTENSION_MODULE_FLAG) != 0) {
-        filename_char_t filename[MAXPATHLEN + 1] = {0};
-        _makeModuleCFilenameValue(filename, sizeof(filename) / sizeof(filename_char_t), entry->name, module_name);
-
-        // Set "__spec__" and "__file__", some modules expect it early.
-        setModuleFileValue(tstate, module, filename);
-
         bool is_package = (entry->flags & NUITKA_PACKAGE_FLAG) != 0;
 
-#if PYTHON_VERSION >= 0x350
-        PyObject *spec_value = createModuleSpec(tstate, module_name,
-                                                LOOKUP_ATTRIBUTE(tstate, module, const_str_plain___file__), is_package);
-
-        SET_ATTRIBUTE(tstate, module, const_str_plain___spec__, spec_value);
-#endif
+        filename_char_t filename[MAXPATHLEN + 1] = {0};
+        _makeModuleCFilenameValue(filename, sizeof(filename) / sizeof(filename_char_t), entry->name, module_name,
+                                  is_package);
 
         callIntoExtensionModule(tstate, entry->name, filename, is_package);
     } else
@@ -1087,7 +1089,7 @@ static PyObject *loadModule(PyThreadState *tstate, PyObject *module, PyObject *m
                                         (entry->flags & NUITKA_PACKAGE_FLAG) != 0);
     } else {
         assert((entry->flags & NUITKA_EXTENSION_MODULE_FLAG) == 0);
-        assert(entry->python_initfunc);
+        assert(entry->python_init_func);
 
         {
             NUITKA_MAY_BE_UNUSED bool res = Nuitka_SetModule(module_name, module);
@@ -1098,7 +1100,7 @@ static PyObject *loadModule(PyThreadState *tstate, PyObject *module, PyObject *m
 #if PYTHON_VERSION < 0x300
         NUITKA_MAY_BE_UNUSED
 #endif
-        PyObject *result = entry->python_initfunc(tstate, module, entry);
+        PyObject *result = entry->python_init_func(tstate, module, entry);
         CHECK_OBJECT_X(result);
 
 #if PYTHON_VERSION >= 0x300
@@ -1317,7 +1319,7 @@ static PyObject *_nuitka_loader_iter_modules(struct Nuitka_LoaderObject *self, P
 
     while (current->name != NULL) {
         if ((current->flags & NUITKA_TRANSLATED_FLAG) != 0) {
-            current->name = UNTRANSLATE(current->name);
+            current->name = UN_TRANSLATE(current->name);
             current->flags -= NUITKA_TRANSLATED_FLAG;
         }
 
@@ -1431,35 +1433,6 @@ PyObject *getImportLibBootstrapModule(void) {
 }
 #endif
 
-#if PYTHON_VERSION >= 0x340
-
-static PyObject *_nuitka_loader_repr_module(PyObject *self, PyObject *args, PyObject *kwds) {
-    PyObject *module;
-    PyObject *unused;
-
-    int res =
-        PyArg_ParseTupleAndKeywords(args, kwds, "O|O:module_repr", (char **)_kw_list_find_module, &module, &unused);
-
-    if (unlikely(res == 0)) {
-        return NULL;
-    }
-
-    PyThreadState *tstate = PyThreadState_GET();
-
-    return PyUnicode_FromFormat("<module '%s' from %R>", PyModule_GetName(module),
-                                Nuitka_GetFilenameObject(tstate, module));
-}
-
-static PyObject *getModuleSpecClass(PyObject *importlib_module) {
-    static PyObject *module_spec_class = NULL;
-
-    if (module_spec_class == NULL) {
-        module_spec_class = PyObject_GetAttrString(importlib_module, "ModuleSpec");
-    }
-
-    return module_spec_class;
-}
-
 static PyObject *getModuleFileValue(PyThreadState *tstate, struct Nuitka_MetaPathBasedLoaderEntry const *entry) {
     PyObject *dir_name = getModuleDirectory(tstate, entry);
 
@@ -1496,6 +1469,35 @@ static PyObject *getModuleFileValue(PyThreadState *tstate, struct Nuitka_MetaPat
     return result;
 }
 
+#if PYTHON_VERSION >= 0x340
+
+static PyObject *_nuitka_loader_repr_module(PyObject *self, PyObject *args, PyObject *kwds) {
+    PyObject *module;
+    PyObject *unused;
+
+    int res =
+        PyArg_ParseTupleAndKeywords(args, kwds, "O|O:module_repr", (char **)_kw_list_find_module, &module, &unused);
+
+    if (unlikely(res == 0)) {
+        return NULL;
+    }
+
+    PyThreadState *tstate = PyThreadState_GET();
+
+    return PyUnicode_FromFormat("<module '%s' from %R>", PyModule_GetName(module),
+                                Nuitka_GetFilenameObject(tstate, module));
+}
+
+static PyObject *getModuleSpecClass(PyObject *importlib_module) {
+    static PyObject *module_spec_class = NULL;
+
+    if (module_spec_class == NULL) {
+        module_spec_class = PyObject_GetAttrString(importlib_module, "ModuleSpec");
+    }
+
+    return module_spec_class;
+}
+
 static PyObject *createModuleSpec(PyThreadState *tstate, PyObject *module_name, PyObject *origin, bool is_package) {
     CHECK_OBJECT(module_name);
     assert(Nuitka_String_Check(module_name));
@@ -1669,9 +1671,9 @@ static PyObject *_nuitka_loader_exec_module(PyObject *self, PyObject *args, PyOb
 
         if (extension_module_filename != NULL) {
             // Set filename attribute
-            res = SET_ATTRIBUTE(tstate, module, const_str_plain___file__, extension_module_filename);
+            bool b_res = SET_ATTRIBUTE(tstate, module, const_str_plain___file__, extension_module_filename);
 
-            if (unlikely(res < 0)) {
+            if (unlikely(b_res == false)) {
                 // Might be refuted, which wouldn't be harmful.
                 CLEAR_ERROR_OCCURRED(tstate);
             }
@@ -1805,7 +1807,7 @@ static PyObject *_nuitka_loader_sys_path_hook(PyObject *self, PyObject *args, Py
 
     while (entry->name != NULL) {
         if ((entry->flags & NUITKA_TRANSLATED_FLAG) != 0) {
-            entry->name = UNTRANSLATE(entry->name);
+            entry->name = UN_TRANSLATE(entry->name);
             entry->flags -= NUITKA_TRANSLATED_FLAG;
         }
 
@@ -1892,14 +1894,28 @@ static void Nuitka_Loader_tp_dealloc(struct Nuitka_LoaderObject *loader) {
 
 static int Nuitka_Loader_tp_traverse(struct Nuitka_LoaderObject *loader, visitproc visit, void *arg) { return 0; }
 
+static PyObject *Nuitka_Loader_get_name(struct Nuitka_LoaderObject *loader, void *closure) {
+    PyObject *result = Nuitka_String_FromString(loader->m_loader_entry->name);
+
+    return result;
+}
+static PyObject *Nuitka_Loader_get_path(struct Nuitka_LoaderObject *loader, void *closure) {
+    PyThreadState *tstate = PyThreadState_GET();
+    PyObject *result = getModuleFileValue(tstate, loader->m_loader_entry);
+
+    return result;
+}
+
 static PyObject *Nuitka_Loader_get__module__(struct Nuitka_LoaderObject *loader, void *closure) {
     PyObject *result = const_str_plain___nuitka__;
 
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 
 static PyGetSetDef Nuitka_Loader_tp_getset[] = {{(char *)"__module__", (getter)Nuitka_Loader_get__module__, NULL, NULL},
+                                                {(char *)"name", (getter)Nuitka_Loader_get_name, NULL, NULL},
+                                                {(char *)"path", (getter)Nuitka_Loader_get_path, NULL, NULL},
                                                 {NULL}};
 
 PyTypeObject Nuitka_Loader_Type = {
@@ -1946,8 +1962,8 @@ PyObject *Nuitka_Loader_New(struct Nuitka_MetaPathBasedLoaderEntry const *entry)
     return (PyObject *)result;
 }
 
-void registerMetaPathBasedUnfreezer(struct Nuitka_MetaPathBasedLoaderEntry *_loader_entries,
-                                    unsigned char **bytecode_data) {
+void registerMetaPathBasedLoader(struct Nuitka_MetaPathBasedLoaderEntry *_loader_entries,
+                                 unsigned char **bytecode_data) {
     // Do it only once.
     if (loader_entries) {
         assert(_loader_entries == loader_entries);
@@ -1971,7 +1987,7 @@ void registerMetaPathBasedUnfreezer(struct Nuitka_MetaPathBasedLoaderEntry *_loa
 
             while (current->name != NULL) {
                 if ((current->flags & NUITKA_TRANSLATED_FLAG) != 0) {
-                    current->name = UNTRANSLATE(current->name);
+                    current->name = UN_TRANSLATE(current->name);
                     current->flags -= NUITKA_TRANSLATED_FLAG;
                 }
 

nuitka/build/static_src/MetaPathBasedLoaderImportlibMetadataDistribution.c

@@ -13,7 +13,16 @@
 static PyObject *metadata_values_dict = NULL;
 
 // For initialization of the metadata dictionary during startup.
-void setDistributionsMetadata(PyObject *metadata_values) { metadata_values_dict = metadata_values; }
+void setDistributionsMetadata(PyThreadState *tstate, PyObject *metadata_values) {
+    metadata_values_dict = MAKE_DICT_EMPTY(tstate);
+
+    // We get the items passed, and need to add it to the dictionary.
+    int res = PyDict_MergeFromSeq2(metadata_values_dict, metadata_values, 1);
+    assert(res == 0);
+
+    // PRINT_ITEM(metadata_values_dict);
+    // PRINT_NEW_LINE();
+}
 
 bool Nuitka_DistributionNext(Py_ssize_t *pos, PyObject **distribution_name_ptr) {
     PyObject *value;
@@ -35,8 +44,8 @@ if sys.version_info >= (3, 8):\n\
 else:\n\
     from importlib_metadata import Distribution,distribution\n\
 class nuitka_distribution(Distribution):\n\
-    def __init__(self, base_path, metadata, entry_points):\n\
-        self.base_path = base_path; self.metadata_data = metadata\n\
+    def __init__(self, path, metadata, entry_points):\n\
+        self._path = path; self.metadata_data = metadata\n\
         self.entry_points_data = entry_points\n\
     def read_text(self, filename):\n\
         if filename == 'METADATA':\n\
@@ -44,7 +53,7 @@ class nuitka_distribution(Distribution):\n\
         elif filename == 'entry_points.txt':\n\
             return self.entry_points_data\n\
     def locate_file(self, path):\n\
-        return os.path.join(self.base_path, path)\n\
+        return os.path.join(self._path, path)\n\
 ";
 
         PyObject *nuitka_distribution_code_object = Py_CompileString(nuitka_distribution_code, "<exec>", Py_file_input);

nuitka/build/static_src/MetaPathBasedLoaderResourceReaderFiles.c

@@ -186,7 +186,7 @@ static PyObject *Nuitka_ResourceReaderFiles_read_text(struct Nuitka_ResourceRead
         return NULL;
     }
 
-    PyObject *file_object = BUILTIN_OPEN_SIMPLE(tstate, file_name, "r", true, encoding);
+    PyObject *file_object = BUILTIN_OPEN_SIMPLE(tstate, file_name, "r", true, encoding, true);
 
     Py_DECREF(file_name);
 
@@ -442,6 +442,33 @@ static PyObject *Nuitka_ResourceReaderFiles_absolute(struct Nuitka_ResourceReade
     return Nuitka_ResourceReaderFiles_New(tstate, files->m_loader_entry, abspath);
 }
 
+static PyObject *Nuitka_ResourceReaderFiles_get_parent(struct Nuitka_ResourceReaderFilesObject *files) {
+    PyThreadState *tstate = PyThreadState_GET();
+
+    PyObject *path = _Nuitka_ResourceReaderFiles_GetPath(tstate, files);
+
+    PyObject *abspath = OS_PATH_ABSPATH(tstate, path);
+
+    if (unlikely(abspath == NULL)) {
+        return NULL;
+    }
+
+    PyObject *dirname = OS_PATH_DIRNAME(tstate, abspath);
+
+    if (unlikely(dirname == NULL)) {
+        return NULL;
+    }
+
+    return Nuitka_ResourceReaderFiles_New(tstate, files->m_loader_entry, dirname);
+}
+
+static int Nuitka_ResourceReaderFiles_set_parent(struct Nuitka_ResourceReaderFilesObject *files, PyObject *value) {
+    PyThreadState *tstate = PyThreadState_GET();
+
+    SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_AttributeError, "readonly attribute");
+    return -1;
+}
+
 static PyMethodDef Nuitka_ResourceReaderFiles_methods[] = {
     {"iterdir", (PyCFunction)Nuitka_ResourceReaderFiles_iterdir, METH_NOARGS, NULL},
     {"read_bytes", (PyCFunction)Nuitka_ResourceReaderFiles_read_bytes, METH_NOARGS, NULL},
@@ -505,6 +532,8 @@ static PyObject *Nuitka_ResourceReaderFiles_tp_richcompare(struct Nuitka_Resourc
 
 static PyGetSetDef Nuitka_ResourceReaderFiles_getset[] = {
     {(char *)"name", (getter)Nuitka_ResourceReaderFiles_get_name, (setter)Nuitka_ResourceReaderFiles_set_name, NULL},
+    {(char *)"parent", (getter)Nuitka_ResourceReaderFiles_get_parent, (setter)Nuitka_ResourceReaderFiles_set_parent,
+     NULL},
     {NULL}};
 
 // Initialized during readying the type for nb_truediv

nuitka/build/static_src/OnefileBootstrap.c

@@ -813,6 +813,30 @@ extern bool checkSplashScreen(void);
 #endif
 #endif
 
+#ifdef _WIN32
+static wchar_t *getCommandLineForChildProcess(void) {
+    int argc;
+    LPWSTR *argv = CommandLineToArgvW(GetCommandLineW(), &argc);
+    assert(argv != NULL);
+    assert(argc > 0);
+
+    static wchar_t result[32768];
+    result[0] = 0;
+
+    appendWStringSafeW(result, getBinaryPath(), sizeof(result) / sizeof(wchar_t));
+
+    for (int i = 1; i < argc; i++) {
+        appendWCharSafeW(result, L' ', sizeof(result) / sizeof(wchar_t));
+        appendWStringSafeW(result, argv[i], sizeof(result) / sizeof(wchar_t));
+    }
+
+#if defined(_NUITKA_EXPERIMENTAL_DEBUG_ONEFILE_HANDLING)
+    wprintf(L"Command line composed to '%ls'\n", result);
+#endif
+    return result;
+}
+#endif
+
 #ifdef _NUITKA_WINMAIN_ENTRY_POINT
 int __stdcall wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, wchar_t *lpCmdLine, int nCmdShow) {
     int argc = __argc;
@@ -1243,12 +1267,12 @@ int main(int argc, char **argv) {
 
     PROCESS_INFORMATION pi;
 
-    bool_res = CreateProcessW(first_filename,        // application name
-                              GetCommandLineW(),     // command line
-                              NULL,                  // process attributes
-                              NULL,                  // thread attributes
-                              TRUE,                  // inherit handles
-                              NORMAL_PRIORITY_CLASS, // creation flags
+    bool_res = CreateProcessW(first_filename,                  // application name
+                              getCommandLineForChildProcess(), // command line
+                              NULL,                            // process attributes
+                              NULL,                            // thread attributes
+                              TRUE,                            // inherit handles
+                              NORMAL_PRIORITY_CLASS,           // creation flags
                               NULL, NULL, &si, &pi);
 
     NUITKA_PRINT_TIMING("ONEFILE: Started slave process.");
@@ -1307,6 +1331,10 @@ int main(int argc, char **argv) {
         exit_code = 2;
     } else if (pid == 0) {
         // Child process
+
+        // Make sure, we use the absolute program path for argv[0]
+        argv[0] = getBinaryPath();
+
         execv(first_filename, argv);
 
         fatalErrorChild("Error, couldn't launch child (exec)", errno);