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

nuitka/build/static_src/HelpersDictionariesGenerated.c

@@ -1,20 +1,4 @@
-//     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
 
 /* This file is included from another C file, help IDEs to still parse it on its own. */
 #ifdef __IDE_ONLY__
@@ -49,12 +33,12 @@ static inline PyDictValues *_Nuitka_PyDict_new_values(Py_ssize_t size) {
     Py_ssize_t values_size = sizeof(PyObject *) * size;
 
 #if PYTHON_VERSION < 0x3b0
-    return (PyDictValues *)PyMem_MALLOC(values_size);
+    return (PyDictValues *)NuitkaMem_Malloc(values_size);
 #else
     // With Python3.11 or higher a prefix is allocated too.
     size_t prefix_size = _Py_SIZE_ROUND_UP(size + 2, sizeof(PyObject *));
     size_t n = prefix_size + values_size;
-    uint8_t *mem = (uint8_t *)PyMem_MALLOC(n);
+    uint8_t *mem = (uint8_t *)NuitkaMem_Malloc(n);
 
     assert(mem != NULL);
 
@@ -65,22 +49,26 @@ static inline PyDictValues *_Nuitka_PyDict_new_values(Py_ssize_t size) {
 #endif
 }
 
-#if NUITKA_DICT_HAS_FREELIST
-static struct _Py_dict_state *_Nuitka_Py_get_dict_state(void) {
-    PyInterpreterState *interp = _PyInterpreterState_GET();
-    return &interp->dict_state;
-}
-#endif
-
 #if PYTHON_VERSION >= 0x300
-static PyDictObject *_Nuitka_AllocatePyDictObject(void) {
+static PyDictObject *_Nuitka_AllocatePyDictObject(PyThreadState *tstate) {
     PyDictObject *result_mp;
 
 #if NUITKA_DICT_HAS_FREELIST
-    struct _Py_dict_state *state = _Nuitka_Py_get_dict_state();
+    // This is the CPython name, spell-checker: ignore numfree
+
+#if PYTHON_VERSION < 0x3d0
+    PyDictObject **items = tstate->interp->dict_state.free_list;
+    int *numfree = &tstate->interp->dict_state.numfree;
+#else
+    struct _Py_object_freelists *freelists = _Nuitka_object_freelists_GET(tstate);
+    struct _Py_dict_freelist *state = &freelists->dicts;
+    PyDictObject **items = state->items;
+    int *numfree = &state->numfree;
+#endif
 
-    if (state->numfree) {
-        result_mp = state->free_list[--state->numfree];
+    if (*numfree) {
+        (*numfree) -= 1;
+        result_mp = items[*numfree];
 
         Nuitka_Py_NewReference((PyObject *)result_mp);
 
@@ -96,6 +84,38 @@ static PyDictObject *_Nuitka_AllocatePyDictObject(void) {
 }
 #endif
 
+#if PYTHON_VERSION >= 0x360
+static PyDictKeysObject *_Nuitka_AllocatePyDictKeysObject(PyThreadState *tstate, Py_ssize_t keys_size) {
+    // CPython names, spell-checker: ignore numfree,dictkeys
+    PyDictKeysObject *dk;
+
+// TODO: Cannot always use cached objects. Need to also consider
+// "log2_size == PyDict_LOG_MINSIZE && unicode" as a criterion,
+// seems it can only be used for the smallest keys type.
+#if NUITKA_DICT_HAS_FREELIST && 0
+#if PYTHON_VERSION < 0x3d0
+    PyDictKeysObject **items = tstate->interp->dict_state.keys_free_list;
+    int *numfree = &tstate->interp->dict_state.keys_numfree;
+#else
+    struct _Py_object_freelists *freelists = _Nuitka_object_freelists_GET(tstate);
+    struct _Py_dictkeys_freelist *state = &freelists->dictkeys;
+    PyDictKeysObject **items = state->items;
+    int *numfree = &state->numfree;
+#endif
+
+    if (*numfree) {
+        (*numfree) -= 1;
+        dk = items[*numfree];
+    } else
+#endif
+    {
+        dk = (PyDictKeysObject *)NuitkaObject_Malloc(keys_size);
+    }
+
+    return dk;
+}
+#endif
+
 #if PYTHON_VERSION >= 0x360 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_DICT_OPT)
 static Py_ssize_t _Nuitka_Py_PyDict_KeysSize(PyDictKeysObject *keys) {
 #if PYTHON_VERSION < 0x360
@@ -114,7 +134,7 @@ static Py_ssize_t _Nuitka_Py_PyDict_KeysSize(PyDictKeysObject *keys) {
 }
 #endif
 
-PyObject *DICT_COPY(PyObject *dict_value) {
+PyObject *DICT_COPY(PyThreadState *tstate, PyObject *dict_value) {
 #if _NUITKA_EXPERIMENTAL_DISABLE_DICT_OPT
     CHECK_OBJECT(dict_value);
     assert(PyDict_CheckExact(dict_value));
@@ -127,7 +147,7 @@ PyObject *DICT_COPY(PyObject *dict_value) {
     assert(PyDict_CheckExact(dict_value));
 
     if (((PyDictObject *)dict_value)->ma_used == 0) {
-        result = MAKE_DICT_EMPTY();
+        result = MAKE_DICT_EMPTY(tstate);
     } else {
         PyDictObject *dict_mp = (PyDictObject *)dict_value;
 
@@ -144,7 +164,7 @@ PyObject *DICT_COPY(PyObject *dict_value) {
 
                 PyObject *value = entry->me_value;
 
-                int res = PyDict_SetItem(result, key, value);
+                NUITKA_MAY_BE_UNUSED int res = PyDict_SetItem(result, key, value);
                 assert(res == 0);
             }
         }
@@ -152,19 +172,19 @@ PyObject *DICT_COPY(PyObject *dict_value) {
         /* Python 3 */
 #ifndef PY_NOGIL
         if (_PyDict_HasSplitTable(dict_mp)) {
-            Py_ssize_t size = DK_ENTRIES_SIZE(dict_mp->ma_keys);
-
-            PyDictObject *result_mp = _Nuitka_AllocatePyDictObject();
+            PyDictObject *result_mp = _Nuitka_AllocatePyDictObject(tstate);
             assert(result_mp != NULL);
             result = (PyObject *)result_mp;
 
+            Py_ssize_t size = DK_ENTRIES_SIZE(dict_mp->ma_keys);
+
             PyDictValues *new_values = _Nuitka_PyDict_new_values(size);
             assert(new_values != NULL);
 
 #if PYTHON_VERSION >= 0x3b0
             // Need to preserve values prefix.
             size_t prefix_size = ((uint8_t *)new_values)[-1];
-            memcpy(((char *)new_values) - prefix_size, ((char *)dict_mp->ma_values) - prefix_size, prefix_size - 1);
+            memcpy((char *)new_values - prefix_size, (char *)dict_mp->ma_values - prefix_size, prefix_size - 1);
 #endif
 
             result_mp->ma_values = new_values;
@@ -200,14 +220,14 @@ PyObject *DICT_COPY(PyObject *dict_value) {
                 assert(dict_mp->ma_values == NULL);
                 assert(dict_mp->ma_keys->dk_refcnt == 1);
 
-                PyDictObject *result_mp = _Nuitka_AllocatePyDictObject();
+                PyDictObject *result_mp = _Nuitka_AllocatePyDictObject(tstate);
                 result = (PyObject *)result_mp;
 
                 result_mp->ma_values = NULL;
                 result_mp->ma_used = dict_mp->ma_used;
 
                 Py_ssize_t keys_size = _Nuitka_Py_PyDict_KeysSize(dict_mp->ma_keys);
-                result_mp->ma_keys = (PyDictKeysObject *)PyObject_MALLOC(keys_size);
+                result_mp->ma_keys = _Nuitka_AllocatePyDictKeysObject(tstate, keys_size);
                 assert(result_mp->ma_keys);
 
                 memcpy(result_mp->ma_keys, dict_mp->ma_keys, keys_size);
@@ -277,20 +297,37 @@ PyObject *DICT_COPY(PyObject *dict_value) {
             {
                 result = _PyDict_NewPresized(dict_mp->ma_used);
 
+#if PYTHON_VERSION < 0x3b0
                 Py_ssize_t size = DK_ENTRIES_SIZE(dict_mp->ma_keys);
 
                 for (Py_ssize_t i = 0; i < size; i++) {
                     PyDictKeyEntry *entry = &DK_ENTRIES(dict_mp->ma_keys)[i];
+                    PyObject *value = entry->me_value;
 
-                    if (entry->me_value != NULL) {
+                    if (value != NULL) {
                         PyObject *key = entry->me_key;
+                        CHECK_OBJECT(key);
 
-                        PyObject *value = entry->me_value;
+                        CHECK_OBJECT(value);
 
-                        int res = PyDict_SetItem(result, key, value);
+                        NUITKA_MAY_BE_UNUSED int res = PyDict_SetItem(result, key, value);
                         assert(res == 0);
                     }
                 }
+#else
+            Py_ssize_t pos = 0;
+            PyObject *key, *value;
+
+            while (Nuitka_DictNext((PyObject *)dict_mp, &pos, &key, &value)) {
+                CHECK_OBJECT(key);
+                CHECK_OBJECT(value);
+
+                CHECK_OBJECT(value);
+
+                NUITKA_MAY_BE_UNUSED int res = PyDict_SetItem(result, key, value);
+                assert(res == 0);
+            }
+#endif
             }
 #endif
     }
@@ -306,7 +343,7 @@ PyObject *DEEP_COPY_DICT(PyThreadState *tstate, PyObject *dict_value) {
     CHECK_OBJECT(dict_value);
     assert(PyDict_CheckExact(dict_value));
 
-    result = DICT_COPY(dict_value);
+    result = DICT_COPY(tstate, dict_value);
 
     Py_ssize_t pos = 0;
     PyObject *key, *value;
@@ -323,7 +360,7 @@ PyObject *DEEP_COPY_DICT(PyThreadState *tstate, PyObject *dict_value) {
     assert(PyDict_CheckExact(dict_value));
 
     if (((PyDictObject *)dict_value)->ma_used == 0) {
-        result = MAKE_DICT_EMPTY();
+        result = MAKE_DICT_EMPTY(tstate);
     } else {
         PyDictObject *dict_mp = (PyDictObject *)dict_value;
 
@@ -341,7 +378,7 @@ PyObject *DEEP_COPY_DICT(PyThreadState *tstate, PyObject *dict_value) {
                 PyObject *value = entry->me_value;
                 value = DEEP_COPY(tstate, value);
 
-                int res = PyDict_SetItem(result, key, value);
+                NUITKA_MAY_BE_UNUSED int res = PyDict_SetItem(result, key, value);
                 assert(res == 0);
 
                 Py_DECREF(value);
@@ -351,19 +388,19 @@ PyObject *DEEP_COPY_DICT(PyThreadState *tstate, PyObject *dict_value) {
         /* Python 3 */
 #ifndef PY_NOGIL
         if (_PyDict_HasSplitTable(dict_mp)) {
-            Py_ssize_t size = DK_ENTRIES_SIZE(dict_mp->ma_keys);
-
-            PyDictObject *result_mp = _Nuitka_AllocatePyDictObject();
+            PyDictObject *result_mp = _Nuitka_AllocatePyDictObject(tstate);
             assert(result_mp != NULL);
             result = (PyObject *)result_mp;
 
+            Py_ssize_t size = DK_ENTRIES_SIZE(dict_mp->ma_keys);
+
             PyDictValues *new_values = _Nuitka_PyDict_new_values(size);
             assert(new_values != NULL);
 
 #if PYTHON_VERSION >= 0x3b0
             // Need to preserve values prefix.
             size_t prefix_size = ((uint8_t *)new_values)[-1];
-            memcpy(((char *)new_values) - prefix_size, ((char *)dict_mp->ma_values) - prefix_size, prefix_size - 1);
+            memcpy((char *)new_values - prefix_size, (char *)dict_mp->ma_values - prefix_size, prefix_size - 1);
 #endif
 
             result_mp->ma_values = new_values;
@@ -399,14 +436,14 @@ PyObject *DEEP_COPY_DICT(PyThreadState *tstate, PyObject *dict_value) {
                 assert(dict_mp->ma_values == NULL);
                 assert(dict_mp->ma_keys->dk_refcnt == 1);
 
-                PyDictObject *result_mp = _Nuitka_AllocatePyDictObject();
+                PyDictObject *result_mp = _Nuitka_AllocatePyDictObject(tstate);
                 result = (PyObject *)result_mp;
 
                 result_mp->ma_values = NULL;
                 result_mp->ma_used = dict_mp->ma_used;
 
                 Py_ssize_t keys_size = _Nuitka_Py_PyDict_KeysSize(dict_mp->ma_keys);
-                result_mp->ma_keys = (PyDictKeysObject *)PyObject_MALLOC(keys_size);
+                result_mp->ma_keys = _Nuitka_AllocatePyDictKeysObject(tstate, keys_size);
                 assert(result_mp->ma_keys);
 
                 memcpy(result_mp->ma_keys, dict_mp->ma_keys, keys_size);
@@ -478,23 +515,45 @@ PyObject *DEEP_COPY_DICT(PyThreadState *tstate, PyObject *dict_value) {
             {
                 result = _PyDict_NewPresized(dict_mp->ma_used);
 
+#if PYTHON_VERSION < 0x3b0
                 Py_ssize_t size = DK_ENTRIES_SIZE(dict_mp->ma_keys);
 
                 for (Py_ssize_t i = 0; i < size; i++) {
                     PyDictKeyEntry *entry = &DK_ENTRIES(dict_mp->ma_keys)[i];
+                    PyObject *value = entry->me_value;
 
-                    if (entry->me_value != NULL) {
+                    if (value != NULL) {
                         PyObject *key = entry->me_key;
+                        CHECK_OBJECT(key);
+
+                        CHECK_OBJECT(value);
 
-                        PyObject *value = entry->me_value;
                         value = DEEP_COPY(tstate, value);
 
-                        int res = PyDict_SetItem(result, key, value);
+                        NUITKA_MAY_BE_UNUSED int res = PyDict_SetItem(result, key, value);
                         assert(res == 0);
 
                         Py_DECREF(value);
                     }
                 }
+#else
+            Py_ssize_t pos = 0;
+            PyObject *key, *value;
+
+            while (Nuitka_DictNext((PyObject *)dict_mp, &pos, &key, &value)) {
+                CHECK_OBJECT(key);
+                CHECK_OBJECT(value);
+
+                CHECK_OBJECT(value);
+
+                value = DEEP_COPY(tstate, value);
+
+                NUITKA_MAY_BE_UNUSED int res = PyDict_SetItem(result, key, value);
+                assert(res == 0);
+
+                Py_DECREF(value);
+            }
+#endif
             }
 #endif
     }
@@ -505,7 +564,7 @@ PyObject *DEEP_COPY_DICT(PyThreadState *tstate, PyObject *dict_value) {
 }
 
 // Helper for function calls with star dict arguments. */
-static PyObject *COPY_DICT_KW(PyObject *dict_value) {
+static PyObject *COPY_DICT_KW(PyThreadState *tstate, PyObject *dict_value) {
     PyObject *result;
     bool had_kw_error = false;
 
@@ -513,7 +572,7 @@ static PyObject *COPY_DICT_KW(PyObject *dict_value) {
     CHECK_OBJECT(dict_value);
     assert(PyDict_CheckExact(dict_value));
 
-    result = DICT_COPY(dict_value);
+    result = DICT_COPY(tstate, dict_value);
 
     Py_ssize_t pos = 0;
     PyObject *key, *value;
@@ -528,7 +587,7 @@ static PyObject *COPY_DICT_KW(PyObject *dict_value) {
     assert(PyDict_CheckExact(dict_value));
 
     if (((PyDictObject *)dict_value)->ma_used == 0) {
-        result = MAKE_DICT_EMPTY();
+        result = MAKE_DICT_EMPTY(tstate);
     } else {
         PyDictObject *dict_mp = (PyDictObject *)dict_value;
 
@@ -548,7 +607,7 @@ static PyObject *COPY_DICT_KW(PyObject *dict_value) {
 
                 PyObject *value = entry->me_value;
 
-                int res = PyDict_SetItem(result, key, value);
+                NUITKA_MAY_BE_UNUSED int res = PyDict_SetItem(result, key, value);
                 assert(res == 0);
             }
         }
@@ -556,12 +615,13 @@ static PyObject *COPY_DICT_KW(PyObject *dict_value) {
         /* Python 3 */
 #ifndef PY_NOGIL
         if (_PyDict_HasSplitTable(dict_mp)) {
-            Py_ssize_t size = DK_ENTRIES_SIZE(dict_mp->ma_keys);
-
-            PyDictObject *result_mp = _Nuitka_AllocatePyDictObject();
+            PyDictObject *result_mp = _Nuitka_AllocatePyDictObject(tstate);
             assert(result_mp != NULL);
             result = (PyObject *)result_mp;
 
+            Py_ssize_t size = DK_ENTRIES_SIZE(dict_mp->ma_keys);
+
+#if PYTHON_VERSION < 0x3b0
             for (Py_ssize_t i = 0; i < size; i++) {
                 PyDictKeyEntry *entry = &DK_ENTRIES(dict_mp->ma_keys)[i];
 
@@ -571,6 +631,18 @@ static PyObject *COPY_DICT_KW(PyObject *dict_value) {
                         had_kw_error = true;
                     }
                 }
+#else
+            Py_ssize_t pos = 0;
+            PyObject *key, *_value;
+
+            while (Nuitka_DictNext((PyObject *)dict_mp, &pos, &key, &_value)) {
+                CHECK_OBJECT(key);
+                CHECK_OBJECT(_value);
+
+                if (unlikely(!checkKeywordType(key))) {
+                    had_kw_error = true;
+                }
+#endif
             }
 
             PyDictValues *new_values = _Nuitka_PyDict_new_values(size);
@@ -579,7 +651,7 @@ static PyObject *COPY_DICT_KW(PyObject *dict_value) {
 #if PYTHON_VERSION >= 0x3b0
             // Need to preserve values prefix.
             size_t prefix_size = ((uint8_t *)new_values)[-1];
-            memcpy(((char *)new_values) - prefix_size, ((char *)dict_mp->ma_values) - prefix_size, prefix_size - 1);
+            memcpy((char *)new_values - prefix_size, (char *)dict_mp->ma_values - prefix_size, prefix_size - 1);
 #endif
 
             result_mp->ma_values = new_values;
@@ -615,14 +687,14 @@ static PyObject *COPY_DICT_KW(PyObject *dict_value) {
                 assert(dict_mp->ma_values == NULL);
                 assert(dict_mp->ma_keys->dk_refcnt == 1);
 
-                PyDictObject *result_mp = _Nuitka_AllocatePyDictObject();
+                PyDictObject *result_mp = _Nuitka_AllocatePyDictObject(tstate);
                 result = (PyObject *)result_mp;
 
                 result_mp->ma_values = NULL;
                 result_mp->ma_used = dict_mp->ma_used;
 
                 Py_ssize_t keys_size = _Nuitka_Py_PyDict_KeysSize(dict_mp->ma_keys);
-                result_mp->ma_keys = (PyDictKeysObject *)PyObject_MALLOC(keys_size);
+                result_mp->ma_keys = _Nuitka_AllocatePyDictKeysObject(tstate, keys_size);
                 assert(result_mp->ma_keys);
 
                 memcpy(result_mp->ma_keys, dict_mp->ma_keys, keys_size);
@@ -675,7 +747,7 @@ static PyObject *COPY_DICT_KW(PyObject *dict_value) {
 
                         Py_INCREF(value);
                         PyObject *key = *key_ptr;
-                        if (is_unicode) {
+                        if (is_unicode == false) {
                             if (unlikely(!checkKeywordType(key))) {
                                 had_kw_error = true;
                             }
@@ -699,23 +771,45 @@ static PyObject *COPY_DICT_KW(PyObject *dict_value) {
             {
                 result = _PyDict_NewPresized(dict_mp->ma_used);
 
+#if PYTHON_VERSION < 0x3b0
                 Py_ssize_t size = DK_ENTRIES_SIZE(dict_mp->ma_keys);
 
                 for (Py_ssize_t i = 0; i < size; i++) {
                     PyDictKeyEntry *entry = &DK_ENTRIES(dict_mp->ma_keys)[i];
+                    PyObject *value = entry->me_value;
 
-                    if (entry->me_value != NULL) {
+                    if (value != NULL) {
                         PyObject *key = entry->me_key;
+                        CHECK_OBJECT(key);
+
                         if (unlikely(!checkKeywordType(key))) {
                             had_kw_error = true;
                         }
 
-                        PyObject *value = entry->me_value;
+                        CHECK_OBJECT(value);
 
-                        int res = PyDict_SetItem(result, key, value);
+                        NUITKA_MAY_BE_UNUSED int res = PyDict_SetItem(result, key, value);
                         assert(res == 0);
                     }
                 }
+#else
+            Py_ssize_t pos = 0;
+            PyObject *key, *value;
+
+            while (Nuitka_DictNext((PyObject *)dict_mp, &pos, &key, &value)) {
+                CHECK_OBJECT(key);
+                CHECK_OBJECT(value);
+
+                if (unlikely(!checkKeywordType(key))) {
+                    had_kw_error = true;
+                }
+
+                CHECK_OBJECT(value);
+
+                NUITKA_MAY_BE_UNUSED int res = PyDict_SetItem(result, key, value);
+                assert(res == 0);
+            }
+#endif
             }
 #endif
     }
@@ -729,3 +823,18 @@ static PyObject *COPY_DICT_KW(PyObject *dict_value) {
 
     return result;
 }
+
+//     Part of "Nuitka", an optimizing Python compiler that is compatible and
+//     integrates with CPython, but also works on its own.
+//
+//     Licensed under the Apache License, Version 2.0 (the "License");
+//     you may not use this file except in compliance with the License.
+//     You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//     Unless required by applicable law or agreed to in writing, software
+//     distributed under the License is distributed on an "AS IS" BASIS,
+//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//     See the License for the specific language governing permissions and
+//     limitations under the License.

nuitka/build/static_src/HelpersDumpBacktraces.c

@@ -0,0 +1,63 @@
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+/* These helpers are used to report C backtraces */
+
+#include "backtrace/backtrace.h"
+
+static struct backtrace_state *our_backtrace_state = NULL;
+
+void INIT_C_BACKTRACES(void) {
+    our_backtrace_state = backtrace_create_state(NULL, 1, NULL, NULL);
+    assert(our_backtrace_state != NULL);
+}
+
+static int bt_frame_count = 0;
+
+static int ourBacktraceFullCallback(void *data, uintptr_t pc, const char *filename, int lineno, const char *function) {
+    if (strcmp(function, "DUMP_C_BACKTRACE") != 0) {
+        fprintf(stderr, "#%d %s:%d %s\n", bt_frame_count, filename, lineno, function);
+        bt_frame_count += 1;
+    }
+
+    if (strcmp(function, "main") == 0) {
+        return 1;
+    }
+
+    return 0;
+}
+
+void DUMP_C_BACKTRACE(void) {
+    assert(our_backtrace_state != NULL);
+
+    bt_frame_count = 0;
+    backtrace_full(our_backtrace_state, 0, ourBacktraceFullCallback, NULL, NULL);
+}
+
+#include "backtrace/backtrace.c"
+#include "backtrace/dwarf.c"
+#if !defined(_WIN32)
+#include "backtrace/elf.c"
+#include "backtrace/mmap.c"
+#else
+#include "backtrace/alloc.c"
+#include "backtrace/pecoff.c"
+#endif
+#include "backtrace/fileline.c"
+#include "backtrace/posix.c"
+#include "backtrace/read.c"
+#include "backtrace/sort.c"
+#include "backtrace/state.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.

nuitka/build/static_src/HelpersEnvironmentVariables.c

@@ -0,0 +1,65 @@
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+// Helpers for working with environment variables from Python binary in a
+// portable way.
+
+#include "nuitka/environment_variables.h"
+
+#include "HelpersEnvironmentVariablesSystem.c"
+
+void undoEnvironmentVariable(PyThreadState *tstate, char const *variable_name, environment_char_t const *old_value) {
+    PyObject *os_module = IMPORT_HARD_OS();
+    CHECK_OBJECT(os_module);
+
+    PyObject *os_environ = PyObject_GetAttrString(os_module, "environ");
+    CHECK_OBJECT(os_environ);
+
+    PyObject *variable_name_str = Nuitka_String_FromString(variable_name);
+    CHECK_OBJECT(variable_name_str);
+
+    if (old_value) {
+        setEnvironmentVariable(variable_name, old_value);
+
+#ifdef _WIN32
+        PyObject *env_value = NuitkaUnicode_FromWideChar(old_value, -1);
+#else
+        PyObject *env_value = Nuitka_String_FromString(old_value);
+#endif
+        CHECK_OBJECT(env_value);
+
+        int res = PyObject_SetItem(os_environ, variable_name_str, env_value);
+
+        if (unlikely(res != 0)) {
+            PyErr_PrintEx(1);
+            Py_Exit(1);
+        }
+
+        Py_DECREF(env_value);
+    } else {
+        unsetEnvironmentVariable(variable_name);
+
+        int res = PyObject_DelItem(os_environ, variable_name_str);
+
+        if (unlikely(res != 0)) {
+            CLEAR_ERROR_OCCURRED(tstate);
+        }
+    }
+
+    Py_DECREF(variable_name_str);
+    Py_DECREF(os_environ);
+}
+
+//     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.