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

nuitka/build/include/nuitka/allocator.h

@@ -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
+
 #ifndef __NUITKA_ALLOCATOR_H__
 #define __NUITKA_ALLOCATOR_H__
 
@@ -28,7 +13,66 @@
 #define _PyObject_GC_IS_TRACKED(obj) (1)
 #endif
 
-#if PYTHON_VERSION >= 0x380
+// The full API is available for Python 3.5 only
+#if PYTHON_VERSION >= 0x350 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_ALLOCATORS)
+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;
+extern void *python_mem_ctx;
+#else
+#define python_obj_ctx (NULL)
+#define python_mem_ctx (NULL)
+#endif
+
+extern void initNuitkaAllocators(void);
+
+// Our version of "PyObject_Malloc".
+NUITKA_MAY_BE_UNUSED static void *NuitkaObject_Malloc(size_t size) { return python_obj_malloc(python_obj_ctx, size); }
+
+// Our version of "PyMem_Malloc".
+NUITKA_MAY_BE_UNUSED static void *NuitkaMem_Malloc(size_t size) { return python_mem_malloc(python_mem_ctx, size); }
+
+// Our version of "PyMem_Calloc".
+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)
+#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
 // Need to make Py_DECREF a macro again that doesn't call an API
 static inline void _Nuitka_Py_DECREF(PyObject *ob) {
     assert(ob != NULL && ob->ob_refcnt >= 0);
@@ -84,6 +128,60 @@ 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.
+#if PYTHON_VERSION < 0x3c0
+#define Py_INCREF_IMMORTAL(value) Py_INCREF(value)
+#define Py_DECREF_IMMORTAL(value) Py_DECREF(value)
+#elif defined(_NUITKA_DEBUG_DEBUG_IMMORTAL)
+#define Py_INCREF_IMMORTAL(value) assert(Py_REFCNT(value) == _Py_IMMORTAL_REFCNT)
+#define Py_DECREF_IMMORTAL(value) assert(Py_REFCNT(value) == _Py_IMMORTAL_REFCNT)
+#else
+#define Py_INCREF_IMMORTAL(value)
+#define Py_DECREF_IMMORTAL(value)
 #endif
 
 // Macro introduced with Python3.9 or higher, make it generally available.
@@ -95,11 +193,26 @@ static inline void _Py_SET_TYPE(PyObject *ob, PyTypeObject *type) { ob->ob_type
 // After Python 3.9 this was moved into the DLL potentially, making
 // it expensive to call.
 #if PYTHON_VERSION >= 0x390
-static void Nuitka_Py_NewReference(PyObject *op) {
+static inline void Nuitka_Py_NewReferenceNoTotal(PyObject *op) { Py_SET_REFCNT(op, 1); }
+static inline void Nuitka_Py_NewReference(PyObject *op) {
 #ifdef Py_REF_DEBUG
+#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
+#if !defined(Py_GIL_DISABLED)
+    op->ob_refcnt = 1;
+#else
+    op->ob_tid = _Py_ThreadId();
+    op->_padding = 0;
+    op->ob_mutex = (PyMutex){0};
+    op->ob_gc_bits = 0;
+    op->ob_ref_local = 1;
+    op->ob_ref_shared = 0;
 #endif
-    Py_SET_REFCNT(op, 1);
 }
 #else
 #define Nuitka_Py_NewReference(op) _Py_NewReference(op)
@@ -126,7 +239,7 @@ static PyObject *Nuitka_PyType_AllocNoTrackVar(PyTypeObject *type, Py_ssize_t ni
     const size_t pre_size = Nuitka_PyType_PreHeaderSize(type);
     assert(pre_size == sizeof(PyGC_Head));
 
-    char *alloc = (char *)PyObject_Malloc(size + pre_size);
+    char *alloc = (char *)NuitkaObject_Malloc(size + pre_size);
     assert(alloc);
     PyObject *obj = (PyObject *)(alloc + pre_size);
 
@@ -161,7 +274,7 @@ static PyObject *Nuitka_PyType_AllocNoTrack(PyTypeObject *type) {
     // TODO: This ought to be static for all our types, so remove it as a call.
     const size_t pre_size = Nuitka_PyType_PreHeaderSize(type);
 
-    char *alloc = (char *)PyObject_Malloc(_PyObject_SIZE(type) + pre_size);
+    char *alloc = (char *)NuitkaObject_Malloc(_PyObject_SIZE(type) + pre_size);
     assert(alloc);
     PyObject *obj = (PyObject *)(alloc + pre_size);
 
@@ -239,4 +352,97 @@ NUITKA_MAY_BE_UNUSED static void *Nuitka_GC_New(PyTypeObject *type) {
     return op;
 }
 
+static bool inline Nuitka_GC_IS_TRACKED_X(PyObject *object) {
+    return object == NULL || _PyObject_GC_IS_TRACKED(object);
+}
+
+// To allow us marking some of our own values as immortal.
+#if PYTHON_VERSION >= 0x3c0
+static void inline Py_SET_REFCNT_IMMORTAL(PyObject *object) {
+    // Normally done only with 3.13, but it makes sense to do this.
+    if (_PyObject_IS_GC(object) && _PyObject_GC_IS_TRACKED(object)) {
+        Nuitka_GC_UnTrack(object);
+    }
+
+#ifdef Py_GIL_DISABLED
+    object->ob_tid = _Py_UNOWNED_TID;
+    object->ob_ref_local = _Py_IMMORTAL_REFCNT_LOCAL;
+    object->ob_ref_shared = 0;
+#else
+    object->ob_refcnt = _Py_IMMORTAL_REFCNT;
+#endif
+}
+#else
+#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
+//     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/include/nuitka/builtins.h

@@ -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
+
 #ifndef __NUITKA_BUILTINS_H__
 #define __NUITKA_BUILTINS_H__
 
@@ -95,3 +80,18 @@ NUITKA_MAY_BE_UNUSED static void Nuitka_SysSetObject(char const *name, PyObject
 }
 
 #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/include/nuitka/calling.h

@@ -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
+
 #ifndef __NUITKA_CALLING_H__
 #define __NUITKA_CALLING_H__
 
@@ -26,7 +11,7 @@
 // For exception test formatting and call code mostly.
 extern char const *GET_CALLABLE_NAME(PyObject *object);
 extern char const *GET_CALLABLE_DESC(PyObject *object);
-extern char const *GET_CLASS_NAME(PyObject *klass);
+extern char const *GET_CLASS_NAME(PyObject *class_object);
 extern char const *GET_INSTANCE_CLASS_NAME(PyThreadState *tstate, PyObject *instance);
 
 // Also used in generated helper code.
@@ -96,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);
@@ -121,3 +106,18 @@ extern void formatCannotInstantiateAbstractClass(PyThreadState *tstate, PyTypeOb
 #include "nuitka/helper/calling_generated.h"
 
 #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/include/nuitka/checkers.h

@@ -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
+
 #ifndef __NUITKA_CHECKERS_H__
 #define __NUITKA_CHECKERS_H__
 
@@ -37,4 +22,18 @@
 extern void CHECK_OBJECT_DEEP(PyObject *value);
 extern void CHECK_OBJECTS_DEEP(PyObject *const *values, Py_ssize_t size);
 
-#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/include/nuitka/checksum_tools.h

@@ -1,5 +1,17 @@
-//     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-//
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+#ifndef __NUITKA_CHECKSUM_TOOLS_H__
+#define __NUITKA_CHECKSUM_TOOLS_H__
+
+// This file is included from another C file, help IDEs to still parse it on
+// its own.
+#ifdef __IDE_ONLY__
+#include "nuitka/prelude.h"
+#endif
+
+extern uint32_t calcCRC32(unsigned char const *message, uint32_t size);
+
+#endif
 //     Part of "Nuitka", an optimizing Python compiler that is compatible and
 //     integrates with CPython, but also works on its own.
 //
@@ -14,20 +26,3 @@
 //     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.
-//
-#ifndef __NUITKA_CHECKSUM_TOOLS_H__
-#define __NUITKA_CHECKSUM_TOOLS_H__
-
-// This file is included from another C file, help IDEs to still parse it on
-// its own.
-#ifdef __IDE_ONLY__
-#include "nuitka/prelude.h"
-#endif
-
-extern uint32_t initCRC32(void);
-extern uint32_t updateCRC32(uint32_t crc, unsigned char const *message, uint32_t size);
-extern uint32_t finalizeCRC32(uint32_t crc);
-
-extern uint32_t calcCRC32(unsigned char const *message, uint32_t size);
-
-#endif

nuitka/build/include/nuitka/compiled_asyncgen.h

@@ -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
+
 #ifndef __NUITKA_COMPILED_ASYNCGEN_H__
 #define __NUITKA_COMPILED_ASYNCGEN_H__
 
@@ -42,7 +27,7 @@ struct Nuitka_AsyncgenObject {
     PyObject *m_module;
 
     PyObject *m_qualname;
-    PyObject *m_yieldfrom;
+    PyObject *m_yield_from;
 
     // Weak references are supported for asyncgen objects in CPython.
     PyObject *m_weakrefs;
@@ -119,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);
@@ -128,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;
@@ -149,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
@@ -181,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
@@ -212,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
@@ -274,3 +262,18 @@ extern int count_released_Nuitka_AsyncgenAthrow_Type;
 #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/include/nuitka/compiled_cell.h

@@ -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
+
 #ifndef __NUITKA_COMPILED_CELL_H__
 #define __NUITKA_COMPILED_CELL_H__
 
@@ -35,7 +20,7 @@ struct Nuitka_CellObject {
 };
 
 // Create cell with out value, and with or without reference given.
-extern struct Nuitka_CellObject *Nuitka_Cell_Empty(void);
+extern struct Nuitka_CellObject *Nuitka_Cell_NewEmpty(void);
 extern struct Nuitka_CellObject *Nuitka_Cell_New0(PyObject *value);
 extern struct Nuitka_CellObject *Nuitka_Cell_New1(PyObject *value);
 
@@ -46,4 +31,34 @@ extern struct Nuitka_CellObject *Nuitka_Cell_New1(PyObject *value);
 #define Nuitka_Cell_GET(cell)                                                                                          \
     (CHECK_OBJECT(cell), assert(Nuitka_Cell_Check((PyObject *)cell)), (((struct Nuitka_CellObject *)(cell))->ob_ref))
 #endif
+
+#if _DEBUG_REFCOUNTS
+extern int count_active_Nuitka_Cell_Type;
+extern int count_allocated_Nuitka_Cell_Type;
+extern int count_released_Nuitka_Cell_Type;
 #endif
+
+NUITKA_MAY_BE_UNUSED static inline void Nuitka_Cell_SET(struct Nuitka_CellObject *cell_object, PyObject *value) {
+    CHECK_OBJECT_X(value);
+    CHECK_OBJECT(cell_object);
+
+    assert(Nuitka_Cell_Check((PyObject *)cell_object));
+    cell_object->ob_ref = value;
+}
+
+#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.