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

nuitka/build/static_src/HelpersConstantsBlob.c

@@ -196,8 +196,10 @@ static PyObject *our_set_richcompare(PyObject *set1, PyObject *set2, int op) {
         // Same sized set, simply check if values are identical. Other reductions should
         // make it identical, or else this won't have the effect intended.
         while (_PySet_Next(set1, &pos1, &key1)) {
-            int res = _PySet_Next(set2, &pos2, &key2);
-            assert(res != 0);
+            {
+                NUITKA_MAY_BE_UNUSED int res = _PySet_Next(set2, &pos2, &key2);
+                assert(res != 0);
+            }
 
             if (key1 != key2) {
                 result = Py_False;
@@ -210,8 +212,10 @@ static PyObject *our_set_richcompare(PyObject *set1, PyObject *set2, int op) {
         // Same sized dictionary, simply check if values are identical. Other reductions should
         // make it identical, or else this won't have the effect intended.
         while (_PySet_NextEntry(set1, &pos1, &key1, &unused1)) {
-            int res = _PySet_NextEntry(set2, &pos2, &key2, &unused2);
-            assert(res != 0);
+            {
+                NUITKA_MAY_BE_UNUSED int res = _PySet_NextEntry(set2, &pos2, &key2, &unused2);
+                assert(res != 0);
+            }
 
             if (key1 != key2) {
                 result = Py_False;
@@ -273,8 +277,10 @@ static PyObject *our_dict_richcompare(PyObject *a, PyObject *b, int op) {
         // Other reductions should make it identical, or else this won't have the
         // effect intended.
         while (Nuitka_DictNext(a, &pos1, &key1, &value1)) {
-            int res = Nuitka_DictNext(b, &pos2, &key2, &value2);
-            assert(res != 0);
+            {
+                NUITKA_MAY_BE_UNUSED int res = Nuitka_DictNext(b, &pos2, &key2, &value2);
+                assert(res != 0);
+            }
 
             if (key1 != key2 || value1 != value2) {
                 result = Py_False;
@@ -447,6 +453,27 @@ static unsigned char const *_unpackValueCString(unsigned char const *data) {
     return data;
 }
 
+// Decoding Variable-length quantity values
+static uint64_t _unpackVariableLength(unsigned char const **data) {
+    uint64_t result = 0;
+    uint64_t factor = 1;
+
+    while (1) {
+        unsigned char value = **data;
+        *data += 1;
+
+        result += (value & 127) * factor;
+
+        if (value < 128) {
+            break;
+        }
+
+        factor <<= 7;
+    }
+
+    return result;
+}
+
 static PyObject *_unpackAnonValue(unsigned char anon_index) {
     switch (anon_index) {
     case 0:
@@ -521,9 +548,7 @@ static unsigned char const *_unpackBlobConstants(PyThreadState *tstate, PyObject
             break;
         }
         case 'T': {
-            // TODO: Use fixed sizes
-            // uint32_t size = unpackSizeUint32(&data);
-            int size = unpackValueInt(&data);
+            int size = (int)_unpackVariableLength(&data);
 
             PyObject *t = PyTuple_New(size);
 
@@ -539,9 +564,7 @@ static unsigned char const *_unpackBlobConstants(PyThreadState *tstate, PyObject
             break;
         }
         case 'L': {
-            // TODO: Use fixed sizes
-            // uint32_t size = unpackSizeUint32(&data);
-            int size = unpackValueInt(&data);
+            int size = (int)_unpackVariableLength(&data);
 
             PyObject *l = PyList_New(size);
 
@@ -557,9 +580,7 @@ static unsigned char const *_unpackBlobConstants(PyThreadState *tstate, PyObject
             break;
         }
         case 'D': {
-            // TODO: Use flexible sizes with bias towards small values.
-            // uint32_t size = unpackSizeUint32(&data);
-            int size = unpackValueInt(&data);
+            int size = (int)_unpackVariableLength(&data);
 
             PyObject *d = _PyDict_NewPresized(size);
 
@@ -584,9 +605,7 @@ static unsigned char const *_unpackBlobConstants(PyThreadState *tstate, PyObject
         }
         case 'P':
         case 'S': {
-            // TODO: Use fixed sizes
-            // uint32_t size = unpackSizeUint32(&data);
-            int size = unpackValueInt(&data);
+            int size = (int)_unpackVariableLength(&data);
 
             PyObject *s;
 
@@ -821,7 +840,7 @@ static unsigned char const *_unpackBlobConstants(PyThreadState *tstate, PyObject
         }
         case 'b': {
             // Python2 str or Python3 bytes, length indicated.
-            int size = unpackValueInt(&data);
+            int size = (int)_unpackVariableLength(&data);
             assert(size > 1);
 
             PyObject *b = Nuitka_Bytes_FromStringAndSize((const char *)data, size);
@@ -840,9 +859,7 @@ static unsigned char const *_unpackBlobConstants(PyThreadState *tstate, PyObject
         }
 
         case 'B': {
-            // TODO: Use fixed sizes for small, e.g. character values, and length vs. 0
-            // termination.
-            int size = unpackValueInt(&data);
+            int size = (int)_unpackVariableLength(&data);
 
             PyObject *b = PyByteArray_FromStringAndSize((const char *)data, size);
             data += size;
@@ -878,7 +895,7 @@ static unsigned char const *_unpackBlobConstants(PyThreadState *tstate, PyObject
             break;
         }
         case 'v': {
-            int size = unpackValueInt(&data);
+            int size = (int)_unpackVariableLength(&data);
 
 #if PYTHON_VERSION < 0x300
             PyObject *u = PyUnicode_FromStringAndSize((const char *)data, size);

nuitka/build/static_src/HelpersDictionaries.c

@@ -214,7 +214,9 @@ static void SET_CURRENT_EXCEPTION_KEY_ERROR(PyThreadState *tstate, PyObject *key
         SET_CURRENT_EXCEPTION_TYPE0_VALUE0(tstate, PyExc_KeyError, key);
     }
 #else
-    return _MAKE_EXCEPTION_FROM_TYPE_ARG(PyExc_KeyError, key);
+    PyObject *exception_value = _MAKE_EXCEPTION_FROM_TYPE_ARG0(PyExc_KeyError, key);
+
+    SET_CURRENT_EXCEPTION_TYPE0_VALUE1(tstate, PyExc_KeyError, exception_value);
 #endif
 }
 

nuitka/build/static_src/HelpersDictionariesGenerated.c

@@ -144,7 +144,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);
             }
         }
@@ -290,7 +290,7 @@ PyObject *DICT_COPY(PyObject *dict_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);
                     }
                 }
@@ -304,7 +304,7 @@ PyObject *DICT_COPY(PyObject *dict_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);
             }
 #endif
@@ -358,7 +358,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);
@@ -510,7 +510,7 @@ PyObject *DEEP_COPY_DICT(PyThreadState *tstate, PyObject *dict_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);
@@ -528,7 +528,7 @@ PyObject *DEEP_COPY_DICT(PyThreadState *tstate, PyObject *dict_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);
@@ -587,7 +587,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);
             }
         }
@@ -768,7 +768,7 @@ static PyObject *COPY_DICT_KW(PyObject *dict_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);
                     }
                 }
@@ -786,7 +786,7 @@ static PyObject *COPY_DICT_KW(PyObject *dict_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);
             }
 #endif

nuitka/build/static_src/HelpersFilesystemPaths.c

@@ -110,7 +110,7 @@ bool readFileChunk(FILE_HANDLE file_handle, void *buffer, size_t size) {
 #endif
 }
 
-bool writeFileChunk(FILE_HANDLE target_file, void *chunk, size_t chunk_size) {
+bool writeFileChunk(FILE_HANDLE target_file, void const *chunk, size_t chunk_size) {
 #if defined(_WIN32)
     DWORD write_size = 0;
     return WriteFile(target_file, chunk, (DWORD)chunk_size, &write_size, NULL);
@@ -289,6 +289,14 @@ bool renameFile(filename_char_t const *source, filename_char_t const *dest) {
 
 #include "nuitka/checksum_tools.h"
 
+extern error_code_t getLastErrorCode(void) {
+#if defined(_WIN32)
+    return GetLastError();
+#else
+    return errno;
+#endif
+}
+
 #if defined(_WIN32)
 struct MapFileToMemoryInfo {
     bool error;
@@ -811,6 +819,7 @@ bool expandTemplatePathW(wchar_t *target, wchar_t const *source, size_t buffer_s
         }
 
         *target++ = *source++;
+        *target = 0;
         buffer_size -= 1;
     }
 
@@ -860,7 +869,7 @@ bool expandTemplatePath(char *target, char const *source, size_t buffer_size) {
 
                     size_t length = strlen(target);
 
-                    if ((length >= 4) && (strcasecmp(target + length - 4, ".exe") == 0)) {
+                    if ((length >= 4) && (strcasecmp(target + length - 4, ".bin") == 0)) {
                         target[length - 4] = 0;
                     }
                 } else if (strcasecmp(var_name, "PID") == 0) {
@@ -947,6 +956,7 @@ bool expandTemplatePath(char *target, char const *source, size_t buffer_size) {
         }
 
         *target++ = *source++;
+        *target = 0;
         buffer_size -= 1;
     }
 

nuitka/build/static_src/HelpersImport.c

@@ -187,7 +187,21 @@ bool IMPORT_MODULE_STAR(PyThreadState *tstate, PyObject *target, bool is_module,
 
         // When we are not using the "__all__", we should skip private variables.
         if (all_case == false) {
-            if (Nuitka_String_AsString_Unchecked(item)[0] == '_') {
+            PyObject *startswith_value;
+#if PYTHON_VERSION < 0x300
+            if (PyString_Check(item)) {
+                startswith_value = STR_STARTSWITH2(tstate, item, const_str_underscore);
+            } else {
+                startswith_value = UNICODE_STARTSWITH2(tstate, item, const_str_underscore);
+            }
+#else
+            startswith_value = UNICODE_STARTSWITH2(tstate, item, const_str_underscore);
+#endif
+
+            CHECK_OBJECT(startswith_value);
+            Py_DECREF(startswith_value);
+
+            if (startswith_value == Py_True) {
                 continue;
             }
         }
@@ -472,3 +486,17 @@ PyObject *IMPORT_NAME_OR_MODULE(PyThreadState *tstate, PyObject *module, PyObjec
     return result;
 }
 #endif
+
+PyObject *IMPORT_MODULE_FIXED(PyThreadState *tstate, PyObject *module_name, PyObject *value_name) {
+    PyObject *import_result = IMPORT_MODULE1(tstate, module_name);
+
+    if (unlikely(import_result == NULL)) {
+        return import_result;
+    }
+
+    PyObject *result = Nuitka_GetModule(tstate, value_name);
+
+    Py_DECREF(import_result);
+
+    return result;
+}

nuitka/build/static_src/HelpersImportHard.c

@@ -102,6 +102,25 @@ PyObject *IMPORT_HARD__IO(void) {
     return module_import_hard__io;
 }
 
+/* C helper for hard import of module "builtins" import. */
+PyObject *IMPORT_HARD_BUILTINS(void) {
+    static PyObject *module_import_hard_builtins = NULL;
+
+    if (module_import_hard_builtins == NULL) {
+        module_import_hard_builtins = PyImport_ImportModule("builtins");
+
+        if (unlikely(module_import_hard_builtins == NULL)) {
+#ifndef __NUITKA_NO_ASSERT__
+            PyErr_PrintEx(0);
+#endif
+            NUITKA_CANNOT_GET_HERE("failed hard import of 'builtins'");
+            abort();
+        }
+    }
+
+    return module_import_hard_builtins;
+}
+
 /* C helper for hard import of module "ctypes" import. */
 PyObject *IMPORT_HARD_CTYPES(void) {
     static PyObject *module_import_hard_ctypes = NULL;

nuitka/build/static_src/HelpersOperationInplaceAddUtils.c

@@ -85,10 +85,11 @@ NUITKA_MAY_BE_UNUSED static bool BYTES_ADD_INCREMENTAL(PyObject **operand1, PyOb
     Py_buffer wb;
     wb.len = -1;
 
-    int res = PyObject_GetBuffer(operand2, &wb, PyBUF_SIMPLE);
-
-    // Has to work.
-    assert(res == 0);
+    {
+        NUITKA_MAY_BE_UNUSED int res = PyObject_GetBuffer(operand2, &wb, PyBUF_SIMPLE);
+        // Has to work.
+        assert(res == 0);
+    }
 
     Py_ssize_t oldsize = PyBytes_GET_SIZE(*operand1);
 

nuitka/build/static_src/HelpersPythonPgo.c

@@ -32,11 +32,11 @@ static FILE *pgo_output;
 
 // Allocated strings
 static char const **PGO_ProbeNameMappings = NULL;
-static int PGO_ProbeNameMappings_size = 0;
-static uint32_t PGO_ProbeNameMappings_used = 0;
+uint32_t PGO_ProbeNameMappings_size = 0;
+uint32_t PGO_ProbeNameMappings_used = 0;
 
-int PGO_getStringID(char const *str) {
-    for (int i = 0; i < PGO_ProbeNameMappings_used; i++) {
+uint32_t PGO_getStringID(char const *str) {
+    for (uint32_t i = 0; i < PGO_ProbeNameMappings_used; i++) {
         if (str == PGO_ProbeNameMappings[i]) {
             return i;
         }
@@ -86,7 +86,7 @@ void PGO_Finalize(void) {
 
     uint32_t offset = (uint32_t)ftell(pgo_output);
 
-    for (int i = 0; i < PGO_ProbeNameMappings_used; i++) {
+    for (uint32_t i = 0; i < PGO_ProbeNameMappings_used; i++) {
         fputs(PGO_ProbeNameMappings[i], pgo_output);
         fputc(0, pgo_output);
     }

nuitka/build/static_src/HelpersSafeStrings.c

@@ -29,6 +29,7 @@
 #include <windows.h>
 #endif
 #include <stdbool.h>
+#include <stdio.h>
 #endif
 
 #include "nuitka/safe_string_ops.h"
@@ -107,7 +108,7 @@ void appendCharSafeW(wchar_t *target, char c, size_t buffer_size) {
 
     target += wcslen(target);
     char buffer_c[2] = {c, 0};
-    size_t res = mbstowcs(target, buffer_c, 2);
+    NUITKA_MAY_BE_UNUSED size_t res = mbstowcs(target, buffer_c, 2);
     assert(res == 1);
 }
 

nuitka/build/static_src/HelpersStrings.c

@@ -146,7 +146,9 @@ PyObject *BUILTIN_ORD(PyObject *value) {
     (assert(_PyUnicode_CHECK(op)), assert(PyUnicode_IS_READY(op)),                                                     \
      PyUnicode_IS_COMPACT_ASCII(op) ? ((PyASCIIObject *)(op))->length : _PyUnicode_UTF8_LENGTH(op))
 #define _PyUnicode_WSTR(op) (((PyASCIIObject *)(op))->wstr)
+#if PYTHON_VERSION < 0x3c0
 #define _PyUnicode_WSTR_LENGTH(op) (((PyCompactUnicodeObject *)(op))->wstr_length)
+#endif
 #define _PyUnicode_LENGTH(op) (((PyASCIIObject *)(op))->length)
 #define _PyUnicode_STATE(op) (((PyASCIIObject *)(op))->state)
 #define _PyUnicode_HASH(op) (((PyASCIIObject *)(op))->hash)
@@ -181,7 +183,7 @@ PyObject *BUILTIN_ORD(PyObject *value) {
             _to += 4;                                                                                                  \
         }                                                                                                              \
         while (_iter < (_end))                                                                                         \
-            *_to++ = (to_type)*_iter++;                                                                                \
+            *_to++ = (to_type)(*_iter++);                                                                              \
     } while (0)
 
 extern int ucs1lib_find_max_char(const Py_UCS1 *begin, const Py_UCS1 *end);
@@ -239,7 +241,7 @@ static int _NuitkaUnicode_modifiable(PyObject *unicode) {
         return 0;
     if (_PyUnicode_HASH(unicode) != -1)
         return 0;
-    // TODO: That ought to be impossible with refcnf 1.
+    // TODO: That ought to be impossible with refcnt 1.
     if (PyUnicode_CHECK_INTERNED(unicode))
         return 0;
     return 1;
@@ -510,11 +512,11 @@ PyObject *UNICODE_CONCAT(PyThreadState *tstate, PyObject *left, PyObject *right)
     }
     Py_ssize_t new_len = left_len + right_len;
 
-    Py_UCS4 maxchar = PyUnicode_MAX_CHAR_VALUE(left);
-    Py_UCS4 maxchar2 = PyUnicode_MAX_CHAR_VALUE(right);
-    maxchar = Py_MAX(maxchar, maxchar2);
+    Py_UCS4 max_char = PyUnicode_MAX_CHAR_VALUE(left);
+    Py_UCS4 max_char2 = PyUnicode_MAX_CHAR_VALUE(right);
+    max_char = Py_MAX(max_char, max_char2);
 
-    PyObject *result = PyUnicode_New(new_len, maxchar);
+    PyObject *result = PyUnicode_New(new_len, max_char);
     if (unlikely(result == NULL)) {
         return NULL;
     }
@@ -561,12 +563,12 @@ bool UNICODE_APPEND(PyThreadState *tstate, PyObject **p_left, PyObject *right) {
 
         _NuitkaUnicode_FastCopyCharacters(*p_left, left_len, right, 0, right_len);
     } else {
-        Py_UCS4 maxchar = PyUnicode_MAX_CHAR_VALUE(left);
-        Py_UCS4 maxchar2 = PyUnicode_MAX_CHAR_VALUE(right);
+        Py_UCS4 max_char = PyUnicode_MAX_CHAR_VALUE(left);
+        Py_UCS4 max_char2 = PyUnicode_MAX_CHAR_VALUE(right);
 
-        maxchar = Py_MAX(maxchar, maxchar2);
+        max_char = Py_MAX(max_char, max_char2);
 
-        PyObject *res = PyUnicode_New(new_len, maxchar);
+        PyObject *res = PyUnicode_New(new_len, max_char);
         if (unlikely(res == NULL)) {
             return false;
         }

nuitka/build/static_src/HelpersTypes.c

@@ -183,6 +183,6 @@ void Nuitka_PyType_Ready(PyTypeObject *type, PyTypeObject *base, bool generic_ge
     assert(!self_aiter);
 #endif
 
-    int res = PyType_Ready(type);
+    NUITKA_MAY_BE_UNUSED int res = PyType_Ready(type);
     assert(res >= 0);
 }

nuitka/build/static_src/InspectPatcher.c

@@ -222,10 +222,11 @@ types._GeneratorWrapper = GeneratorWrapperEnhanced\
     CHECK_OBJECT(wrapper_enhancement_code_object);
 
     {
-        PyObject *module = PyImport_ExecCodeModule("nuitka_types_patch", wrapper_enhancement_code_object);
+        NUITKA_MAY_BE_UNUSED PyObject *module =
+            PyImport_ExecCodeModule("nuitka_types_patch", wrapper_enhancement_code_object);
         CHECK_OBJECT(module);
 
-        bool bool_res = Nuitka_DelModuleString(tstate, "nuitka_types_patch");
+        NUITKA_MAY_BE_UNUSED bool bool_res = Nuitka_DelModuleString(tstate, "nuitka_types_patch");
         assert(bool_res != false);
     }