Nuitka-winsvc 1.8__cp311-cp311-win_amd64.whl → 2.5.1__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__
@@ -23,21 +7,6 @@
 
 /* WARNING, this code is GENERATED. Modify the template HelperDictionaryCopy.c.j2 instead! */
 
-// Usable fraction of keys.
-#define DK_USABLE_FRACTION(n) (((n) << 1) / 3)
-
-#if PYTHON_VERSION < 0x3b0
-typedef PyObject *PyDictValues;
-#endif
-
-#if PYTHON_VERSION < 0x360
-#define DK_ENTRIES_SIZE(keys) (keys->dk_size)
-#elif PYTHON_VERSION < 0x3b0
-#define DK_ENTRIES_SIZE(keys) DK_USABLE_FRACTION(DK_SIZE(keys))
-#else
-#define DK_ENTRIES_SIZE(keys) (keys->dk_nentries)
-#endif
-
 // More than 2/3 of the keys are used, i.e. no space is wasted.
 #if PYTHON_VERSION < 0x360
 #define IS_COMPACT(dict_mp) (dict_mp->ma_used >= (dict_mp->ma_keys->dk_size * 2) / 3)
@@ -49,12 +18,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,56 +34,7 @@ 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) {
-    PyDictObject *result_mp;
-
-#if NUITKA_DICT_HAS_FREELIST
-    struct _Py_dict_state *state = _Nuitka_Py_get_dict_state();
-
-    if (state->numfree) {
-        result_mp = state->free_list[--state->numfree];
-
-        Nuitka_Py_NewReference((PyObject *)result_mp);
-
-        assert(PyDict_CheckExact((PyObject *)result_mp));
-        assert(result_mp != NULL);
-    } else
-#endif
-    {
-        result_mp = (PyDictObject *)Nuitka_GC_New(&PyDict_Type);
-    }
-
-    return result_mp;
-}
-#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
-    return sizeof(PyDictKeysObject) + (DK_SIZE(keys) - 1) * sizeof(PyDictKeyEntry);
-#elif PYTHON_VERSION < 0x370
-    return (sizeof(PyDictKeysObject) - Py_MEMBER_SIZE(PyDictKeysObject, dk_indices) + DK_IXSIZE(keys) * DK_SIZE(keys) +
-            DK_USABLE_FRACTION(DK_SIZE(keys)) * sizeof(PyDictKeyEntry));
-#elif PYTHON_VERSION < 0x3b0
-    return (sizeof(PyDictKeysObject) + DK_IXSIZE(keys) * DK_SIZE(keys) +
-            DK_USABLE_FRACTION(DK_SIZE(keys)) * sizeof(PyDictKeyEntry));
-#else
-    size_t entry_size = keys->dk_kind == DICT_KEYS_GENERAL ? sizeof(PyDictKeyEntry) : sizeof(PyDictUnicodeEntry);
-    return (sizeof(PyDictKeysObject) + ((size_t)1 << keys->dk_log2_index_bytes) +
-            DK_USABLE_FRACTION(DK_SIZE(keys)) * entry_size);
-#endif
-}
-#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 +47,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,27 +64,26 @@ 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);
             }
         }
 #else
         /* 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;
@@ -191,7 +110,6 @@ PyObject *DICT_COPY(PyObject *dict_value) {
 
             Nuitka_GC_Track(result_mp);
         } else
-#endif
 #if PYTHON_VERSION >= 0x360
             // Fast dictionary copy if it has at least 2/3 space usage. This is most relevant
             // for the DICT_COPY, where it might even be the intention to trigger a shrink with
@@ -200,14 +118,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 +195,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 +241,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 +258,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 +276,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);
@@ -349,21 +284,20 @@ PyObject *DEEP_COPY_DICT(PyThreadState *tstate, PyObject *dict_value) {
         }
 #else
         /* 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;
@@ -390,7 +324,6 @@ PyObject *DEEP_COPY_DICT(PyThreadState *tstate, PyObject *dict_value) {
 
             Nuitka_GC_Track(result_mp);
         } else
-#endif
 #if PYTHON_VERSION >= 0x360
             // Fast dictionary copy if it has at least 2/3 space usage. This is most relevant
             // for the DICT_COPY, where it might even be the intention to trigger a shrink with
@@ -399,14 +332,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 +411,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 +460,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 +468,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 +483,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,20 +503,20 @@ 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);
             }
         }
 #else
         /* 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 +526,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 +546,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;
@@ -606,7 +573,6 @@ static PyObject *COPY_DICT_KW(PyObject *dict_value) {
 
             Nuitka_GC_Track(result_mp);
         } else
-#endif
 #if PYTHON_VERSION >= 0x360
             // Fast dictionary copy if it has at least 2/3 space usage. This is most relevant
             // for the DICT_COPY, where it might even be the intention to trigger a shrink with
@@ -615,14 +581,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 +641,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 +665,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 +717,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.