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

nuitka/build/static_src/CompiledAsyncgenType.c

@@ -1,4 +1,4 @@
-//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 /** Compiled Asyncgen.
  *
@@ -177,13 +177,13 @@ static int Nuitka_Asyncgen_set_frame(PyObject *self, PyObject *value, void *data
 }
 
 static void Nuitka_Asyncgen_release_closure(struct Nuitka_AsyncgenObject *asyncgen) {
-    CHECK_OBJECT(asyncgen);
-
     for (Py_ssize_t i = 0; i < asyncgen->m_closure_given; i++) {
         CHECK_OBJECT(asyncgen->m_closure[i]);
         Py_DECREF(asyncgen->m_closure[i]);
     }
 
+    // This can be ran multiple times, set the count to zero,
+    // after first run, which deactivates the above loop.
     asyncgen->m_closure_given = 0;
 }
 
@@ -367,6 +367,7 @@ static PySendResult _Nuitka_Asyncgen_sendR(PyThreadState *tstate, struct Nuitka_
         PyObject *yielded;
 
         if (asyncgen->m_yield_from == NULL) {
+            // This consumes a reference to the value.
             yielded = ((asyncgen_code)asyncgen->m_code)(tstate, asyncgen, value);
         } else {
             // This does not release the value if any, so we need to do it afterwards.
@@ -397,7 +398,7 @@ static PySendResult _Nuitka_Asyncgen_sendR(PyThreadState *tstate, struct Nuitka_
         _Nuitka_GeneratorPopFrame(tstate, return_frame);
 
 #if _DEBUG_ASYNCGEN
-        PRINT_ASYNCGEN_STATUS("Returned from coroutine", asyncgen);
+        PRINT_ASYNCGEN_STATUS("Returned from asyncgen", asyncgen);
         // dumpFrameStack();
 #endif
 
@@ -792,7 +793,7 @@ static PyObject *Nuitka_Asyncgen_throw(PyThreadState *tstate, struct Nuitka_Asyn
     return result;
 }
 
-static int _Nuitka_Asyncgen_init_hooks(PyThreadState *tstate, struct Nuitka_AsyncgenObject *asyncgen) {
+static bool _Nuitka_Asyncgen_init_hooks(PyThreadState *tstate, struct Nuitka_AsyncgenObject *asyncgen) {
     /* Just do this once per async generator object. */
     if (asyncgen->m_hooks_init_done) {
         return 0;
@@ -816,13 +817,13 @@ static int _Nuitka_Asyncgen_init_hooks(PyThreadState *tstate, struct Nuitka_Asyn
         Py_DECREF(firstiter);
 
         if (unlikely(res == NULL)) {
-            return 1;
+            return true;
         }
 
         Py_DECREF(res);
     }
 
-    return 0;
+    return false;
 }
 
 static PyObject *Nuitka_AsyncgenAsend_New(struct Nuitka_AsyncgenObject *asyncgen, PyObject *sendval);
@@ -896,13 +897,13 @@ static PySendResult _Nuitka_Asyncgen_am_send(struct Nuitka_AsyncgenObject *async
 #endif
 
     *result = NULL;
-    Py_INCREF(arg);
 
     PyThreadState *tstate = PyThreadState_GET();
 
     struct Nuitka_ExceptionPreservationItem exception_state;
     INIT_ERROR_OCCURRED_STATE(&exception_state);
 
+    Py_INCREF(arg);
     PySendResult res = _Nuitka_Asyncgen_sendR(tstate, asyncgen, arg, false, &exception_state, result);
 
 #if _DEBUG_ASYNCGEN
@@ -922,6 +923,26 @@ static void Nuitka_Asyncgen_tp_finalize(struct Nuitka_AsyncgenObject *asyncgen)
     PyThreadState *tstate = PyThreadState_GET();
 
     struct Nuitka_ExceptionPreservationItem saved_exception_state;
+
+    // Need to call registered finalizer if provided, "asyncio" seems to do
+    // that.
+    PyObject *finalizer = asyncgen->m_finalizer;
+    if (finalizer != NULL && asyncgen->m_closed == false) {
+        // Save the current exception, if any.
+        FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
+
+        PyObject *res = CALL_FUNCTION_WITH_SINGLE_ARG(tstate, finalizer, (PyObject *)asyncgen);
+
+        if (unlikely(res == NULL)) {
+            PyErr_WriteUnraisable((PyObject *)asyncgen);
+        } else {
+            Py_DECREF(res);
+        }
+
+        RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
+        return;
+    }
+
     FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
 
     bool close_result = _Nuitka_Asyncgen_close(tstate, asyncgen);
@@ -944,69 +965,56 @@ static void Nuitka_Asyncgen_tp_dealloc(struct Nuitka_AsyncgenObject *asyncgen) {
     count_active_Nuitka_Asyncgen_Type -= 1;
     count_released_Nuitka_Asyncgen_Type += 1;
 #endif
+    if (asyncgen->m_weakrefs != NULL) {
+        Nuitka_GC_UnTrack(asyncgen);
 
-    // Revive temporarily.
-    assert(Py_REFCNT(asyncgen) == 0);
-    Py_SET_REFCNT(asyncgen, 1);
+        // TODO: Avoid API call and make this our own function to reuse the
+        // pattern of temporarily untracking the value or maybe even to avoid
+        // the need to do it. It may also be a lot of work to do that though
+        // and maybe having weakrefs is uncommon.
+        PyObject_ClearWeakRefs((PyObject *)asyncgen);
+        assert(!HAS_ERROR_OCCURRED(PyThreadState_GET()));
 
-    PyThreadState *tstate = PyThreadState_GET();
+        Nuitka_GC_Track(asyncgen);
+    }
 
-    // Save the current exception, if any, we must preserve it.
-    struct Nuitka_ExceptionPreservationItem saved_exception_state;
+    // TODO: Avoid this API call, it's bound to be slow on some platforms and
+    // does more checks than necessary for us.
+    if (PyObject_CallFinalizerFromDealloc((PyObject *)asyncgen)) {
+        return;
+    }
+    // if (!_PyGC_FINALIZED(asyncgen)) {
+    //     Nuitka_Asyncgen_tp_finalize(asyncgen);
 
-    PyObject *finalizer = asyncgen->m_finalizer;
-    if (finalizer != NULL && asyncgen->m_closed == false) {
-        // Save the current exception, if any.
-        FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
+    //     _PyGC_SET_FINALIZED(asyncgen);
+    // }
 
-        PyObject *res = CALL_FUNCTION_WITH_SINGLE_ARG(tstate, finalizer, (PyObject *)asyncgen);
+    Nuitka_GC_UnTrack(asyncgen);
 
-        if (unlikely(res == NULL)) {
-            PyErr_WriteUnraisable((PyObject *)asyncgen);
-        } else {
-            Py_DECREF(res);
-        }
+    PyThreadState *tstate = PyThreadState_GET();
 
-        RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
-        return;
-    }
+    // Save the current exception, if any, we must preserve it.
+    struct Nuitka_ExceptionPreservationItem saved_exception_state;
 
     FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
 
-    bool close_result = _Nuitka_Asyncgen_close(tstate, asyncgen);
-
-    if (unlikely(close_result == false)) {
-        PyErr_WriteUnraisable((PyObject *)asyncgen);
-    }
-
     Nuitka_Asyncgen_release_closure(asyncgen);
 
-    // Allow for above code to resurrect the coroutine, do not release the object
-    // like Py_DECREF would.
-    Py_SET_REFCNT(asyncgen, Py_REFCNT(asyncgen) - 1);
-    if (Py_REFCNT(asyncgen) >= 1) {
-        return;
-    }
+    Py_XDECREF(asyncgen->m_finalizer);
 
     if (asyncgen->m_frame) {
         Nuitka_SetFrameGenerator(asyncgen->m_frame, NULL);
         Py_DECREF(asyncgen->m_frame);
-        asyncgen->m_frame = NULL;
     }
 
     // Now it is safe to release references and memory for it.
-    Nuitka_GC_UnTrack(asyncgen);
-
-    Py_XDECREF(asyncgen->m_finalizer);
-
-    if (asyncgen->m_weakrefs != NULL) {
-        PyObject_ClearWeakRefs((PyObject *)asyncgen);
-        assert(!HAS_ERROR_OCCURRED(tstate));
-    }
-
     Py_DECREF(asyncgen->m_name);
     Py_DECREF(asyncgen->m_qualname);
 
+    // TODO: Maybe push this into the freelist code and do
+    // it on allocation.
+    _PyGC_SET_UNFINALIZED((PyObject *)asyncgen);
+
     /* Put the object into free list or release to GC */
     releaseToFreeList(free_list_asyncgens, asyncgen, MAX_ASYNCGEN_FREE_LIST_COUNT);
 
@@ -1310,8 +1318,8 @@ struct Nuitka_AsyncgenAsendObject {
 
 #if _DEBUG_ASYNCGEN
 
-NUITKA_MAY_BE_UNUSED static void _PRINT_ASYNCGENASEND_STATUS(char const *descriptor, char const *context,
-                                                             struct Nuitka_AsyncgenAsendObject *asyncgen_asend) {
+NUITKA_MAY_BE_UNUSED static void _PRINT_ASYNCGEN_ASEND_STATUS(char const *descriptor, char const *context,
+                                                              struct Nuitka_AsyncgenAsendObject *asyncgen_asend) {
     char const *status;
 
     switch (asyncgen_asend->m_state) {
@@ -1339,8 +1347,8 @@ NUITKA_MAY_BE_UNUSED static void _PRINT_ASYNCGENASEND_STATUS(char const *descrip
     PRINT_NEW_LINE();
 }
 
-#define PRINT_ASYNCGENASEND_STATUS(context, asyncgen_asend)                                                            \
-    _PRINT_ASYNCGENASEND_STATUS(__FUNCTION__, context, asyncgen_asend)
+#define PRINT_ASYNCGEN_ASEND_STATUS(context, asyncgen_asend)                                                           \
+    _PRINT_ASYNCGEN_ASEND_STATUS(__FUNCTION__, context, asyncgen_asend)
 
 #endif
 
@@ -1447,7 +1455,7 @@ static int Nuitka_AsyncgenAsend_tp_traverse(struct Nuitka_AsyncgenAsendObject *a
 
 static PyObject *Nuitka_AsyncgenAsend_send(struct Nuitka_AsyncgenAsendObject *asyncgen_asend, PyObject *arg) {
 #if _DEBUG_ASYNCGEN
-    PRINT_ASYNCGENASEND_STATUS("Enter", asyncgen_asend);
+    PRINT_ASYNCGEN_ASEND_STATUS("Enter", asyncgen_asend);
     PRINT_COROUTINE_VALUE("arg", arg);
     PRINT_NEW_LINE();
 #endif
@@ -1462,7 +1470,7 @@ static PyObject *Nuitka_AsyncgenAsend_send(struct Nuitka_AsyncgenAsendObject *as
 #endif
 
 #if _DEBUG_ASYNCGEN
-        PRINT_ASYNCGENASEND_STATUS("Leave", asyncgen_asend);
+        PRINT_ASYNCGEN_ASEND_STATUS("Leave", asyncgen_asend);
         PRINT_STRING("Closed -> StopIteration\n");
         PRINT_CURRENT_EXCEPTION();
         PRINT_NEW_LINE();
@@ -1507,12 +1515,17 @@ static PyObject *Nuitka_AsyncgenAsend_send(struct Nuitka_AsyncgenAsendObject *as
     PyObject *result = _Nuitka_Asyncgen_send(tstate, asyncgen_asend->m_gen, arg, false, &exception_state);
 
 #if _DEBUG_ASYNCGEN
-    PRINT_STRING("Returned from _Nuitka_Asyncgen_send\n");
+    PRINT_ASYNCGEN_ASEND_STATUS("Returned from _Nuitka_Asyncgen_send", asyncgen_asend);
     PRINT_COROUTINE_VALUE("result", result);
     PRINT_CURRENT_EXCEPTION();
 #endif
 
     result = _Nuitka_Asyncgen_unwrap_value(tstate, asyncgen_asend->m_gen, result);
+#if _DEBUG_ASYNCGEN
+    PRINT_ASYNCGEN_ASEND_STATUS("Returned from _Nuitka_Asyncgen_unwrap_value", asyncgen_asend);
+    PRINT_COROUTINE_VALUE("result", result);
+    PRINT_CURRENT_EXCEPTION();
+#endif
 
 #if _DEBUG_ASYNCGEN
     PRINT_COROUTINE_VALUE("result", result);
@@ -1525,7 +1538,7 @@ static PyObject *Nuitka_AsyncgenAsend_send(struct Nuitka_AsyncgenAsendObject *as
     }
 
 #if _DEBUG_ASYNCGEN
-    PRINT_ASYNCGENASEND_STATUS("Leave", asyncgen_asend);
+    PRINT_ASYNCGEN_ASEND_STATUS("Leave", asyncgen_asend);
     PRINT_COROUTINE_VALUE("result", result);
     PRINT_NEW_LINE();
 #endif
@@ -1535,7 +1548,7 @@ static PyObject *Nuitka_AsyncgenAsend_send(struct Nuitka_AsyncgenAsendObject *as
 
 static PyObject *Nuitka_AsyncgenAsend_tp_iternext(struct Nuitka_AsyncgenAsendObject *asyncgen_asend) {
 #if _DEBUG_ASYNCGEN
-    PRINT_ASYNCGENASEND_STATUS("Enter", asyncgen_asend);
+    PRINT_ASYNCGEN_ASEND_STATUS("Enter", asyncgen_asend);
     PRINT_STRING("Deferring to Nuitka_AsyncgenAsend_send(Py_None)\n");
     PRINT_NEW_LINE();
 #endif
@@ -1543,7 +1556,7 @@ static PyObject *Nuitka_AsyncgenAsend_tp_iternext(struct Nuitka_AsyncgenAsendObj
     PyObject *result = Nuitka_AsyncgenAsend_send(asyncgen_asend, Py_None);
 
 #if _DEBUG_ASYNCGEN
-    PRINT_ASYNCGENASEND_STATUS("Leave", asyncgen_asend);
+    PRINT_ASYNCGEN_ASEND_STATUS("Leave", asyncgen_asend);
     PRINT_COROUTINE_VALUE("result", result);
     PRINT_NEW_LINE();
 #endif
@@ -1553,7 +1566,7 @@ static PyObject *Nuitka_AsyncgenAsend_tp_iternext(struct Nuitka_AsyncgenAsendObj
 
 static PyObject *Nuitka_AsyncgenAsend_throw(struct Nuitka_AsyncgenAsendObject *asyncgen_asend, PyObject *args) {
 #if _DEBUG_ASYNCGEN
-    PRINT_ASYNCGENASEND_STATUS("Enter", asyncgen_asend);
+    PRINT_ASYNCGEN_ASEND_STATUS("Enter", asyncgen_asend);
     PRINT_STRING("Nuitka_AsyncgenAsend_throw: args:");
     PRINT_ITEM(args);
     PRINT_NEW_LINE();
@@ -1601,7 +1614,7 @@ static PyObject *Nuitka_AsyncgenAsend_throw(struct Nuitka_AsyncgenAsendObject *a
 static PyObject *_Nuitka_AsyncgenAsend_throw2(PyThreadState *tstate, struct Nuitka_AsyncgenAsendObject *asyncgen_asend,
                                               struct Nuitka_ExceptionPreservationItem *exception_state) {
 #if _DEBUG_ASYNCGEN
-    PRINT_ASYNCGENASEND_STATUS("Enter", asyncgen_asend);
+    PRINT_ASYNCGEN_ASEND_STATUS("Enter", asyncgen_asend);
     PRINT_EXCEPTION_STATE(exception_state);
     PRINT_CURRENT_EXCEPTION();
     PRINT_NEW_LINE();
@@ -1623,7 +1636,7 @@ static PyObject *_Nuitka_AsyncgenAsend_throw2(PyThreadState *tstate, struct Nuit
     }
 
 #if _DEBUG_ASYNCGEN
-    PRINT_ASYNCGENASEND_STATUS("Got result", asyncgen_asend);
+    PRINT_ASYNCGEN_ASEND_STATUS("Got result", asyncgen_asend);
     PRINT_COROUTINE_VALUE("result", result);
     PRINT_CURRENT_EXCEPTION();
 #endif
@@ -1640,7 +1653,7 @@ static PyObject *_Nuitka_AsyncgenAsend_throw2(PyThreadState *tstate, struct Nuit
     }
 
 #if _DEBUG_ASYNCGEN
-    PRINT_ASYNCGENASEND_STATUS("Leave", asyncgen_asend);
+    PRINT_ASYNCGEN_ASEND_STATUS("Leave", asyncgen_asend);
     PRINT_COROUTINE_VALUE("result", result);
     PRINT_CURRENT_EXCEPTION();
     PRINT_NEW_LINE();
@@ -1753,8 +1766,8 @@ struct Nuitka_AsyncgenAthrowObject {
 
 #if _DEBUG_ASYNCGEN
 
-NUITKA_MAY_BE_UNUSED static void _PRINT_ASYNCGENATHROW_STATUS(char const *descriptor, char const *context,
-                                                              struct Nuitka_AsyncgenAthrowObject *asyncgen_athrow) {
+NUITKA_MAY_BE_UNUSED static void _PRINT_ASYNCGEN_ATHROW_STATUS(char const *descriptor, char const *context,
+                                                               struct Nuitka_AsyncgenAthrowObject *asyncgen_athrow) {
     char const *status;
 
     switch (asyncgen_athrow->m_state) {
@@ -1782,8 +1795,8 @@ NUITKA_MAY_BE_UNUSED static void _PRINT_ASYNCGENATHROW_STATUS(char const *descri
     PRINT_NEW_LINE();
 }
 
-#define PRINT_ASYNCGENATHROW_STATUS(context, coroutine)                                                                \
-    _PRINT_ASYNCGENATHROW_STATUS(__FUNCTION__, context, asyncgen_athrow)
+#define PRINT_ASYNCGEN_ATHROW_STATUS(context, coroutine)                                                               \
+    _PRINT_ASYNCGEN_ATHROW_STATUS(__FUNCTION__, context, asyncgen_athrow)
 
 #endif
 
@@ -1818,7 +1831,7 @@ static int Nuitka_AsyncgenAthrow_traverse(struct Nuitka_AsyncgenAthrowObject *as
 
 static PyObject *Nuitka_AsyncgenAthrow_send(struct Nuitka_AsyncgenAthrowObject *asyncgen_athrow, PyObject *arg) {
 #if _DEBUG_ASYNCGEN
-    PRINT_ASYNCGENATHROW_STATUS("Enter", asyncgen_athrow);
+    PRINT_ASYNCGEN_ATHROW_STATUS("Enter", asyncgen_athrow);
     PRINT_COROUTINE_VALUE("arg", arg);
     PRINT_NEW_LINE();
 #endif
@@ -1893,7 +1906,7 @@ static PyObject *Nuitka_AsyncgenAthrow_send(struct Nuitka_AsyncgenAthrowObject *
                                              1, /* Do not close generator when PyExc_GeneratorExit is passed */
                                              &exception_state);
 
-            if (retval) {
+            if (retval != NULL) {
                 if (_PyAsyncGenWrappedValue_CheckExact(retval) || Nuitka_AsyncgenWrappedValue_CheckExact(retval)) {
 #if PYTHON_VERSION >= 0x380
                     asyncgen_athrow->m_gen->m_running_async = false;
@@ -1943,13 +1956,14 @@ static PyObject *Nuitka_AsyncgenAthrow_send(struct Nuitka_AsyncgenAthrowObject *
     struct Nuitka_ExceptionPreservationItem exception_state;
     INIT_ERROR_OCCURRED_STATE(&exception_state);
 
+    Py_INCREF(arg);
     retval = _Nuitka_Asyncgen_send(tstate, asyncgen, arg, false, &exception_state);
 
     if (asyncgen_athrow->m_args) {
         return _Nuitka_Asyncgen_unwrap_value(tstate, asyncgen, retval);
     } else {
         /* We are here to close if no args. */
-        if (retval) {
+        if (retval != NULL) {
             if (_PyAsyncGenWrappedValue_CheckExact(retval) || Nuitka_AsyncgenWrappedValue_CheckExact(retval)) {
 #if PYTHON_VERSION >= 0x380
                 asyncgen_athrow->m_gen->m_running_async = false;
@@ -1994,7 +2008,7 @@ check_error:
 
 static PyObject *Nuitka_AsyncgenAthrow_throw(struct Nuitka_AsyncgenAthrowObject *asyncgen_athrow, PyObject *args) {
 #if _DEBUG_ASYNCGEN
-    PRINT_ASYNCGENATHROW_STATUS("Enter", asyncgen_athrow);
+    PRINT_ASYNCGEN_ATHROW_STATUS("Enter", asyncgen_athrow);
     PRINT_COROUTINE_VALUE("args", args);
     PRINT_NEW_LINE();
 #endif

nuitka/build/static_src/CompiledCellType.c

@@ -1,4 +1,4 @@
-//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 /** Compiled cells.
  *
@@ -22,6 +22,7 @@ int count_allocated_Nuitka_Cell_Type;
 int count_released_Nuitka_Cell_Type;
 #endif
 
+// Freelist setup
 #define MAX_CELL_FREE_LIST_COUNT 1000
 static struct Nuitka_CellObject *free_list_cells = NULL;
 static int free_list_cells_count = 0;

nuitka/build/static_src/CompiledCodeHelpers.c

@@ -1,4 +1,4 @@
-//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 /* Implementations of compiled code helpers.
 
@@ -1595,25 +1595,6 @@ PyObject *JOIN_PATH2(PyObject *dirname, PyObject *filename) {
     return result;
 }
 
-#if defined(_WIN32)
-// Replacement for RemoveFileSpecW, slightly smaller, avoids a link library.
-NUITKA_MAY_BE_UNUSED static void stripFilenameW(wchar_t *path) {
-    wchar_t *last_slash = NULL;
-
-    while (*path != 0) {
-        if (*path == L'\\') {
-            last_slash = path;
-        }
-
-        path++;
-    }
-
-    if (last_slash != NULL) {
-        *last_slash = 0;
-    }
-}
-#endif
-
 #if defined(_NUITKA_EXE)
 
 wchar_t const *getBinaryDirectoryWideChars(bool resolve_symlinks) {
@@ -1629,6 +1610,7 @@ wchar_t const *getBinaryDirectoryWideChars(bool resolve_symlinks) {
 
         stripFilenameW(binary_directory);
 
+#ifndef _NUITKA_EXPERIMENTAL_AVOID_SHORT_PATH
         // Query length of result first.
         DWORD length = GetShortPathNameW(binary_directory, NULL, 0);
         assert(length != 0);
@@ -1645,6 +1627,7 @@ wchar_t const *getBinaryDirectoryWideChars(bool resolve_symlinks) {
         appendWStringSafeW(binary_directory, short_binary_directory, sizeof(binary_directory) / sizeof(wchar_t));
 
         free(short_binary_directory);
+#endif
 #else
         appendStringSafeW(binary_directory, getBinaryDirectoryHostEncoded(true),
                           sizeof(binary_directory) / sizeof(wchar_t));
@@ -1938,13 +1921,12 @@ PyObject *getDllFilenameObject(void) {
 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");
+    environment_char_t const *onefile_directory = getEnvironmentVariable("NUITKA_ONEFILE_DIRECTORY");
+    if (onefile_directory != NULL) {
+        PyObject *result = Nuitka_String_FromFilename(onefile_directory);
+        unsetEnvironmentVariable("NUITKA_ONEFILE_DIRECTORY");
 
-        PyThreadState *tstate = PyThreadState_GET();
-        return OS_PATH_DIRNAME(tstate, result);
+        return result;
     }
 
     return getBinaryDirectoryObject(resolve_symlinks);

nuitka/build/static_src/CompiledCoroutineType.c

@@ -1,4 +1,4 @@
-//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 /** Compiled Coroutines.
  *
@@ -177,8 +177,6 @@ static int Nuitka_Coroutine_set_frame(PyObject *self, PyObject *value, void *dat
 }
 
 static void Nuitka_Coroutine_release_closure(struct Nuitka_CoroutineObject *coroutine) {
-    CHECK_OBJECT(coroutine);
-
     for (Py_ssize_t i = 0; i < coroutine->m_closure_given; i++) {
         CHECK_OBJECT(coroutine->m_closure[i]);
         Py_DECREF(coroutine->m_closure[i]);
@@ -1084,19 +1082,37 @@ static void Nuitka_Coroutine_tp_finalize(struct Nuitka_CoroutineObject *coroutin
     RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
 }
 
+// Freelist setup
 #define MAX_COROUTINE_FREE_LIST_COUNT 100
-static struct Nuitka_CoroutineObject *free_list_coros = NULL;
-static int free_list_coros_count = 0;
+static struct Nuitka_CoroutineObject *free_list_coroutines = NULL;
+static int free_list_coroutines_count = 0;
 
 static void Nuitka_Coroutine_tp_dealloc(struct Nuitka_CoroutineObject *coroutine) {
 #if _DEBUG_REFCOUNTS
     count_active_Nuitka_Coroutine_Type -= 1;
     count_released_Nuitka_Coroutine_Type += 1;
 #endif
+    if (coroutine->m_weakrefs != NULL) {
+        Nuitka_GC_UnTrack(coroutine);
+
+        // TODO: Avoid API call and make this our own function to reuse the
+        // pattern of temporarily untracking the value or maybe even to avoid
+        // the need to do it. It may also be a lot of work to do that though
+        // and maybe having weakrefs is uncommon.
+        PyObject_ClearWeakRefs((PyObject *)coroutine);
+        assert(!HAS_ERROR_OCCURRED(PyThreadState_GET()));
+
+        Nuitka_GC_Track(coroutine);
+    }
+
+    // TODO: Avoid this API call, it's bound to be slow on some platforms and
+    // does more checks than necessary for us.
+    if (PyObject_CallFinalizerFromDealloc((PyObject *)coroutine)) {
+        return;
+    }
 
-    // Revive temporarily.
-    assert(Py_REFCNT(coroutine) == 0);
-    Py_SET_REFCNT(coroutine, 1);
+    // Now it is safe to release references and memory for it.
+    Nuitka_GC_UnTrack(coroutine);
 
     PyThreadState *tstate = PyThreadState_GET();
 
@@ -1109,44 +1125,26 @@ static void Nuitka_Coroutine_tp_dealloc(struct Nuitka_CoroutineObject *coroutine
     PRINT_NEW_LINE();
 #endif
 
-    bool close_result = _Nuitka_Coroutine_close(tstate, coroutine);
-
-    if (unlikely(close_result == false)) {
-        PyErr_WriteUnraisable((PyObject *)coroutine);
-    }
-
     Nuitka_Coroutine_release_closure(coroutine);
 
-    // Allow for above code to resurrect the coroutine.
-    Py_SET_REFCNT(coroutine, Py_REFCNT(coroutine) - 1);
-    if (Py_REFCNT(coroutine) >= 1) {
-        RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
-        return;
-    }
-
     if (coroutine->m_frame) {
         Nuitka_SetFrameGenerator(coroutine->m_frame, NULL);
         Py_DECREF(coroutine->m_frame);
-        coroutine->m_frame = NULL;
     }
 
-    // Now it is safe to release references and memory for it.
-    Nuitka_GC_UnTrack(coroutine);
-
-    if (coroutine->m_weakrefs != NULL) {
-        PyObject_ClearWeakRefs((PyObject *)coroutine);
-        assert(!HAS_ERROR_OCCURRED(tstate));
-    }
+#if PYTHON_VERSION >= 0x370
+    Py_XDECREF(coroutine->m_origin);
+#endif
 
     Py_DECREF(coroutine->m_name);
     Py_DECREF(coroutine->m_qualname);
 
-#if PYTHON_VERSION >= 0x370
-    Py_XDECREF(coroutine->m_origin);
-#endif
+    // TODO: Maybe push this into the freelist code and do
+    // it on allocation.
+    _PyGC_SET_UNFINALIZED((PyObject *)coroutine);
 
     /* Put the object into free list or release to GC */
-    releaseToFreeList(free_list_coros, coroutine, MAX_COROUTINE_FREE_LIST_COUNT);
+    releaseToFreeList(free_list_coroutines, coroutine, MAX_COROUTINE_FREE_LIST_COUNT);
 
     RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
 }
@@ -1402,7 +1400,7 @@ static PyObject *computeCoroutineOrigin(PyThreadState *tstate, int origin_depth)
         frame_count += 1;
     }
 
-    PyObject *cr_origin = MAKE_TUPLE_EMPTY(tstate, frame_count);
+    PyObject *cr_origin = MAKE_TUPLE_EMPTY_VAR(tstate, frame_count);
 
     frame = PyEval_GetFrame();
 
@@ -1435,7 +1433,7 @@ PyObject *Nuitka_Coroutine_New(PyThreadState *tstate, coroutine_code code, PyObj
     Py_ssize_t full_size = closure_given + (heap_storage_size + sizeof(void *) - 1) / sizeof(void *);
 
     // Macro to assign result memory from GC or free list.
-    allocateFromFreeList(free_list_coros, struct Nuitka_CoroutineObject, Nuitka_Coroutine_Type, full_size);
+    allocateFromFreeList(free_list_coroutines, struct Nuitka_CoroutineObject, Nuitka_Coroutine_Type, full_size);
 
     // For quicker access of generator heap.
     result->m_heap_storage = &result->m_closure[closure_given];