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

nuitka/build/SconsUtils.py

@@ -15,6 +15,7 @@ import sys
 
 from nuitka.__past__ import basestring, unicode
 from nuitka.containers.OrderedDicts import OrderedDict
+from nuitka.Progress import enableThreading
 from nuitka.Tracing import scons_details_logger, scons_logger
 from nuitka.utils.Execution import executeProcess
 from nuitka.utils.FileOperations import (
@@ -44,6 +45,10 @@ def initScons():
 
     SCons.dblite.dblite.sync = no_sync
 
+    # We use threads during build, so keep locks if necessary for progress bar
+    # updates.
+    enableThreading()
+
 
 def setupScons(env, source_dir):
     env["BUILD_DIR"] = source_dir

nuitka/build/include/nuitka/allocator.h

@@ -18,6 +18,11 @@
 extern void *(*python_obj_malloc)(void *ctx, size_t size);
 extern void *(*python_mem_malloc)(void *ctx, size_t size);
 extern void *(*python_mem_calloc)(void *ctx, size_t nelem, size_t elsize);
+#ifndef Py_GIL_DISABLED
+extern void *(*python_mem_realloc)(void *ctx, void *ptr, size_t new_size);
+#else
+extern void (*python_mem_free)(void *ctx, void *ptr);
+#endif
 
 #if defined(Py_DEBUG)
 extern void *python_obj_ctx;
@@ -40,10 +45,31 @@ NUITKA_MAY_BE_UNUSED static void *NuitkaMem_Calloc(size_t nelem, size_t elsize)
     return python_mem_calloc(python_mem_ctx, nelem, elsize);
 }
 
+#ifndef Py_GIL_DISABLED
+// Our version of "PyMem_Realloc".
+NUITKA_MAY_BE_UNUSED static void *NuitkaMem_Realloc(void *ptr, size_t new_size) {
+    return python_mem_realloc(python_mem_ctx, ptr, new_size);
+}
+#else
+NUITKA_MAY_BE_UNUSED static void NuitkaMem_Free(void *ptr) { python_mem_free(python_mem_ctx, ptr); }
+#endif
+
 #else
 #define NuitkaObject_Malloc(size) PyObject_MALLOC(size)
 #define NuitkaMem_Malloc(size) PyMem_MALLOC(size)
-#define NuitkaMem_Calloc(elem, elsize) PyMem_CALLOC(elem, elsize)
+#define NuitkaMem_Calloc(elem, elsize) PyMem_Calloc(elem, elsize)
+#ifndef Py_GIL_DISABLED
+#if defined(_WIN32)
+// On Windows, mixing different runtime DLLs can cause issues at
+// release, so we need to go through the API to get the proper
+// DLL runtime.
+#define NuitkaMem_Realloc(ptr, new_size) PyMem_Realloc(ptr, new_size)
+#else
+#define NuitkaMem_Realloc(ptr, new_size) PyMem_REALLOC(ptr, new_size)
+#endif
+#else
+#define NuitkaMem_Free(ptr) PyMem_Free(ptr)
+#endif
 #endif
 
 #if PYTHON_VERSION >= 0x380 && PYTHON_VERSION < 0x3c0
@@ -102,6 +128,48 @@ static inline void _Nuitka_Py_XDECREF(PyObject *ob) {
         }                                                                                                              \
     } while (0)
 
+#elif PYTHON_VERSION >= 0x3c0 && defined(_WIN32) && !defined(Py_DEBUG) && !defined(Py_TRACE_REFS) &&                   \
+    !defined(Py_GIL_DISABLED) && !defined(_NUITKA_EXPERIMENTAL_DISABLE_PY_DECREF_OVERRIDE)
+
+#undef Py_DECREF
+#define Py_DECREF(arg)                                                                                                 \
+    do {                                                                                                               \
+        PyObject *op = _PyObject_CAST(arg);                                                                            \
+        if (_Py_IsImmortal(op)) {                                                                                      \
+            break;                                                                                                     \
+        }                                                                                                              \
+        _Py_DECREF_STAT_INC();                                                                                         \
+        if (--op->ob_refcnt == 0) {                                                                                    \
+            destructor dealloc = Py_TYPE(op)->tp_dealloc;                                                              \
+            (*dealloc)(op);                                                                                            \
+        }                                                                                                              \
+    } while (0)
+
+#undef Py_XDECREF
+#define Py_XDECREF(arg)                                                                                                \
+    do {                                                                                                               \
+        PyObject *xop = _PyObject_CAST(arg);                                                                           \
+        if (xop != NULL) {                                                                                             \
+            Py_DECREF(xop);                                                                                            \
+        }                                                                                                              \
+    } while (0)
+
+#undef Py_IS_TYPE
+#define Py_IS_TYPE(ob, type) (_PyObject_CAST(ob)->ob_type == (type))
+
+#undef _Py_DECREF_SPECIALIZED
+#define _Py_DECREF_SPECIALIZED(arg, dealloc)                                                                           \
+    do {                                                                                                               \
+        PyObject *op = _PyObject_CAST(arg);                                                                            \
+        if (_Py_IsImmortal(op)) {                                                                                      \
+            break;                                                                                                     \
+        }                                                                                                              \
+        _Py_DECREF_STAT_INC();                                                                                         \
+        if (--op->ob_refcnt == 0) {                                                                                    \
+            destructor d = (destructor)(dealloc);                                                                      \
+            d(op);                                                                                                     \
+        }                                                                                                              \
+    } while (0)
 #endif
 
 // For Python3.12, avoid reference management if value is known to be immortal.
@@ -131,6 +199,7 @@ static inline void Nuitka_Py_NewReference(PyObject *op) {
 #if PYTHON_VERSION < 0x3c0
     _Py_RefTotal++;
 #else
+    // Refcounts are now in the interpreter state, spell-checker: ignore reftotal
     _PyInterpreterState_GET()->object_state.reftotal++;
 #endif
 #endif
@@ -307,6 +376,60 @@ static void inline Py_SET_REFCNT_IMMORTAL(PyObject *object) {
 #define Py_SET_REFCNT_IMMORTAL(object)
 #endif
 
+// Have these defines from newer Python for all Python versions available
+#ifndef _Py_CAST
+#define _Py_CAST(type, expr) ((type)(expr))
+#endif
+
+#ifndef _PyObject_CAST
+#define _PyObject_CAST(op) _Py_CAST(PyObject *, (op))
+#endif
+
+#ifndef Py_SETREF
+#ifdef _Py_TYPEOF
+#define Py_SETREF(dst, src)                                                                                            \
+    do {                                                                                                               \
+        _Py_TYPEOF(dst) *_tmp_dst_ptr = &(dst);                                                                        \
+        _Py_TYPEOF(dst) _tmp_old_dst = (*_tmp_dst_ptr);                                                                \
+        *_tmp_dst_ptr = (src);                                                                                         \
+        Py_DECREF(_tmp_old_dst);                                                                                       \
+    } while (0)
+#else
+#define Py_SETREF(dst, src)                                                                                            \
+    do {                                                                                                               \
+        PyObject **_tmp_dst_ptr = _Py_CAST(PyObject **, &(dst));                                                       \
+        PyObject *_tmp_old_dst = (*_tmp_dst_ptr);                                                                      \
+        PyObject *_tmp_src = _PyObject_CAST(src);                                                                      \
+        memcpy(_tmp_dst_ptr, &_tmp_src, sizeof(PyObject *));                                                           \
+        Py_DECREF(_tmp_old_dst);                                                                                       \
+    } while (0)
+#endif
+#endif
+
+#ifndef Py_XSETREF
+/* Py_XSETREF() is a variant of Py_SETREF() that uses Py_XDECREF() instead of
+ * Py_DECREF().
+ */
+#ifdef _Py_TYPEOF
+#define Py_XSETREF(dst, src)                                                                                           \
+    do {                                                                                                               \
+        _Py_TYPEOF(dst) *_tmp_dst_ptr = &(dst);                                                                        \
+        _Py_TYPEOF(dst) _tmp_old_dst = (*_tmp_dst_ptr);                                                                \
+        *_tmp_dst_ptr = (src);                                                                                         \
+        Py_XDECREF(_tmp_old_dst);                                                                                      \
+    } while (0)
+#else
+#define Py_XSETREF(dst, src)                                                                                           \
+    do {                                                                                                               \
+        PyObject **_tmp_dst_ptr = _Py_CAST(PyObject **, &(dst));                                                       \
+        PyObject *_tmp_old_dst = (*_tmp_dst_ptr);                                                                      \
+        PyObject *_tmp_src = _PyObject_CAST(src);                                                                      \
+        memcpy(_tmp_dst_ptr, &_tmp_src, sizeof(PyObject *));                                                           \
+        Py_XDECREF(_tmp_old_dst);                                                                                      \
+    } while (0)
+#endif
+#endif
+
 #endif
 
 //     Part of "Nuitka", an optimizing Python compiler that is compatible and

nuitka/build/include/nuitka/calling.h

@@ -81,24 +81,24 @@ NUITKA_MAY_BE_UNUSED static PyObject *CALL_FUNCTION(PyThreadState *tstate, PyObj
 extern PyObject *CALL_FUNCTION_NO_ARGS(PyThreadState *tstate, PyObject *called);
 
 // Function call variants with positional arguments tuple.
-NUITKA_MAY_BE_UNUSED static PyObject *CALL_FUNCTION_WITH_POSARGS(PyThreadState *tstate, PyObject *function_object,
-                                                                 PyObject *positional_args) {
+NUITKA_MAY_BE_UNUSED static PyObject *CALL_FUNCTION_WITH_POS_ARGS(PyThreadState *tstate, PyObject *function_object,
+                                                                  PyObject *positional_args) {
     return CALL_FUNCTION(tstate, function_object, positional_args, NULL);
 }
 
 // Method call variants with positional arguments tuple.
-extern PyObject *CALL_METHOD_WITH_POSARGS(PyThreadState *tstate, PyObject *source, PyObject *attr_name,
-                                          PyObject *positional_args);
+extern PyObject *CALL_METHOD_WITH_POS_ARGS(PyThreadState *tstate, PyObject *source, PyObject *attr_name,
+                                           PyObject *positional_args);
 
 // TODO: Specialize in template too.
-NUITKA_MAY_BE_UNUSED static PyObject *CALL_FUNCTION_WITH_KEYARGS(PyThreadState *tstate, PyObject *function_object,
+NUITKA_MAY_BE_UNUSED static PyObject *CALL_FUNCTION_WITH_KW_ARGS(PyThreadState *tstate, PyObject *function_object,
                                                                  PyObject *named_args) {
     return CALL_FUNCTION(tstate, function_object, const_tuple_empty, named_args);
 }
 
 // Call built-in functions with using defaulted values.
 extern PyObject *CALL_BUILTIN_KW_ARGS(PyThreadState *tstate, PyObject *callable, PyObject **args,
-                                      char const **arg_names, int max_args);
+                                      char const **arg_names, int max_args, int kw_only_args);
 
 // For abstract class instantiation error message, during call.
 extern void formatCannotInstantiateAbstractClass(PyThreadState *tstate, PyTypeObject *type);

nuitka/build/include/nuitka/compiled_asyncgen.h

@@ -104,6 +104,10 @@ static inline void SAVE_ASYNCGEN_EXCEPTION(PyThreadState *tstate, struct Nuitka_
      * Python3.7: The exception is preserved in the asyncgen object itself
      * which has a new "m_exc_state" structure just for that.
      */
+#if _DEBUG_EXCEPTIONS
+    PRINT_STRING("SAVE_ASYNCGEN_EXCEPTION: Enter\n");
+    PRINT_PUBLISHED_EXCEPTION();
+#endif
 
 #if PYTHON_VERSION < 0x3b0
     PyObject *saved_exception_type = EXC_TYPE(tstate);
@@ -113,11 +117,6 @@ static inline void SAVE_ASYNCGEN_EXCEPTION(PyThreadState *tstate, struct Nuitka_
     PyTracebackObject *saved_exception_traceback = EXC_TRACEBACK(tstate);
 #endif
 
-#if _DEBUG_EXCEPTIONS
-    PRINT_STRING("SAVE_ASYNCGEN_EXCEPTION: Enter\n");
-    PRINT_EXCEPTION(saved_exception_type, saved_exception_value, saved_exception_traceback);
-#endif
-
 #if PYTHON_VERSION < 0x370
     EXC_TYPE(tstate) = tstate->frame->f_exc_type;
     EXC_VALUE(tstate) = tstate->frame->f_exc_value;
@@ -134,7 +133,7 @@ static inline void SAVE_ASYNCGEN_EXCEPTION(PyThreadState *tstate, struct Nuitka_
 
 #if _DEBUG_EXCEPTIONS
     PRINT_STRING("SAVE_ASYNCGEN_EXCEPTION: Leave\n");
-    PRINT_EXCEPTION(EXC_TYPE(tstate), EXC_VALUE(tstate), EXC_TRACEBACK(tstate));
+    PRINT_PUBLISHED_EXCEPTION();
 #endif
 
 #if PYTHON_VERSION < 0x370
@@ -166,7 +165,11 @@ static inline void RESTORE_ASYNCGEN_EXCEPTION(PyThreadState *tstate, struct Nuit
 
 #if _DEBUG_EXCEPTIONS
     PRINT_STRING("RESTORE_ASYNCGEN_EXCEPTION: Enter\n");
+#if PYTHON_VERSION < 0x3b0
     PRINT_EXCEPTION(saved_exception_type, saved_exception_value, saved_exception_traceback);
+#else
+    _PRINT_EXCEPTION1(saved_exception_value);
+#endif
 #endif
 
 #if PYTHON_VERSION < 0x370
@@ -197,7 +200,7 @@ static inline void RESTORE_ASYNCGEN_EXCEPTION(PyThreadState *tstate, struct Nuit
 
 #if _DEBUG_EXCEPTIONS
     PRINT_STRING("RESTORE_ASYNCGEN_EXCEPTION: Leave\n");
-    PRINT_EXCEPTION(EXC_TYPE(tstate), EXC_VALUE(tstate), EXC_TRACEBACK(tstate));
+    PRINT_PUBLISHED_EXCEPTION();
 #endif
 
 #if PYTHON_VERSION < 0x3b0

nuitka/build/include/nuitka/compiled_frame.h

@@ -143,7 +143,7 @@ NUITKA_MAY_BE_UNUSED static inline bool isFrameUnusable(struct Nuitka_FrameObjec
         frame_object == NULL ||
         // Still in use
         Py_REFCNT(frame_object) > 1 ||
-#if PYTHON_VERSION < 0x340
+#if PYTHON_VERSION < 0x300
         // Last used by another thread (TODO: Could just set it when re-using)
         frame_object->m_frame.f_tstate != PyThreadState_GET() ||
 #endif
@@ -483,6 +483,7 @@ NUITKA_MAY_BE_UNUSED inline static void pushFrameStackGeneratorCompiledFrame(PyT
 #define NUITKA_TYPE_DESCRIPTION_OBJECT 'o'
 #define NUITKA_TYPE_DESCRIPTION_OBJECT_PTR 'O'
 #define NUITKA_TYPE_DESCRIPTION_BOOL 'b'
+#define NUITKA_TYPE_DESCRIPTION_NILONG 'L'
 
 #if _DEBUG_REFCOUNTS
 extern int count_active_Nuitka_Frame_Type;

nuitka/build/include/nuitka/constants.h

@@ -87,6 +87,10 @@ extern PyObject **global_constants;
 #define const_str_plain_range global_constants[29]
 // 'rb'
 #define const_str_plain_rb global_constants[29]
+// 'b'
+#define const_str_plain_b global_constants[29]
+// 'w'
+#define const_str_plain_w global_constants[29]
 // 'open'
 #define const_str_plain_open global_constants[30]
 // 'keys'
@@ -139,6 +143,8 @@ extern PyObject **global_constants;
 #define const_str_plain_isfile global_constants[42]
 // 'listdir'
 #define const_str_plain_listdir global_constants[42]
+// 'stat'
+#define const_str_plain_stat global_constants[42]
 // 'basename'
 #define const_str_plain_basename global_constants[42]
 // 'dirname'

nuitka/build/include/nuitka/debug_settings.h

@@ -0,0 +1,60 @@
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+// No guard on purpose, must include this only once for real.
+
+#ifdef _NUITKA_EXPERIMENTAL_DEBUG_FRAME
+#define _DEBUG_FRAME 1
+#else
+#define _DEBUG_FRAME 0
+#endif
+#ifdef _NUITKA_EXPERIMENTAL_DEBUG_REFRAME
+#define _DEBUG_REFRAME 1
+#else
+#define _DEBUG_REFRAME 0
+#endif
+#ifdef _NUITKA_EXPERIMENTAL_DEBUG_EXCEPTIONS
+#define _DEBUG_EXCEPTIONS 1
+#else
+#define _DEBUG_EXCEPTIONS 0
+#endif
+#ifdef _NUITKA_EXPERIMENTAL_DEBUG_GENERATOR
+#define _DEBUG_GENERATOR 1
+#else
+#define _DEBUG_GENERATOR 0
+#endif
+#ifdef _NUITKA_EXPERIMENTAL_DEBUG_COROUTINE
+#define _DEBUG_COROUTINE 1
+#else
+#define _DEBUG_COROUTINE 0
+#endif
+#ifdef _NUITKA_EXPERIMENTAL_DEBUG_ASYNCGEN
+#define _DEBUG_ASYNCGEN 1
+#else
+#define _DEBUG_ASYNCGEN 0
+#endif
+#ifdef _NUITKA_EXPERIMENTAL_DEBUG_CLASSES
+#define _DEBUG_CLASSES 1
+#else
+#define _DEBUG_CLASSES 0
+#endif
+
+#ifdef _NUITKA_EXPERIMENTAL_REPORT_REFCOUNTS
+#define _DEBUG_REFCOUNTS 1
+#else
+#define _DEBUG_REFCOUNTS 0
+#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.