Nuitka-winsvc 1.8.6__cp312-cp312-win_amd64.whl → 1.9.3__cp312-cp312-win_amd64.whl

nuitka/build/static_src/CompiledGeneratorType.c

@@ -28,6 +28,7 @@
 /* This file is included from another C file, help IDEs to still parse it on its own. */
 #ifdef __IDE_ONLY__
 #include "nuitka/prelude.h"
+#include <structmember.h>
 #endif
 
 // In a separate file, code to interact with uncompiled generators, that does
@@ -132,7 +133,7 @@ static long Nuitka_Generator_tp_traverse(struct Nuitka_GeneratorObject *generato
 
     // TODO: Identify the impact of not visiting owned objects like module.
 #if PYTHON_VERSION >= 0x300
-    Py_VISIT(generator->m_yieldfrom);
+    Py_VISIT(generator->m_yield_from);
 #endif
 
     for (Py_ssize_t i = 0; i < generator->m_closure_given; i++) {
@@ -297,12 +298,12 @@ static PyObject *_Nuitka_YieldFromPassExceptionTo(PyThreadState *tstate, PyObjec
 }
 
 static PyObject *_Nuitka_YieldFromGeneratorCore(PyThreadState *tstate, struct Nuitka_GeneratorObject *generator,
-                                                PyObject *yieldfrom, PyObject *send_value) {
+                                                PyObject *yield_from, PyObject *send_value) {
     // Send iteration value to the sub-generator, which may be a CPython
     // generator object, something with an iterator next, or a send method,
     // where the later is only required if values other than "None" need to
     // be passed in.
-    CHECK_OBJECT(yieldfrom);
+    CHECK_OBJECT(yield_from);
     assert(send_value != NULL || HAS_ERROR_OCCURRED(tstate));
 
     PyObject *retval;
@@ -322,7 +323,7 @@ static PyObject *_Nuitka_YieldFromGeneratorCore(PyThreadState *tstate, struct Nu
     // Exception, was thrown into us, need to send that to sub-generator.
     if (exception_type != NULL) {
         // Passing ownership of exception fetch to it.
-        retval = _Nuitka_YieldFromPassExceptionTo(tstate, yieldfrom, exception_type, exception_value, exception_tb);
+        retval = _Nuitka_YieldFromPassExceptionTo(tstate, yield_from, exception_type, exception_value, exception_tb);
 
         // TODO: This wants to look at retval most definitely, send_value is going to be NULL.
         if (unlikely(send_value == NULL)) {
@@ -335,23 +336,23 @@ static PyObject *_Nuitka_YieldFromGeneratorCore(PyThreadState *tstate, struct Nu
                 return NULL;
             }
         }
-    } else if (PyGen_CheckExact(yieldfrom)) {
-        retval = Nuitka_PyGen_Send(tstate, (PyGenObject *)yieldfrom, Py_None);
+    } else if (PyGen_CheckExact(yield_from)) {
+        retval = Nuitka_PyGen_Send(tstate, (PyGenObject *)yield_from, Py_None);
     }
 #if PYTHON_VERSION >= 0x350
-    else if (PyCoro_CheckExact(yieldfrom)) {
-        retval = Nuitka_PyGen_Send(tstate, (PyGenObject *)yieldfrom, Py_None);
+    else if (PyCoro_CheckExact(yield_from)) {
+        retval = Nuitka_PyGen_Send(tstate, (PyGenObject *)yield_from, Py_None);
     }
 #endif
-    else if (send_value == Py_None && Py_TYPE(yieldfrom)->tp_iternext != NULL) {
-        retval = Py_TYPE(yieldfrom)->tp_iternext(yieldfrom);
+    else if (send_value == Py_None && Py_TYPE(yield_from)->tp_iternext != NULL) {
+        retval = Py_TYPE(yield_from)->tp_iternext(yield_from);
     } else {
         // Bug compatibility here, before 3.3 tuples were unrolled in calls, which is what
         // PyObject_CallMethod does.
 #if PYTHON_VERSION >= 0x340
-        retval = PyObject_CallMethodObjArgs(yieldfrom, const_str_plain_send, send_value, NULL);
+        retval = PyObject_CallMethodObjArgs(yield_from, const_str_plain_send, send_value, NULL);
 #else
-        retval = PyObject_CallMethod(yieldfrom, (char *)"send", (char *)"O", send_value);
+        retval = PyObject_CallMethod(yield_from, (char *)"send", (char *)"O", send_value);
 #endif
     }
 
@@ -382,15 +383,15 @@ static PyObject *Nuitka_YieldFromGeneratorCore(PyThreadState *tstate, struct Nui
     CHECK_OBJECT(generator);
     CHECK_OBJECT_X(send_value);
 
-    PyObject *yieldfrom = generator->m_yieldfrom;
-    CHECK_OBJECT(yieldfrom);
+    PyObject *yield_from = generator->m_yield_from;
+    CHECK_OBJECT(yield_from);
 
     // Need to make it unaccessible while using it.
-    generator->m_yieldfrom = NULL;
-    PyObject *yielded = _Nuitka_YieldFromGeneratorCore(tstate, generator, yieldfrom, send_value);
+    generator->m_yield_from = NULL;
+    PyObject *yielded = _Nuitka_YieldFromGeneratorCore(tstate, generator, yield_from, send_value);
 
     if (yielded == NULL) {
-        Py_DECREF(yieldfrom);
+        Py_DECREF(yield_from);
 
         if (generator->m_returned != NULL) {
             PyObject *yield_from_result = generator->m_returned;
@@ -403,7 +404,7 @@ static PyObject *Nuitka_YieldFromGeneratorCore(PyThreadState *tstate, struct Nui
         }
 
     } else {
-        generator->m_yieldfrom = yieldfrom;
+        generator->m_yield_from = yield_from;
     }
 
     return yielded;
@@ -414,7 +415,7 @@ static PyObject *Nuitka_YieldFromGeneratorNext(PyThreadState *tstate, struct Nui
 
     // Coroutines are already perfect for yielding from.
 #if PYTHON_VERSION >= 0x350
-    if (PyCoro_CheckExact(generator->m_yieldfrom) || Nuitka_Coroutine_Check(generator->m_yieldfrom)) {
+    if (PyCoro_CheckExact(generator->m_yield_from) || Nuitka_Coroutine_Check(generator->m_yield_from)) {
         if (unlikely((generator->m_code_object->co_flags & CO_ITERABLE_COROUTINE) == 0)) {
             SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError,
                                             "cannot 'yield from' a coroutine object in a non-coroutine generator");
@@ -422,10 +423,10 @@ static PyObject *Nuitka_YieldFromGeneratorNext(PyThreadState *tstate, struct Nui
     } else
 #endif
     {
-        PyObject *new_iterator = MAKE_ITERATOR(tstate, generator->m_yieldfrom);
+        PyObject *new_iterator = MAKE_ITERATOR(tstate, generator->m_yield_from);
         if (new_iterator != NULL) {
-            Py_DECREF(generator->m_yieldfrom);
-            generator->m_yieldfrom = new_iterator;
+            Py_DECREF(generator->m_yield_from);
+            generator->m_yield_from = new_iterator;
         }
     }
 
@@ -539,7 +540,7 @@ static PyObject *_Nuitka_Generator_send(PyThreadState *tstate, struct Nuitka_Gen
         PyObject *yielded;
 
 #if PYTHON_VERSION >= 0x300
-        if (generator->m_yieldfrom == NULL) {
+        if (generator->m_yield_from == NULL) {
             yielded = ((generator_code)generator->m_code)(tstate, generator, value);
         } else {
             // This does not release the value if any, so we need to do it afterwards.
@@ -552,9 +553,9 @@ static PyObject *_Nuitka_Generator_send(PyThreadState *tstate, struct Nuitka_Gen
         assert(PyThreadState_GET() == tstate);
 
 #if PYTHON_VERSION >= 0x300
-        // If the generator returns with m_yieldfrom set, it wants us to yield
+        // If the generator returns with m_yield_from set, it wants us to yield
         // from that value from now on.
-        while (yielded == NULL && generator->m_yieldfrom != NULL) {
+        while (yielded == NULL && generator->m_yield_from != NULL) {
             yielded = Nuitka_YieldFromGeneratorNext(tstate, generator);
         }
 #endif
@@ -902,49 +903,49 @@ static bool _Nuitka_Asyncgen_close(PyThreadState *tstate, struct Nuitka_Asyncgen
 #endif
 
 // Note: This is also used for coroutines and asyncgen
-static bool Nuitka_gen_close_iter(PyThreadState *tstate, PyObject *yieldfrom) {
+static bool Nuitka_gen_close_iter(PyThreadState *tstate, PyObject *yield_from) {
 #if _DEBUG_GENERATOR
     PRINT_STRING("Nuitka_gen_close_iter: Enter\n");
 #endif
 
-    CHECK_OBJECT(yieldfrom);
+    CHECK_OBJECT(yield_from);
 
-    // TODO: Could specialize depending in yieldfrom type for performance. Many
+    // TODO: Could specialize depending in yield_from type for performance. Many
     // times these will be our own ones, or known ones like uncompiled
     // generators.
-    if (Nuitka_Generator_Check(yieldfrom)) {
+    if (Nuitka_Generator_Check(yield_from)) {
 #if _DEBUG_GENERATOR
         PRINT_STRING("Nuitka_gen_close_iter: Defer to _Nuitka_Generator_close\n");
 #endif
-        return _Nuitka_Generator_close(tstate, (struct Nuitka_GeneratorObject *)yieldfrom);
+        return _Nuitka_Generator_close(tstate, (struct Nuitka_GeneratorObject *)yield_from);
     }
 
 #if PYTHON_VERSION >= 0x350
-    if (Nuitka_Coroutine_Check(yieldfrom)) {
+    if (Nuitka_Coroutine_Check(yield_from)) {
 #if _DEBUG_GENERATOR
         PRINT_STRING("Nuitka_gen_close_iter: Defer to _Nuitka_Coroutine_close\n");
 #endif
-        return _Nuitka_Coroutine_close(tstate, (struct Nuitka_CoroutineObject *)yieldfrom);
+        return _Nuitka_Coroutine_close(tstate, (struct Nuitka_CoroutineObject *)yield_from);
     }
 #endif
 
 #if PYTHON_VERSION >= 0x360
-    if (Nuitka_Asyncgen_Check(yieldfrom)) {
+    if (Nuitka_Asyncgen_Check(yield_from)) {
 #if _DEBUG_GENERATOR
         PRINT_STRING("Nuitka_gen_close_iter: Defer to _Nuitka_Asyncgen_close\n");
 #endif
-        return _Nuitka_Asyncgen_close(tstate, (struct Nuitka_AsyncgenObject *)yieldfrom);
+        return _Nuitka_Asyncgen_close(tstate, (struct Nuitka_AsyncgenObject *)yield_from);
     }
 #endif
 
-    PyObject *meth = PyObject_GetAttr(yieldfrom, const_str_plain_close);
+    PyObject *meth = PyObject_GetAttr(yield_from, const_str_plain_close);
 
     if (unlikely(meth == NULL)) {
         if (unlikely(!PyErr_ExceptionMatches(PyExc_AttributeError))) {
 #if _DEBUG_GENERATOR
             PRINT_STRING("Nuitka_gen_close_iter: Strange error while looking up close method.\n");
 #endif
-            PyErr_WriteUnraisable(yieldfrom);
+            PyErr_WriteUnraisable(yield_from);
         }
 
         CLEAR_ERROR_OCCURRED(tstate);
@@ -989,7 +990,7 @@ static PyObject *_Nuitka_Generator_throw2(PyThreadState *tstate, struct Nuitka_G
                                           PyTracebackObject *exception_tb) {
 #if _DEBUG_GENERATOR
     PRINT_GENERATOR_STATUS("Enter", generator);
-    PRINT_COROUTINE_VALUE("yieldfrom", generator->m_yieldfrom);
+    PRINT_COROUTINE_VALUE("yield_from", generator->m_yield_from);
     PRINT_EXCEPTION(exception_type, exception_value, exception_tb);
     PRINT_NEW_LINE();
 #endif
@@ -1001,11 +1002,11 @@ static PyObject *_Nuitka_Generator_throw2(PyThreadState *tstate, struct Nuitka_G
     CHECK_OBJECT_X(exception_tb);
 
 #if PYTHON_VERSION >= 0x300
-    if (generator->m_yieldfrom != NULL) {
+    if (generator->m_yield_from != NULL) {
         if (EXCEPTION_MATCH_BOOL_SINGLE(tstate, exception_type, PyExc_GeneratorExit)) {
             // Generators need to close the yield_from.
             Nuitka_MarkGeneratorAsRunning(generator);
-            bool res = Nuitka_gen_close_iter(tstate, generator->m_yieldfrom);
+            bool res = Nuitka_gen_close_iter(tstate, generator->m_yield_from);
             Nuitka_MarkGeneratorAsNotRunning(generator);
 
             if (res == false) {
@@ -1025,19 +1026,19 @@ static PyObject *_Nuitka_Generator_throw2(PyThreadState *tstate, struct Nuitka_G
 
 #if _DEBUG_GENERATOR
         PRINT_GENERATOR_STATUS("Passing to yielded from", generator);
-        PRINT_COROUTINE_VALUE("m_yieldfrom", generator->m_yieldfrom);
+        PRINT_COROUTINE_VALUE("m_yield_from", generator->m_yield_from);
         PRINT_NEW_LINE();
 #endif
 
-        if (Nuitka_Generator_Check(generator->m_yieldfrom)) {
-            struct Nuitka_GeneratorObject *gen = ((struct Nuitka_GeneratorObject *)generator->m_yieldfrom);
+        if (Nuitka_Generator_Check(generator->m_yield_from)) {
+            struct Nuitka_GeneratorObject *gen = ((struct Nuitka_GeneratorObject *)generator->m_yield_from);
             // Transferred exception ownership to "_Nuitka_Generator_throw2".
             Nuitka_MarkGeneratorAsRunning(generator);
             ret = _Nuitka_Generator_throw2(tstate, gen, exception_type, exception_value, exception_tb);
             Nuitka_MarkGeneratorAsNotRunning(generator);
 #if NUITKA_UNCOMPILED_THROW_INTEGRATION
-        } else if (PyGen_CheckExact(generator->m_yieldfrom)) {
-            PyGenObject *gen = (PyGenObject *)generator->m_yieldfrom;
+        } else if (PyGen_CheckExact(generator->m_yield_from)) {
+            PyGenObject *gen = (PyGenObject *)generator->m_yield_from;
 
             // Transferred exception ownership to "Nuitka_UncompiledGenerator_throw".
             Nuitka_MarkGeneratorAsRunning(generator);
@@ -1045,23 +1046,23 @@ static PyObject *_Nuitka_Generator_throw2(PyThreadState *tstate, struct Nuitka_G
             Nuitka_MarkGeneratorAsNotRunning(generator);
 #endif
 #if PYTHON_VERSION >= 0x350
-        } else if (Nuitka_Coroutine_Check(generator->m_yieldfrom)) {
-            struct Nuitka_CoroutineObject *coro = ((struct Nuitka_CoroutineObject *)generator->m_yieldfrom);
+        } else if (Nuitka_Coroutine_Check(generator->m_yield_from)) {
+            struct Nuitka_CoroutineObject *coro = ((struct Nuitka_CoroutineObject *)generator->m_yield_from);
             // Transferred exception ownership to "_Nuitka_Coroutine_throw2".
             Nuitka_MarkGeneratorAsRunning(generator);
             ret = _Nuitka_Coroutine_throw2(tstate, coro, true, exception_type, exception_value, exception_tb);
             Nuitka_MarkGeneratorAsNotRunning(generator);
-        } else if (Nuitka_CoroutineWrapper_Check(generator->m_yieldfrom)) {
+        } else if (Nuitka_CoroutineWrapper_Check(generator->m_yield_from)) {
             struct Nuitka_CoroutineObject *coro =
-                ((struct Nuitka_CoroutineWrapperObject *)generator->m_yieldfrom)->m_coroutine;
+                ((struct Nuitka_CoroutineWrapperObject *)generator->m_yield_from)->m_coroutine;
 
             // Transferred exception ownership to "_Nuitka_Coroutine_throw2".
             Nuitka_MarkGeneratorAsRunning(generator);
             ret = _Nuitka_Coroutine_throw2(tstate, coro, true, exception_type, exception_value, exception_tb);
             Nuitka_MarkGeneratorAsNotRunning(generator);
 #if NUITKA_UNCOMPILED_THROW_INTEGRATION
-        } else if (PyCoro_CheckExact(generator->m_yieldfrom)) {
-            PyGenObject *gen = (PyGenObject *)generator->m_yieldfrom;
+        } else if (PyCoro_CheckExact(generator->m_yield_from)) {
+            PyGenObject *gen = (PyGenObject *)generator->m_yield_from;
 
             // Transferred exception ownership to "Nuitka_UncompiledGenerator_throw".
             Nuitka_MarkGeneratorAsRunning(generator);
@@ -1069,9 +1070,9 @@ static PyObject *_Nuitka_Generator_throw2(PyThreadState *tstate, struct Nuitka_G
             Nuitka_MarkGeneratorAsNotRunning(generator);
 #endif
 #if PYTHON_VERSION >= 0x360
-        } else if (Nuitka_AsyncgenAsend_Check(generator->m_yieldfrom)) {
+        } else if (Nuitka_AsyncgenAsend_Check(generator->m_yield_from)) {
             struct Nuitka_AsyncgenAsendObject *asyncgen_asend =
-                ((struct Nuitka_AsyncgenAsendObject *)generator->m_yieldfrom);
+                ((struct Nuitka_AsyncgenAsendObject *)generator->m_yield_from);
 
             // Transferred exception ownership to "_Nuitka_AsyncgenAsend_throw2".
             Nuitka_MarkGeneratorAsRunning(generator);
@@ -1080,7 +1081,7 @@ static PyObject *_Nuitka_Generator_throw2(PyThreadState *tstate, struct Nuitka_G
 #endif
 #endif
         } else {
-            PyObject *meth = PyObject_GetAttr(generator->m_yieldfrom, const_str_plain_throw);
+            PyObject *meth = PyObject_GetAttr(generator->m_yield_from, const_str_plain_throw);
             if (unlikely(meth == NULL)) {
                 if (!PyErr_ExceptionMatches(PyExc_AttributeError)) {
                     // Release exception, we are done with it now.
@@ -1101,7 +1102,7 @@ static PyObject *_Nuitka_Generator_throw2(PyThreadState *tstate, struct Nuitka_G
 
 #if 0
             // TODO: Add slow mode traces.
-            PRINT_ITEM(coroutine->m_yieldfrom);
+            PRINT_ITEM(coroutine->m_yield_from);
             PRINT_NEW_LINE();
 #endif
             Nuitka_MarkGeneratorAsRunning(generator);
@@ -1118,14 +1119,14 @@ static PyObject *_Nuitka_Generator_throw2(PyThreadState *tstate, struct Nuitka_G
 
         if (unlikely(ret == NULL)) {
             // Return value or exception, not to continue with yielding from.
-            if (generator->m_yieldfrom != NULL) {
-                CHECK_OBJECT(generator->m_yieldfrom);
+            if (generator->m_yield_from != NULL) {
+                CHECK_OBJECT(generator->m_yield_from);
 #if _DEBUG_GENERATOR
                 PRINT_GENERATOR_STATUS("Null return, yield from removal:", generator);
-                PRINT_COROUTINE_VALUE("yieldfrom", generator->m_yieldfrom);
+                PRINT_COROUTINE_VALUE("yield_from", generator->m_yield_from);
 #endif
-                Py_DECREF(generator->m_yieldfrom);
-                generator->m_yieldfrom = NULL;
+                Py_DECREF(generator->m_yield_from);
+                generator->m_yield_from = NULL;
             }
 
             PyObject *val;
@@ -1382,9 +1383,9 @@ static int Nuitka_Generator_set_qualname(struct Nuitka_GeneratorObject *generato
 }
 
 static PyObject *Nuitka_Generator_get_yieldfrom(struct Nuitka_GeneratorObject *generator) {
-    if (generator->m_yieldfrom) {
-        Py_INCREF(generator->m_yieldfrom);
-        return generator->m_yieldfrom;
+    if (generator->m_yield_from) {
+        Py_INCREF(generator->m_yield_from);
+        return generator->m_yield_from;
     } else {
         Py_INCREF(Py_None);
         return Py_None;
@@ -1487,8 +1488,6 @@ static PyAsyncMethods Nuitka_Generator_as_async = {
 };
 #endif
 
-#include <structmember.h>
-
 PyTypeObject Nuitka_Generator_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "compiled_generator", // tp_name
     sizeof(struct Nuitka_GeneratorObject),               // tp_basicsize
@@ -1649,7 +1648,7 @@ PyObject *Nuitka_Generator_New(generator_code code, PyObject *module, PyObject *
 #endif
 
 #if PYTHON_VERSION >= 0x300
-    result->m_yieldfrom = NULL;
+    result->m_yield_from = NULL;
 #endif
 
     memcpy(&result->m_closure[0], closure, closure_given * sizeof(struct Nuitka_CellObject *));

nuitka/build/static_src/CompiledGeneratorTypeUncompiledIntegration.c

@@ -367,7 +367,7 @@ static PyObject *Nuitka_PyGen_Send(PyThreadState *tstate, PyGenObject *gen, PyOb
 static bool _Nuitka_Generator_check_throw2(PyThreadState *tstate, PyObject **exception_type, PyObject **exception_value,
                                            PyTracebackObject **exception_tb);
 
-#if PYTHON_VERSION < 0x3B0
+#if PYTHON_VERSION < 0x3b0
 #include <opcode.h>
 // Clashes with our helper names.
 #undef CALL_FUNCTION

nuitka/build/static_src/CompiledMethodType.c

@@ -27,6 +27,7 @@
 #ifdef __IDE_ONLY__
 #include "nuitka/freelists.h"
 #include "nuitka/prelude.h"
+#include <structmember.h>
 #endif
 
 static PyObject *Nuitka_Method_get__doc__(struct Nuitka_MethodObject *method, void *closure) {
@@ -40,8 +41,8 @@ static PyObject *Nuitka_Method_get__doc__(struct Nuitka_MethodObject *method, vo
     return result;
 }
 
-static PyGetSetDef Nuitka_Method_getsets[] = {{(char *)"__doc__", (getter)Nuitka_Method_get__doc__, NULL, NULL},
-                                              {NULL}};
+static PyGetSetDef Nuitka_Method_tp_getset[] = {{(char *)"__doc__", (getter)Nuitka_Method_get__doc__, NULL, NULL},
+                                                {NULL}};
 
 #define OFF(x) offsetof(struct Nuitka_MethodObject, x)
 
@@ -61,6 +62,7 @@ static PyObject *Nuitka_Method_reduce(struct Nuitka_MethodObject *method) {
 #if PYTHON_VERSION < 0x300
     PyThreadState *tstate = PyThreadState_GET();
 
+    // spell-checker: ignore instancemethod
     SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "can't pickle instancemethod objects");
     return NULL;
 #elif PYTHON_VERSION < 0x340
@@ -531,7 +533,7 @@ PyTypeObject Nuitka_Method_Type = {
     0,                                                // tp_iternext
     Nuitka_Method_methods,                            // tp_methods
     Nuitka_Method_members,                            // tp_members
-    Nuitka_Method_getsets,                            // tp_getset
+    Nuitka_Method_tp_getset,                          // tp_getset
     0,                                                // tp_base
     0,                                                // tp_dict
     (descrgetfunc)Nuitka_Method_tp_descr_get,         // tp_descr_get

nuitka/build/static_src/HelperEnvironmentVariables.c

@@ -0,0 +1,120 @@
+//     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.
+//
+
+// Helpers for working with environment variables in a portable way. This mainly
+// abstracts the string type differences between Win32 and non-Win32 environment
+// variables.
+
+#include "nuitka/environment_variables.h"
+
+#if defined(_WIN32)
+
+environment_char_t const *getEnvironmentVariable(char const *name) {
+    // Max size for environment variables according to docs.
+    wchar_t buffer[32768];
+    buffer[0] = 0;
+
+    wchar_t name_wide[40];
+    name_wide[0] = 0;
+    appendStringSafeW(name_wide, name, sizeof(name_wide) / sizeof(wchar_t));
+
+    // Size must be in bytes apparently, not in characters. Cannot be larger anyway.
+    DWORD res = GetEnvironmentVariableW(name_wide, buffer, 65536);
+
+    if (res == 0 || res > sizeof(buffer)) {
+        return NULL;
+    }
+
+    return wcsdup(buffer);
+}
+
+void setEnvironmentVariable(char const *name, environment_char_t const *value) {
+    assert(name != NULL);
+    assert(value != NULL);
+
+    wchar_t name_wide[40];
+    name_wide[0] = 0;
+    appendStringSafeW(name_wide, name, sizeof(name_wide) / sizeof(wchar_t));
+
+    DWORD res = SetEnvironmentVariableW(name_wide, value);
+    assert(wcscmp(getEnvironmentVariable(name), value) == 0);
+
+    assert(res != 0);
+}
+
+void unsetEnvironmentVariable(char const *name) {
+    wchar_t name_wide[40];
+    name_wide[0] = 0;
+    appendStringSafeW(name_wide, name, sizeof(name_wide) / sizeof(wchar_t));
+
+    DWORD res = SetEnvironmentVariableW(name_wide, NULL);
+
+    assert(res != 0);
+}
+
+#else
+
+environment_char_t const *getEnvironmentVariable(char const *name) { return getenv(name); }
+
+void setEnvironmentVariable(char const *name, environment_char_t const *value) { setenv(name, value, 1); }
+
+void unsetEnvironmentVariable(char const *name) { unsetenv(name); }
+
+#endif
+
+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);
+}

nuitka/build/static_src/HelpersAttributes.c

@@ -1208,7 +1208,7 @@ PyObject *LOOKUP_SPECIAL(PyThreadState *tstate, PyObject *source, PyObject *attr
         }
     }
 
-#if PYTHON_VERSION < 0x3B0
+#if PYTHON_VERSION < 0x3b0
     SET_CURRENT_EXCEPTION_TYPE0_VALUE0(tstate, PyExc_AttributeError, attr_name);
 #else
     // TODO: Maybe we should have dedicated variations with the 4 hard coded

nuitka/build/static_src/HelpersBuiltin.c

@@ -55,7 +55,7 @@ PyObject *CALL_BUILTIN_KW_ARGS(PyThreadState *tstate, PyObject *callable, PyObje
                 kw_dict = MAKE_DICT_EMPTY();
             }
 
-            int res = PyDict_SetItemString(kw_dict, arg_names[i], args[i]);
+            NUITKA_MAY_BE_UNUSED int res = PyDict_SetItemString(kw_dict, arg_names[i], args[i]);
             assert(res == 0);
         }
 

nuitka/build/static_src/HelpersChecksumTools.c

@@ -21,9 +21,14 @@
 #include "nuitka/prelude.h"
 #endif
 
-uint32_t initCRC32(void) { return 0xFFFFFFFF; }
+// Comment in to disable outside zlib usage for code size, very slow though,
+// since it doesn't use assembly to use CPU crc32 instructions.
+// #define _NUITKA_USE_OWN_CRC32
 
-uint32_t updateCRC32(uint32_t crc, unsigned char const *message, uint32_t size) {
+#ifdef _NUITKA_USE_OWN_CRC32
+uint32_t _initCRC32(void) { return 0xFFFFFFFF; }
+
+uint32_t _updateCRC32(uint32_t crc, unsigned char const *message, uint32_t size) {
     for (uint32_t i = 0; i < size; i++) {
         unsigned int c = message[i];
         crc = crc ^ c;
@@ -37,9 +42,19 @@ uint32_t updateCRC32(uint32_t crc, unsigned char const *message, uint32_t size)
     return crc;
 }
 
-uint32_t finalizeCRC32(uint32_t crc) { return ~crc; }
+uint32_t _finalizeCRC32(uint32_t crc) { return ~crc; }
 
 // No Python runtime is available yet, need to do this in C.
 uint32_t calcCRC32(unsigned char const *message, uint32_t size) {
-    return finalizeCRC32(updateCRC32(initCRC32(), message, size));
+    return _finalizeCRC32(_updateCRC32(_initCRC32(), message, size));
 }
+#else
+
+#ifdef _NUITKA_USE_SYSTEM_CRC32
+#include "zlib.h"
+#else
+#include "crc32.c"
+#endif
+
+uint32_t calcCRC32(unsigned char const *message, uint32_t size) { return crc32(0, message, size) & 0xFFFFFFFF; }
+#endif

nuitka/build/static_src/HelpersComparisonEq.c

@@ -2151,7 +2151,7 @@ static PyObject *COMPARE_EQ_OBJECT_UNICODE_UNICODE(PyObject *operand1, PyObject
     } else {
         int kind1 = PyUnicode_KIND(a);
         if (unlikely(kind1 == 0)) {
-            int res = _PyUnicode_Ready((PyObject *)a);
+            NUITKA_MAY_BE_UNUSED int res = _PyUnicode_Ready((PyObject *)a);
             assert(res != -1);
             kind1 = PyUnicode_KIND(a);
             assert(kind1 != 0);
@@ -2159,7 +2159,7 @@ static PyObject *COMPARE_EQ_OBJECT_UNICODE_UNICODE(PyObject *operand1, PyObject
 
         int kind2 = PyUnicode_KIND(b);
         if (unlikely(kind2 == 0)) {
-            int res = _PyUnicode_Ready((PyObject *)b);
+            NUITKA_MAY_BE_UNUSED int res = _PyUnicode_Ready((PyObject *)b);
             assert(res != -1);
             kind2 = PyUnicode_KIND(b);
             assert(kind2 != 0);
@@ -2821,7 +2821,7 @@ static bool COMPARE_EQ_CBOOL_UNICODE_UNICODE(PyObject *operand1, PyObject *opera
     } else {
         int kind1 = PyUnicode_KIND(a);
         if (unlikely(kind1 == 0)) {
-            int res = _PyUnicode_Ready((PyObject *)a);
+            NUITKA_MAY_BE_UNUSED int res = _PyUnicode_Ready((PyObject *)a);
             assert(res != -1);
             kind1 = PyUnicode_KIND(a);
             assert(kind1 != 0);
@@ -2829,7 +2829,7 @@ static bool COMPARE_EQ_CBOOL_UNICODE_UNICODE(PyObject *operand1, PyObject *opera
 
         int kind2 = PyUnicode_KIND(b);
         if (unlikely(kind2 == 0)) {
-            int res = _PyUnicode_Ready((PyObject *)b);
+            NUITKA_MAY_BE_UNUSED int res = _PyUnicode_Ready((PyObject *)b);
             assert(res != -1);
             kind2 = PyUnicode_KIND(b);
             assert(kind2 != 0);

nuitka/build/static_src/HelpersComparisonNe.c

@@ -2134,7 +2134,7 @@ static PyObject *COMPARE_NE_OBJECT_UNICODE_UNICODE(PyObject *operand1, PyObject
     } else {
         int kind1 = PyUnicode_KIND(a);
         if (unlikely(kind1 == 0)) {
-            int res = _PyUnicode_Ready((PyObject *)a);
+            NUITKA_MAY_BE_UNUSED int res = _PyUnicode_Ready((PyObject *)a);
             assert(res != -1);
             kind1 = PyUnicode_KIND(a);
             assert(kind1 != 0);
@@ -2142,7 +2142,7 @@ static PyObject *COMPARE_NE_OBJECT_UNICODE_UNICODE(PyObject *operand1, PyObject
 
         int kind2 = PyUnicode_KIND(b);
         if (unlikely(kind2 == 0)) {
-            int res = _PyUnicode_Ready((PyObject *)b);
+            NUITKA_MAY_BE_UNUSED int res = _PyUnicode_Ready((PyObject *)b);
             assert(res != -1);
             kind2 = PyUnicode_KIND(b);
             assert(kind2 != 0);
@@ -2797,7 +2797,7 @@ static bool COMPARE_NE_CBOOL_UNICODE_UNICODE(PyObject *operand1, PyObject *opera
     } else {
         int kind1 = PyUnicode_KIND(a);
         if (unlikely(kind1 == 0)) {
-            int res = _PyUnicode_Ready((PyObject *)a);
+            NUITKA_MAY_BE_UNUSED int res = _PyUnicode_Ready((PyObject *)a);
             assert(res != -1);
             kind1 = PyUnicode_KIND(a);
             assert(kind1 != 0);
@@ -2805,7 +2805,7 @@ static bool COMPARE_NE_CBOOL_UNICODE_UNICODE(PyObject *operand1, PyObject *opera
 
         int kind2 = PyUnicode_KIND(b);
         if (unlikely(kind2 == 0)) {
-            int res = _PyUnicode_Ready((PyObject *)b);
+            NUITKA_MAY_BE_UNUSED int res = _PyUnicode_Ready((PyObject *)b);
             assert(res != -1);
             kind2 = PyUnicode_KIND(b);
             assert(kind2 != 0);