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

nuitka/build/static_src/HelpersEnvironmentVariablesSystem.c

@@ -0,0 +1,93 @@
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+// 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_system.h"
+#include "nuitka/safe_string_ops.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 setEnvironmentVariableFromLong(char const *name, long value) {
+    char buffer[128];
+    snprintf(buffer, sizeof(buffer), "%ld", value);
+
+#if defined(_WIN32)
+    wchar_t buffer2[128];
+    buffer2[0] = 0;
+    appendStringSafeW(buffer2, buffer, 128);
+
+    setEnvironmentVariable(name, buffer2);
+#else
+    setEnvironmentVariable(name, buffer);
+#endif
+}
+
+//     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/HelpersExceptions.c

@@ -1,20 +1,5 @@
-//     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
+
 /** For setting exceptions.
  *
  * These are non-inline variants for exception raises, done so to avoid the code bloat.
@@ -57,52 +42,36 @@ void SET_CURRENT_EXCEPTION_TYPE_COMPLAINT_NICE(char const *format, PyObject *mis
     SET_CURRENT_EXCEPTION_TYPE0_FORMAT1(PyExc_TypeError, format, TYPE_NAME_DESC(mistyped));
 }
 
-void FORMAT_NAME_ERROR(PyObject **exception_type, PyObject **exception_value, PyObject *variable_name) {
-    *exception_type = PyExc_NameError;
-    Py_INCREF(*exception_type);
-
-    *exception_value =
-        Nuitka_String_FromFormat("name '%s' is not defined", Nuitka_String_AsString_Unchecked(variable_name));
-    CHECK_OBJECT(*exception_value);
-}
-
-#if PYTHON_VERSION < 0x340
-void FORMAT_GLOBAL_NAME_ERROR(PyObject **exception_type, PyObject **exception_value, PyObject *variable_name) {
-    *exception_type = PyExc_NameError;
-    Py_INCREF(*exception_type);
-
-    *exception_value =
-        Nuitka_String_FromFormat("global name '%s' is not defined", Nuitka_String_AsString_Unchecked(variable_name));
-    CHECK_OBJECT(*exception_value);
-}
-#endif
-
-void FORMAT_UNBOUND_LOCAL_ERROR(PyObject **exception_type, PyObject **exception_value, PyObject *variable_name) {
-    *exception_type = PyExc_UnboundLocalError;
-    Py_INCREF(*exception_type);
-
-#if PYTHON_VERSION < 0x3b0
+void FORMAT_UNBOUND_LOCAL_ERROR(PyThreadState *tstate, struct Nuitka_ExceptionPreservationItem *exception_state,
+                                PyObject *variable_name) {
+#if PYTHON_VERSION < 0x300
     char const *message = "local variable '%s' referenced before assignment";
+    PyObject *exception_value = Nuitka_String_FromFormat(message, Nuitka_String_AsString_Unchecked(variable_name));
+#elif PYTHON_VERSION < 0x3b0
+    char const *message = "local variable '%U' referenced before assignment";
+    PyObject *exception_value = Nuitka_String_FromFormat(message, variable_name);
 #else
-    char const *message = "cannot access local variable '%s' where it is not associated with a value";
+    char const *message = "cannot access local variable '%U' where it is not associated with a value";
+    PyObject *exception_value = Nuitka_String_FromFormat(message, variable_name);
 #endif
 
-    *exception_value = Nuitka_String_FromFormat(message, Nuitka_String_AsString_Unchecked(variable_name));
-    CHECK_OBJECT(*exception_value);
+    CHECK_OBJECT(exception_value);
+    SET_EXCEPTION_PRESERVATION_STATE_FROM_TYPE0_VALUE1(tstate, exception_state, PyExc_UnboundLocalError,
+                                                       exception_value);
 }
 
-void FORMAT_UNBOUND_CLOSURE_ERROR(PyObject **exception_type, PyObject **exception_value, PyObject *variable_name) {
-    *exception_type = PyExc_NameError;
-    Py_INCREF(*exception_type);
-
+void FORMAT_UNBOUND_CLOSURE_ERROR(PyThreadState *tstate, struct Nuitka_ExceptionPreservationItem *exception_state,
+                                  PyObject *variable_name) {
 #if PYTHON_VERSION < 0x3b0
     char const *message = "free variable '%s' referenced before assignment in enclosing scope";
 #else
     char const *message = "cannot access free variable '%s' where it is not associated with a value in enclosing scope";
 #endif
 
-    *exception_value = Nuitka_String_FromFormat(message, Nuitka_String_AsString_Unchecked(variable_name));
-    CHECK_OBJECT(*exception_value);
+    PyObject *exception_value = Nuitka_String_FromFormat(message, Nuitka_String_AsString_Unchecked(variable_name));
+    CHECK_OBJECT(exception_value);
+
+    SET_EXCEPTION_PRESERVATION_STATE_FROM_TYPE0_VALUE1(tstate, exception_state, PyExc_NameError, exception_value);
 }
 
 static PyObject *_Nuitka_Err_CreateException(PyThreadState *tstate, PyObject *exception_type, PyObject *value) {
@@ -111,7 +80,7 @@ static PyObject *_Nuitka_Err_CreateException(PyThreadState *tstate, PyObject *ex
     if (value == NULL || value == Py_None) {
         exc = CALL_FUNCTION_NO_ARGS(tstate, exception_type);
     } else if (PyTuple_Check(value)) {
-        exc = CALL_FUNCTION_WITH_POSARGS(tstate, exception_type, value);
+        exc = CALL_FUNCTION_WITH_POS_ARGS(tstate, exception_type, value);
     } else {
         exc = CALL_FUNCTION_WITH_SINGLE_ARG(tstate, exception_type, value);
     }
@@ -129,10 +98,106 @@ static PyObject *_Nuitka_Err_CreateException(PyThreadState *tstate, PyObject *ex
     return exc;
 }
 
-#if PYTHON_VERSION < 0x3c0
+PyObject *MAKE_EXCEPTION_WITH_VALUE(PyThreadState *tstate, PyObject *exception_type, PyObject *value) {
+    return _Nuitka_Err_CreateException(tstate, exception_type, value);
+}
+
 // Our replacement for PyErr_NormalizeException, that however does not attempt
 // to deal with recursion, i.e. exception during normalization, we just avoid
 // the API call overhead in the normal case.
+
+#if PYTHON_VERSION >= 0x3d0
+// TODO: Merge with old branch for enhancements.
+void Nuitka_Err_NormalizeException(PyThreadState *tstate, PyObject **exc, PyObject **val, PyTracebackObject **tb) {
+    int recursion_depth = 0;
+    tstate->recursion_headroom++;
+
+    PyObject *type, *value;
+    PyTracebackObject *initial_tb;
+
+restart:
+    type = *exc;
+
+    if (type == NULL) {
+        tstate->recursion_headroom--;
+        return;
+    }
+
+    value = *val;
+
+    if (!value) {
+        Py_INCREF_IMMORTAL(Py_None);
+        value = Py_None;
+    }
+
+    if (PyExceptionClass_Check(type)) {
+        PyObject *instance_class = NULL;
+
+        int is_subclass = 0;
+
+        if (PyExceptionInstance_Check(value)) {
+            instance_class = PyExceptionInstance_Class(value);
+
+            is_subclass = PyObject_IsSubclass(instance_class, type);
+            if (is_subclass < 0) {
+                goto error;
+            }
+        }
+
+        if (!is_subclass) {
+            PyObject *fixed_value = _Nuitka_Err_CreateException(tstate, type, value);
+
+            if (fixed_value == NULL) {
+                goto error;
+            }
+
+            Py_SETREF(value, fixed_value);
+        } else if (instance_class != type) {
+            Py_SETREF(type, Py_NewRef(instance_class));
+        }
+    }
+    *exc = type;
+    *val = value;
+    tstate->recursion_headroom--;
+    return;
+
+error:
+    Py_DECREF(type);
+    Py_DECREF(value);
+    recursion_depth++;
+    if (recursion_depth == 32) {
+        _PyErr_SetString(tstate, PyExc_RecursionError,
+                         "maximum recursion depth exceeded "
+                         "while normalizing an exception");
+    }
+
+    initial_tb = *tb;
+
+    struct Nuitka_ExceptionPreservationItem exception_state;
+    FETCH_ERROR_OCCURRED_STATE(tstate, &exception_state);
+
+    ASSIGN_ARGS_FROM_EXCEPTION_PRESERVATION_STATE(&exception_state, exc, val, tb);
+    RELEASE_ERROR_OCCURRED_STATE(&exception_state);
+
+    assert(*exc != NULL);
+    if (initial_tb != NULL) {
+        if (*tb == NULL)
+            *tb = initial_tb;
+        else
+            Py_DECREF(initial_tb);
+    }
+    if (recursion_depth >= 32 + 2) {
+        if (PyErr_GivenExceptionMatches(*exc, PyExc_MemoryError)) {
+            Py_FatalError("Cannot recover from MemoryErrors "
+                          "while normalizing exceptions.");
+        } else {
+            Py_FatalError("Cannot recover from the recursive normalization "
+                          "of an exception.");
+        }
+    }
+    goto restart;
+}
+#else
 void Nuitka_Err_NormalizeException(PyThreadState *tstate, PyObject **exc, PyObject **val, PyTracebackObject **tb) {
     PyObject *type = *exc;
 
@@ -144,19 +209,19 @@ void Nuitka_Err_NormalizeException(PyThreadState *tstate, PyObject **exc, PyObje
     // Allow setting the value to NULL for time savings with quick type only errors
     if (value == NULL) {
         value = Py_None;
-        Py_INCREF(value);
+        Py_INCREF_IMMORTAL(value);
     }
 
     // Normalize the exception from class to instance
     if (PyExceptionClass_Check(type)) {
-        PyObject *inclass = NULL;
+        PyObject *instance_class = NULL;
 
         int is_subclass = 0;
 
         if (PyExceptionInstance_Check(value)) {
-            inclass = PyExceptionInstance_Class(value);
+            instance_class = PyExceptionInstance_Class(value);
 
-            is_subclass = PyObject_IsSubclass(inclass, type);
+            is_subclass = PyObject_IsSubclass(instance_class, type);
 
             if (is_subclass < 0) {
                 goto error;
@@ -174,12 +239,12 @@ void Nuitka_Err_NormalizeException(PyThreadState *tstate, PyObject **exc, PyObje
 
             Py_DECREF(value);
             value = fixed_value;
-        } else if (inclass != type) {
+        } else if (instance_class != type) {
             // Switch to given type then
-            Py_INCREF(inclass);
+            Py_INCREF(instance_class);
             Py_DECREF(type);
 
-            type = inclass;
+            type = instance_class;
         }
     }
 
@@ -194,7 +259,11 @@ error:
     Py_DECREF(value);
     PyTracebackObject *initial_tb = *tb;
 
-    FETCH_ERROR_OCCURRED(tstate, exc, val, tb);
+    struct Nuitka_ExceptionPreservationItem exception_state;
+    FETCH_ERROR_OCCURRED_STATE(tstate, &exception_state);
+
+    ASSIGN_ARGS_FROM_EXCEPTION_PRESERVATION_STATE(&exception_state, exc, val, tb);
+    RELEASE_ERROR_OCCURRED_STATE(&exception_state);
 
     if (initial_tb != NULL) {
         if (*tb == NULL) {
@@ -210,4 +279,20 @@ error:
     PyErr_NormalizeException(exc, val, (PyObject **)tb);
 #endif
 }
-#endif
+
+#endif
+
+//     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/HelpersFiles.c

@@ -1,20 +1,5 @@
-//     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
+
 /* Small helpers to access files and their contents */
 
 // This file is included from another C file, help IDEs to still parse it on
@@ -98,10 +83,10 @@ PyObject *BUILTIN_OPEN_BINARY_READ_SIMPLE(PyThreadState *tstate, PyObject *filen
 }
 
 PyObject *GET_FILE_BYTES(PyThreadState *tstate, PyObject *filename) {
-    PyObject *result;
+    PyObject *read_result;
 
-    if (TRACE_FILE_READ(tstate, filename, &result)) {
-        return result;
+    if (TRACE_FILE_READ(tstate, filename, &read_result)) {
+        return read_result;
     }
 
     PyObject *data_file = BUILTIN_OPEN_BINARY_READ_SIMPLE(tstate, filename);
@@ -118,9 +103,32 @@ PyObject *GET_FILE_BYTES(PyThreadState *tstate, PyObject *filename) {
         return NULL;
     }
 
-    result = CALL_FUNCTION_NO_ARGS(tstate, read_method);
+    PyObject *close_method = LOOKUP_ATTRIBUTE(tstate, data_file, const_str_plain_close);
+
+    if (unlikely(close_method == NULL)) {
+        Py_DECREF(read_method);
+        return NULL;
+    }
+
+    read_result = CALL_FUNCTION_NO_ARGS(tstate, read_method);
     Py_DECREF(read_method);
-    return result;
+
+    if (unlikely(read_result == NULL)) {
+        Py_DECREF(close_method);
+        return NULL;
+    }
+
+    PyObject *close_result = CALL_FUNCTION_NO_ARGS(tstate, close_method);
+    Py_DECREF(close_method);
+
+    if (unlikely(close_result == NULL)) {
+        Py_DECREF(read_result);
+        return NULL;
+    }
+
+    Py_DECREF(close_result);
+
+    return read_result;
 }
 
 // TODO: Don't we have this generated.
@@ -200,6 +208,57 @@ PyObject *OS_LISTDIR(PyThreadState *tstate, PyObject *path) {
     return result;
 }
 
+extern PyObject *OS_STAT(PyThreadState *tstate, PyObject *path, PyObject *dir_fd, PyObject *follow_symlinks) {
+    assert(path != NULL);
+
+    PyObject *result;
+
+    if (TRACE_FILE_STAT(tstate, path, dir_fd, follow_symlinks, &result)) {
+        return result;
+    }
+
+    PyObject *stat_func = LOOKUP_ATTRIBUTE(tstate, IMPORT_HARD_OS(), const_str_plain_stat);
+
+#if PYTHON_VERSION < 0x300
+    assert(dir_fd == NULL);
+
+    result = CALL_FUNCTION_WITH_SINGLE_ARG(tstate, stat_func, path);
+#else
+
+    PyObject *args[] = {path, dir_fd, follow_symlinks};
+
+    char const *arg_names[] = {"path", "dir_fd", "follow_symlinks"};
+    result = CALL_BUILTIN_KW_ARGS(tstate, stat_func, args, arg_names, 3, 2);
+#endif
+
+    Py_DECREF(stat_func);
+    return result;
+}
+
+extern PyObject *OS_LSTAT(PyThreadState *tstate, PyObject *path, PyObject *dir_fd) {
+#if PYTHON_VERSION < 0x300
+    assert(path != NULL);
+    PyObject *result;
+
+    if (TRACE_FILE_STAT(tstate, path, dir_fd, false, &result)) {
+        return result;
+    }
+
+    assert(path != NULL);
+    assert(dir_fd == NULL);
+    PyObject *stat_func = LOOKUP_ATTRIBUTE(tstate, IMPORT_HARD_OS(), const_str_plain_stat);
+
+    result = CALL_FUNCTION_WITH_SINGLE_ARG(tstate, stat_func, path);
+
+    Py_DECREF(stat_func);
+    return result;
+#else
+    PyObject *follow_symlinks = Py_False;
+
+    return OS_STAT(tstate, path, dir_fd, follow_symlinks);
+#endif
+}
+
 PyObject *OS_PATH_BASENAME(PyThreadState *tstate, PyObject *filename) {
     CHECK_OBJECT(filename);
 
@@ -211,6 +270,17 @@ PyObject *OS_PATH_BASENAME(PyThreadState *tstate, PyObject *filename) {
     return result;
 }
 
+PyObject *OS_PATH_DIRNAME(PyThreadState *tstate, PyObject *filename) {
+    CHECK_OBJECT(filename);
+
+    PyObject *dirname_func = LOOKUP_ATTRIBUTE(tstate, IMPORT_HARD_OS_PATH(tstate), const_str_plain_dirname);
+
+    PyObject *result = CALL_FUNCTION_WITH_SINGLE_ARG(tstate, dirname_func, filename);
+
+    Py_DECREF(dirname_func);
+    return result;
+}
+
 PyObject *OS_PATH_ABSPATH(PyThreadState *tstate, PyObject *filename) {
     CHECK_OBJECT(filename);
 
@@ -233,6 +303,15 @@ PyObject *OS_PATH_ISABS(PyThreadState *tstate, PyObject *filename) {
     return result;
 }
 
+extern PyObject *OS_PATH_NORMPATH(PyThreadState *tstate, PyObject *filename) {
+    PyObject *normpath_func = LOOKUP_ATTRIBUTE(tstate, IMPORT_HARD_OS_PATH(tstate), const_str_plain_normpath);
+
+    PyObject *result = CALL_FUNCTION_WITH_SINGLE_ARG(tstate, normpath_func, filename);
+
+    Py_DECREF(normpath_func);
+    return result;
+}
+
 nuitka_bool compareFilePaths(PyThreadState *tstate, PyObject *filename_a, PyObject *filename_b) {
     filename_a = OS_PATH_ABSPATH(tstate, filename_a);
 
@@ -249,3 +328,18 @@ nuitka_bool compareFilePaths(PyThreadState *tstate, PyObject *filename_a, PyObje
 
     return RICH_COMPARE_EQ_NBOOL_OBJECT_OBJECT(filename_a, filename_b);
 }
+
+//     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.