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

nuitka/build/include/nuitka/compiled_coroutine.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_COROUTINE_H__
 #define __NUITKA_COMPILED_COROUTINE_H__
 
@@ -42,7 +27,7 @@ struct Nuitka_CoroutineObject {
     PyObject *m_module;
 
     PyObject *m_qualname;
-    PyObject *m_yieldfrom;
+    PyObject *m_yield_from;
 
     // Weak references are supported for coroutine objects in CPython.
     PyObject *m_weakrefs;
@@ -268,3 +253,18 @@ extern int count_released_Nuitka_AIterWrapper_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_frame.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_FRAME_H__
 #define __NUITKA_COMPILED_FRAME_H__
 
@@ -62,51 +47,70 @@ extern struct Nuitka_FrameObject *MAKE_CLASS_FRAME(PyThreadState *tstate, PyCode
 // Create a code object for the given filename and function name
 
 #if PYTHON_VERSION < 0x300
-#define MAKE_CODE_OBJECT(filename, line, flags, function_name, function_qualname, argnames, freevars, arg_count,       \
+#define MAKE_CODE_OBJECT(filename, line, flags, function_name, function_qualname, arg_names, free_vars, arg_count,     \
                          kw_only_count, pos_only_count)                                                                \
-    makeCodeObject(filename, line, flags, function_name, argnames, freevars, arg_count)
+    makeCodeObject(filename, line, flags, function_name, arg_names, free_vars, arg_count)
 extern PyCodeObject *makeCodeObject(PyObject *filename, int line, int flags, PyObject *function_name,
-                                    PyObject *argnames, PyObject *freevars, int arg_count);
+                                    PyObject *arg_names, PyObject *free_vars, int arg_count);
 #elif PYTHON_VERSION < 0x380
-#define MAKE_CODE_OBJECT(filename, line, flags, function_name, function_qualname, argnames, freevars, arg_count,       \
+#define MAKE_CODE_OBJECT(filename, line, flags, function_name, function_qualname, arg_names, free_vars, arg_count,     \
                          kw_only_count, pos_only_count)                                                                \
-    makeCodeObject(filename, line, flags, function_name, argnames, freevars, arg_count, kw_only_count)
+    makeCodeObject(filename, line, flags, function_name, arg_names, free_vars, arg_count, kw_only_count)
 extern PyCodeObject *makeCodeObject(PyObject *filename, int line, int flags, PyObject *function_name,
-                                    PyObject *argnames, PyObject *freevars, int arg_count, int kw_only_count);
+                                    PyObject *arg_names, PyObject *free_vars, int arg_count, int kw_only_count);
 #elif PYTHON_VERSION < 0x3b0
-#define MAKE_CODE_OBJECT(filename, line, flags, function_name, function_qualname, argnames, freevars, arg_count,       \
+#define MAKE_CODE_OBJECT(filename, line, flags, function_name, function_qualname, arg_names, free_vars, arg_count,     \
                          kw_only_count, pos_only_count)                                                                \
-    makeCodeObject(filename, line, flags, function_name, argnames, freevars, arg_count, kw_only_count, pos_only_count)
+    makeCodeObject(filename, line, flags, function_name, arg_names, free_vars, arg_count, kw_only_count, pos_only_count)
 extern PyCodeObject *makeCodeObject(PyObject *filename, int line, int flags, PyObject *function_name,
-                                    PyObject *argnames, PyObject *freevars, int arg_count, int kw_only_count,
+                                    PyObject *arg_names, PyObject *free_vars, int arg_count, int kw_only_count,
                                     int pos_only_count);
 #else
-#define MAKE_CODE_OBJECT(filename, line, flags, function_name, function_qualname, argnames, freevars, arg_count,       \
+#define MAKE_CODE_OBJECT(filename, line, flags, function_name, function_qualname, arg_names, free_vars, arg_count,     \
                          kw_only_count, pos_only_count)                                                                \
-    makeCodeObject(filename, line, flags, function_name, function_qualname, argnames, freevars, arg_count,             \
+    makeCodeObject(filename, line, flags, function_name, function_qualname, arg_names, free_vars, arg_count,           \
                    kw_only_count, pos_only_count)
 extern PyCodeObject *makeCodeObject(PyObject *filename, int line, int flags, PyObject *function_name,
-                                    PyObject *function_qualname, PyObject *argnames, PyObject *freevars, int arg_count,
-                                    int kw_only_count, int pos_only_count);
+                                    PyObject *function_qualname, PyObject *arg_names, PyObject *free_vars,
+                                    int arg_count, int kw_only_count, int pos_only_count);
 #endif
 
 NUITKA_MAY_BE_UNUSED static inline bool isFakeCodeObject(PyCodeObject *code) {
 #if PYTHON_VERSION < 0x300
     return code->co_code == const_str_empty;
-#elif PYTHON_VERSION < 0x3B0
-    return code->co_code == const_str_empty;
+#elif PYTHON_VERSION < 0x3b0
+    return code->co_code == const_bytes_empty;
 #else
-    return _PyCode_CODE(code)[0] == 0;
+    // Starting for Python3.11, we just proper bytecode that raises
+    // "RuntimeError" itself, so this function is only used to
+    // optimize checks away.
+    return false;
 #endif
 }
 
 extern PyTypeObject Nuitka_Frame_Type;
 
-static inline bool Nuitka_Frame_Check(PyObject *object) {
+static inline bool Nuitka_Frame_CheckExact(PyObject *object) {
     CHECK_OBJECT(object);
     return Py_TYPE(object) == &Nuitka_Frame_Type;
 }
 
+static inline bool Nuitka_Frame_Check(PyObject *object) {
+    assert(object);
+
+    if (!_PyObject_GC_IS_TRACKED(object)) {
+        return false;
+    }
+
+    CHECK_OBJECT(object);
+
+    if (Nuitka_Frame_CheckExact(object)) {
+        return true;
+    }
+
+    return strcmp(Py_TYPE(object)->tp_name, "compiled_frame") == 0;
+}
+
 struct Nuitka_FrameObject {
     PyFrameObject m_frame;
 
@@ -139,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
@@ -166,10 +170,20 @@ extern int count_hit_frame_cache_instances;
 extern void dumpFrameStack(void);
 #endif
 
+#if PYTHON_VERSION >= 0x3b0
+inline static PyCodeObject *Nuitka_InterpreterFrame_GetCodeObject(_PyInterpreterFrame *frame) {
+#if PYTHON_VERSION < 0x3d0
+    return frame->f_code;
+#else
+    return (PyCodeObject *)frame->f_executable;
+#endif
+}
+#endif
+
 inline static PyCodeObject *Nuitka_Frame_GetCodeObject(PyFrameObject *frame) {
 #if PYTHON_VERSION >= 0x3b0
     assert(frame->f_frame);
-    return frame->f_frame->f_code;
+    return Nuitka_InterpreterFrame_GetCodeObject(frame->f_frame);
 #else
     return frame->f_code;
 #endif
@@ -180,6 +194,7 @@ inline static void assertPythonFrameObject(PyFrameObject *frame_object) {
     // TODO: Need to do this manually, as this is making frame caching code
     // vulnerable to mistakes, but so far the compiled frame type is private
     // assert(PyObject_IsInstance((PyObject *)frame_object, (PyObject *)&PyFrame_Type));
+    CHECK_OBJECT(frame_object);
 
     CHECK_CODE_OBJECT(Nuitka_Frame_GetCodeObject(frame_object));
 }
@@ -195,7 +210,7 @@ inline static void assertFrameObject(struct Nuitka_FrameObject *frame_object) {
 }
 
 inline static void assertThreadFrameObject(Nuitka_ThreadStateFrameType *frame) {
-#if PYTHON_VERSION < 0x3B0
+#if PYTHON_VERSION < 0x3b0
     assertPythonFrameObject(frame);
 #else
     // For uncompiled frames of Python 3.11 these often do not exist. TODO: Figure
@@ -206,11 +221,11 @@ inline static void assertThreadFrameObject(Nuitka_ThreadStateFrameType *frame) {
 #endif
 }
 
-// Mark frame as currently executed. Starting with Python 3.4 that means it
+// Mark frame as currently executed. Starting with Python 3 that means it
 // can or cannot be cleared, or should lead to a generator close. For Python2
 // this is a no-op. Using a define to spare the compile from inlining an empty
 // function.
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
 
 #if PYTHON_VERSION < 0x3b0
 
@@ -238,7 +253,7 @@ static inline void Nuitka_Frame_MarkAsExecuting(struct Nuitka_FrameObject *frame
 #define Nuitka_Frame_MarkAsExecuting(frame) ;
 #endif
 
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
 static inline void Nuitka_Frame_MarkAsNotExecuting(struct Nuitka_FrameObject *frame) {
     CHECK_OBJECT(frame);
 #if PYTHON_VERSION >= 0x3b0
@@ -254,7 +269,7 @@ static inline void Nuitka_Frame_MarkAsNotExecuting(struct Nuitka_FrameObject *fr
 #define Nuitka_PythonFrame_MarkAsExecuting(frame) ;
 #endif
 
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
 static inline bool Nuitka_Frame_IsExecuting(struct Nuitka_FrameObject *frame) {
     CHECK_OBJECT(frame);
 #if PYTHON_VERSION >= 0x3b0
@@ -267,15 +282,24 @@ static inline bool Nuitka_Frame_IsExecuting(struct Nuitka_FrameObject *frame) {
 }
 #endif
 
-#if PYTHON_VERSION >= 0x3B0
+#if PYTHON_VERSION >= 0x3b0
+
+#if PYTHON_VERSION < 0x3d0
+#define CURRENT_TSTATE_INTERPRETER_FRAME(tstate) tstate->cframe->current_frame
+#else
+#define CURRENT_TSTATE_INTERPRETER_FRAME(tstate) tstate->current_frame
+#endif
+
 NUITKA_MAY_BE_UNUSED inline static void pushFrameStackInterpreterFrame(PyThreadState *tstate,
                                                                        _PyInterpreterFrame *interpreter_frame) {
-    _PyInterpreterFrame *old = tstate->cframe->current_frame;
+    _PyInterpreterFrame *old = CURRENT_TSTATE_INTERPRETER_FRAME(tstate);
     interpreter_frame->previous = old;
-    tstate->cframe->current_frame = interpreter_frame;
+    CURRENT_TSTATE_INTERPRETER_FRAME(tstate) = interpreter_frame;
 
-    if (old != NULL && interpreter_frame->frame_obj) {
+    if (old != NULL && !_PyFrame_IsIncomplete(old) && interpreter_frame->frame_obj) {
         interpreter_frame->frame_obj->f_back = old->frame_obj;
+        CHECK_OBJECT_X(old->frame_obj);
+
         Py_XINCREF(old->frame_obj);
     }
 }
@@ -293,7 +317,7 @@ NUITKA_MAY_BE_UNUSED inline static void pushFrameStackPythonFrame(PyThreadState
 
     if (old) {
         assertPythonFrameObject(old);
-        CHECK_CODE_OBJECT(old->f_code);
+        CHECK_CODE_OBJECT(Nuitka_Frame_GetCodeObject(old));
     }
 
     // No recursion with identical frames allowed, assert against it.
@@ -304,7 +328,6 @@ NUITKA_MAY_BE_UNUSED inline static void pushFrameStackPythonFrame(PyThreadState
 
     // Transfer ownership of old frame.
     if (old != NULL) {
-
         frame_object->f_back = old;
     }
 
@@ -348,13 +371,13 @@ NUITKA_MAY_BE_UNUSED inline static void popFrameStack(PyThreadState *tstate) {
     Nuitka_Frame_MarkAsNotExecuting(frame_object);
     Py_DECREF(frame_object);
 #else
-    assert(tstate->cframe);
-    assert(tstate->cframe->current_frame);
+    assert(CURRENT_TSTATE_INTERPRETER_FRAME(tstate));
 
-    struct Nuitka_FrameObject *frame_object = (struct Nuitka_FrameObject *)tstate->cframe->current_frame->frame_obj;
+    struct Nuitka_FrameObject *frame_object =
+        (struct Nuitka_FrameObject *)CURRENT_TSTATE_INTERPRETER_FRAME(tstate)->frame_obj;
     CHECK_OBJECT(frame_object);
 
-    tstate->cframe->current_frame = tstate->cframe->current_frame->previous;
+    CURRENT_TSTATE_INTERPRETER_FRAME(tstate) = CURRENT_TSTATE_INTERPRETER_FRAME(tstate)->previous;
 
     Nuitka_Frame_MarkAsNotExecuting(frame_object);
 
@@ -373,7 +396,7 @@ NUITKA_MAY_BE_UNUSED inline static void popFrameStack(PyThreadState *tstate) {
 
 // TODO: These can be moved to private code, once all C library is included by
 // compiled code helpers, but generators are currently not.
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
 NUITKA_MAY_BE_UNUSED static void Nuitka_SetFrameGenerator(struct Nuitka_FrameObject *nuitka_frame,
                                                           PyObject *generator) {
 #if PYTHON_VERSION < 0x3b0
@@ -401,7 +424,7 @@ NUITKA_MAY_BE_UNUSED static PyCodeObject *Nuitka_GetFrameCodeObject(struct Nuitk
 #if PYTHON_VERSION < 0x3b0
     return nuitka_frame->m_frame.f_code;
 #else
-    return nuitka_frame->m_interpreter_frame.f_code;
+    return Nuitka_InterpreterFrame_GetCodeObject(&nuitka_frame->m_interpreter_frame);
 #endif
 }
 
@@ -427,7 +450,7 @@ NUITKA_MAY_BE_UNUSED static Nuitka_ThreadStateFrameType *_Nuitka_GetThreadStateF
 #if PYTHON_VERSION < 0x3b0
     return tstate->frame;
 #else
-    return tstate->cframe->current_frame;
+    return CURRENT_TSTATE_INTERPRETER_FRAME(tstate);
 #endif
 }
 
@@ -460,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;
@@ -468,3 +492,18 @@ extern int count_released_Nuitka_Frame_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_function.h

@@ -1,26 +1,11 @@
-//     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_FUNCTION_H__
 #define __NUITKA_COMPILED_FUNCTION_H__
 
 #ifdef __IDE_ONLY__
-#include "Python.h"
-#include "frameobject.h"
+#include <Python.h>
+#include <frameobject.h>
 #endif
 
 // Compiled function type.
@@ -86,6 +71,10 @@ struct Nuitka_FunctionObject {
     PyObject *m_qualname;
 #endif
 
+#if PYTHON_VERSION >= 0x3c0
+    PyObject *m_type_params;
+#endif
+
     // Constant return value to use.
     PyObject *m_constant_return_value;
 
@@ -108,7 +97,7 @@ extern struct Nuitka_FunctionObject *Nuitka_Function_New(function_impl_code c_co
 #else
 extern struct Nuitka_FunctionObject *Nuitka_Function_New(function_impl_code c_code, PyObject *name, PyObject *qualname,
                                                          PyCodeObject *code_object, PyObject *defaults,
-                                                         PyObject *kwdefaults, PyObject *annotations, PyObject *module,
+                                                         PyObject *kw_defaults, PyObject *annotations, PyObject *module,
                                                          PyObject *doc, struct Nuitka_CellObject **closure,
                                                          Py_ssize_t closure_given);
 #endif
@@ -119,6 +108,18 @@ extern void Nuitka_Function_EnableConstReturnFalse(struct Nuitka_FunctionObject
 
 extern void Nuitka_Function_EnableConstReturnGeneric(struct Nuitka_FunctionObject *function, PyObject *value);
 
+#ifdef _NUITKA_PLUGIN_DILL_ENABLED
+extern int Nuitka_Function_GetFunctionCodeIndex(struct Nuitka_FunctionObject *function,
+                                                function_impl_code const *function_table);
+extern struct Nuitka_FunctionObject *
+Nuitka_Function_CreateFunctionViaCodeIndex(PyObject *module, PyObject *function_qualname, PyObject *function_index,
+                                           PyObject *code_object_desc, PyObject *constant_return_value,
+                                           PyObject *defaults, PyObject *kw_defaults, PyObject *doc, PyObject *closure,
+                                           function_impl_code const *function_table, int function_table_size);
+extern PyObject *Nuitka_Function_ExtractCodeObjectDescription(PyThreadState *tstate,
+                                                              struct Nuitka_FunctionObject *function);
+#endif
+
 static inline bool Nuitka_Function_Check(PyObject *object) { return Py_TYPE(object) == &Nuitka_Function_Type; }
 
 static inline PyObject *Nuitka_Function_GetName(PyObject *object) {
@@ -147,4 +148,25 @@ PyObject *Nuitka_CallMethodFunctionPosArgsKwArgs(PyThreadState *tstate, struct N
                                                  PyObject *object, PyObject *const *args, Py_ssize_t args_size,
                                                  PyObject *kw);
 
+#if _DEBUG_REFCOUNTS
+extern int count_active_Nuitka_Function_Type;
+extern int count_allocated_Nuitka_Function_Type;
+extern int count_released_Nuitka_Function_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_generator.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_GENERATOR_H__
 #define __NUITKA_COMPILED_GENERATOR_H__
 
@@ -67,7 +52,7 @@ struct Nuitka_GeneratorObject {
 #endif
 #if PYTHON_VERSION >= 0x300
     // The value currently yielded from.
-    PyObject *m_yieldfrom;
+    PyObject *m_yield_from;
 #endif
 
     // Weak references are supported for generator objects in CPython.
@@ -257,4 +242,25 @@ NUITKA_MAY_BE_UNUSED static void DROP_GENERATOR_EXCEPTION(struct Nuitka_Generato
 #endif
 }
 
+#if _DEBUG_REFCOUNTS
+extern int count_active_Nuitka_Generator_Type;
+extern int count_allocated_Nuitka_Generator_Type;
+extern int count_released_Nuitka_Generator_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_method.h

@@ -1,20 +1,4 @@
-//     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_METHOD_H__
 #define __NUITKA_COMPILED_METHOD_H__
@@ -48,8 +32,23 @@ struct Nuitka_MethodObject {
 extern PyTypeObject Nuitka_Method_Type;
 
 // Make a method out of a function.
-extern PyObject *Nuitka_Method_New(struct Nuitka_FunctionObject *function, PyObject *object, PyObject *klass);
+extern PyObject *Nuitka_Method_New(struct Nuitka_FunctionObject *function, PyObject *object, PyObject *class_object);
 
 static inline bool Nuitka_Method_Check(PyObject *object) { return Py_TYPE(object) == &Nuitka_Method_Type; }
 
 #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/constants.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_CONSTANTS_H__
 #define __NUITKA_CONSTANTS_H__
 
@@ -102,10 +87,16 @@ 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'
 #define const_str_plain_keys global_constants[30]
+// 'get'
+#define const_str_plain_get global_constants[30]
 // 'as_file'
 #define const_str_plain_as_file global_constants[30]
 // 'register'
@@ -130,6 +121,10 @@ extern PyObject **global_constants;
 #define const_str_plain_classmethod global_constants[36]
 // 'name'
 #define const_str_plain_name global_constants[37]
+// 'ascii'
+#define const_str_plain_ascii global_constants[37]
+// 'punycode'
+#define const_str_plain_punycode global_constants[37]
 // 'globals'
 #define const_str_plain_globals global_constants[38]
 // 'locals'
@@ -148,18 +143,26 @@ 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'
+#define const_str_plain_dirname global_constants[42]
 // 'abspath'
 #define const_str_plain_abspath global_constants[42]
 // 'isabs'
 #define const_str_plain_isabs global_constants[42]
+// 'normpath'
+#define const_str_plain_normpath global_constants[42]
 // 'path'
 #define const_str_plain_path global_constants[42]
 // '__newobj__'
 #define const_str_plain___newobj__ global_constants[44]
 // '.'
 #define const_str_dot global_constants[45]
+// '_'
+#define const_str_underscore global_constants[45]
 // '__getattr__'
 #define const_str_plain___getattr__ global_constants[46]
 // '__setattr__'
@@ -225,4 +228,18 @@ extern PyObject **global_constants;
 #include "__constants.h"
 #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.