Nuitka-winsvc 2.7.7__cp313-cp313-win_amd64.whl

nuitka/build/include/nuitka/compiled_generator.h

@@ -0,0 +1,287 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+#ifndef __NUITKA_COMPILED_GENERATOR_H__
+#define __NUITKA_COMPILED_GENERATOR_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
+
+// Compiled generator function type.
+
+// Another cornerstone of the integration into CPython. Try to behave as well as
+// normal generator objects do or even better.
+
+// Status of the generator object.
+#ifdef __cplusplus
+enum Generator_Status {
+    status_Unused,  // Not used so far
+    status_Running, // Running, used but didn't stop yet
+    status_Finished // Stopped, no more values to come
+};
+#else
+typedef int Generator_Status;
+static const int status_Unused = 0;
+static const int status_Running = 1;
+static const int status_Finished = 2;
+#endif
+
+// We use this even before Python3.10
+#if PYTHON_VERSION < 0x3a0
+typedef enum {
+    PYGEN_RETURN = 0,
+    PYGEN_ERROR = -1,
+    PYGEN_NEXT = 1,
+} PySendResult;
+#endif
+
+// The Nuitka_GeneratorObject is the storage associated with a compiled
+// generator object instance of which there can be many for each code.
+struct Nuitka_GeneratorObject {
+    /* Python object folklore: */
+    PyObject_VAR_HEAD
+
+        PyObject *m_name;
+
+    // TODO: Only to make traceback for non-started throw
+    PyObject *m_module;
+
+#if PYTHON_VERSION >= 0x350
+    PyObject *m_qualname;
+#endif
+#if PYTHON_VERSION >= 0x300
+    // The value currently yielded from.
+    PyObject *m_yield_from;
+#endif
+
+    // Weak references are supported for generator objects in CPython.
+    PyObject *m_weakrefs;
+
+    int m_running;
+
+    void *m_code;
+
+    struct Nuitka_FrameObject *m_frame;
+    PyCodeObject *m_code_object;
+
+    // Was it ever used, is it still running, or already finished.
+    Generator_Status m_status;
+
+#if PYTHON_VERSION >= 0x370
+    struct Nuitka_ExceptionStackItem m_exc_state;
+#endif
+
+#if PYTHON_VERSION >= 0x300
+    struct Nuitka_ExceptionStackItem m_resume_exception;
+#endif
+
+    // The label index to resume after yield.
+    int m_yield_return_index;
+
+    // Returned value if yielded value is NULL, is
+    // NULL if not a return
+#if PYTHON_VERSION >= 0x300
+    PyObject *m_returned;
+#endif
+
+    // A kind of uuid for the generator object, used in comparisons.
+    long m_counter;
+
+    /* The heap of generator objects at run time. */
+    void *m_heap_storage;
+
+    /* Closure variables given, if any, we reference cells here. The last
+     * part is dynamically allocated, the array size differs per generator
+     * and includes the heap storage.
+     */
+    Py_ssize_t m_closure_given;
+    struct Nuitka_CellObject *m_closure[1];
+};
+
+extern PyTypeObject Nuitka_Generator_Type;
+
+typedef PyObject *(*generator_code)(PyThreadState *tstate, struct Nuitka_GeneratorObject *, PyObject *);
+
+extern PyObject *Nuitka_Generator_New(generator_code code, PyObject *module, PyObject *name,
+#if PYTHON_VERSION >= 0x350
+                                      PyObject *qualname,
+#endif
+                                      PyCodeObject *code_object, struct Nuitka_CellObject **closure,
+                                      Py_ssize_t closure_given, Py_ssize_t heap_storage_size);
+
+extern PyObject *Nuitka_Generator_NewEmpty(PyObject *module, PyObject *name,
+#if PYTHON_VERSION >= 0x350
+                                           PyObject *qualname,
+#endif
+                                           PyCodeObject *code_object, struct Nuitka_CellObject **closure,
+                                           Py_ssize_t closure_given);
+
+extern PyObject *Nuitka_Generator_qiter(PyThreadState *tstate, struct Nuitka_GeneratorObject *generator,
+                                        bool *finished);
+
+static inline bool Nuitka_Generator_Check(PyObject *object) { return Py_TYPE(object) == &Nuitka_Generator_Type; }
+
+static inline PyObject *Nuitka_Generator_GetName(PyObject *object) {
+    return ((struct Nuitka_GeneratorObject *)object)->m_name;
+}
+
+static inline void SAVE_GENERATOR_EXCEPTION(PyThreadState *tstate, struct Nuitka_GeneratorObject *generator) {
+    /* Before Python3.7: When yielding from an exception handler in Python3,
+     * the exception preserved to the frame is restored, while the current one
+     * is put as there.
+     *
+     * Python3.7: The exception is preserved in the generator object itself
+     * which has a new "m_exc_state" structure just for that.
+     */
+
+#if _DEBUG_EXCEPTIONS
+    PRINT_STRING("SAVE_GENERATOR_EXCEPTION: Saving: ");
+    PRINT_PUBLISHED_EXCEPTION();
+#endif
+
+#if PYTHON_VERSION < 0x3b0
+    PyObject *saved_exception_type = EXC_TYPE(tstate);
+#endif
+    PyObject *saved_exception_value = EXC_VALUE(tstate);
+#if PYTHON_VERSION < 0x3b0
+    PyTracebackObject *saved_exception_traceback = EXC_TRACEBACK(tstate);
+#endif
+
+#if PYTHON_VERSION < 0x370
+    EXC_TYPE(tstate) = tstate->frame->f_exc_type;
+    EXC_VALUE(tstate) = tstate->frame->f_exc_value;
+    SET_EXC_TRACEBACK(tstate, tstate->frame->f_exc_traceback);
+#else
+#if PYTHON_VERSION < 0x3b0
+    EXC_TYPE(tstate) = generator->m_exc_state.exception_type;
+#endif
+    EXC_VALUE(tstate) = generator->m_exc_state.exception_value;
+#if PYTHON_VERSION < 0x3b0
+    SET_EXC_TRACEBACK(tstate, generator->m_exc_state.exception_tb);
+#endif
+#endif
+
+#if _DEBUG_EXCEPTIONS
+    PRINT_STRING("SAVE_GENERATOR_EXCEPTION: Restored: ");
+    PRINT_PUBLISHED_EXCEPTION();
+#endif
+
+#if PYTHON_VERSION < 0x370
+    tstate->frame->f_exc_type = saved_exception_type;
+    tstate->frame->f_exc_value = saved_exception_value;
+    tstate->frame->f_exc_traceback = (PyObject *)saved_exception_traceback;
+#else
+#if PYTHON_VERSION < 0x3b0
+    generator->m_exc_state.exception_type = saved_exception_type;
+#endif
+    generator->m_exc_state.exception_value = saved_exception_value;
+#if PYTHON_VERSION < 0x3b0
+    generator->m_exc_state.exception_tb = (PyTracebackObject *)saved_exception_traceback;
+#endif
+#endif
+}
+
+static inline void RESTORE_GENERATOR_EXCEPTION(PyThreadState *tstate, struct Nuitka_GeneratorObject *generator) {
+    // When returning from yield, the exception of the frame is preserved, and
+    // the one that enters should be there.
+
+#if _DEBUG_EXCEPTIONS
+    PRINT_STRING("RESTORE_GENERATOR_EXCEPTION: Replacing :");
+    PRINT_PUBLISHED_EXCEPTION();
+#endif
+
+#if PYTHON_VERSION < 0x3b0
+    PyObject *saved_exception_type = EXC_TYPE(tstate);
+#endif
+    PyObject *saved_exception_value = EXC_VALUE(tstate);
+#if PYTHON_VERSION < 0x3b0
+    PyTracebackObject *saved_exception_traceback = EXC_TRACEBACK(tstate);
+#endif
+
+#if PYTHON_VERSION < 0x370
+    EXC_TYPE(tstate) = tstate->frame->f_exc_type;
+    EXC_VALUE(tstate) = tstate->frame->f_exc_value;
+    SET_EXC_TRACEBACK(tstate, tstate->frame->f_exc_traceback);
+
+    tstate->frame->f_exc_type = saved_exception_type;
+    tstate->frame->f_exc_value = saved_exception_value;
+    tstate->frame->f_exc_traceback = (PyObject *)saved_exception_traceback;
+#else
+#if PYTHON_VERSION < 0x3b0
+    EXC_TYPE(tstate) = generator->m_exc_state.exception_type;
+#endif
+    EXC_VALUE(tstate) = generator->m_exc_state.exception_value;
+#if PYTHON_VERSION < 0x3b0
+    SET_EXC_TRACEBACK(tstate, generator->m_exc_state.exception_tb);
+#endif
+
+#if PYTHON_VERSION < 0x3b0
+    generator->m_exc_state.exception_type = saved_exception_type;
+#endif
+    generator->m_exc_state.exception_value = saved_exception_value;
+#if PYTHON_VERSION < 0x3b0
+    generator->m_exc_state.exception_tb = (PyTracebackObject *)saved_exception_traceback;
+#endif
+#endif
+
+#if _DEBUG_EXCEPTIONS
+    PRINT_STRING("RESTORE_GENERATOR_EXCEPTION: Restored:");
+    PRINT_PUBLISHED_EXCEPTION();
+#endif
+}
+
+// Functions to preserver and restore from heap area temporary values during
+// yield/yield from/await exits of generator functions.
+extern void Nuitka_PreserveHeap(void *dest, ...);
+extern void Nuitka_RestoreHeap(void *source, ...);
+
+NUITKA_MAY_BE_UNUSED static void STORE_GENERATOR_EXCEPTION(PyThreadState *tstate,
+                                                           struct Nuitka_GeneratorObject *generator) {
+#if PYTHON_VERSION < 0x3b0
+    EXC_TYPE_F(generator) = EXC_TYPE(tstate);
+    if (EXC_TYPE_F(generator) == Py_None) {
+        EXC_TYPE_F(generator) = NULL;
+    }
+    Py_XINCREF(EXC_TYPE_F(generator));
+#endif
+    EXC_VALUE_F(generator) = EXC_VALUE(tstate);
+    Py_XINCREF(EXC_VALUE_F(generator));
+#if PYTHON_VERSION < 0x3b0
+    ASSIGN_EXC_TRACEBACK_F(generator, EXC_TRACEBACK(tstate));
+    Py_XINCREF(EXC_TRACEBACK_F(generator));
+#endif
+}
+
+NUITKA_MAY_BE_UNUSED static void DROP_GENERATOR_EXCEPTION(struct Nuitka_GeneratorObject *generator) {
+#if PYTHON_VERSION < 0x3b0
+    Py_CLEAR(EXC_TYPE_F(generator));
+#endif
+    Py_CLEAR(EXC_VALUE_F(generator));
+#if PYTHON_VERSION < 0x3b0
+    Py_CLEAR(EXC_TRACEBACK_F(generator));
+#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

@@ -0,0 +1,54 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+#ifndef __NUITKA_COMPILED_METHOD_H__
+#define __NUITKA_COMPILED_METHOD_H__
+
+// Compiled function and compile generator types may be referenced.
+#include "compiled_function.h"
+#include "compiled_generator.h"
+
+// The backbone of the integration into CPython. Try to behave as well as normal
+// method objects, or even better.
+
+// The Nuitka_MethodObject is the storage associated with a compiled method
+// instance of which there can be many for each code.
+
+struct Nuitka_MethodObject {
+    /* Python object folklore: */
+    PyObject_HEAD
+
+        struct Nuitka_FunctionObject *m_function;
+
+    PyObject *m_weakrefs;
+
+    PyObject *m_object;
+    PyObject *m_class;
+
+#if PYTHON_VERSION >= 0x380
+    vectorcallfunc m_vectorcall;
+#endif
+};
+
+extern PyTypeObject Nuitka_Method_Type;
+
+// Make a method out of a function.
+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

@@ -0,0 +1,251 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+#ifndef __NUITKA_CONSTANTS_H__
+#define __NUITKA_CONSTANTS_H__
+
+// Generated.
+// TODO: Move generated ones to separate file.
+#ifdef __IDE_ONLY__
+extern PyObject **global_constants;
+// ()
+#define const_tuple_empty global_constants[1]
+// {}
+#define const_dict_empty global_constants[2]
+// 0
+#define const_int_0 global_constants[3]
+// 1
+#define const_int_pos_1 global_constants[4]
+// -1
+#define const_int_neg_1 global_constants[5]
+// 0.0
+#define const_float_0_0 global_constants[6]
+// -0.0
+#define const_float_minus_0_0 global_constants[7]
+// 1.0
+#define const_float_1_0 global_constants[8]
+// -1.0
+#define const_float_minus_1_0 global_constants[9]
+// ''
+#define const_str_empty global_constants[10]
+// b''
+#define const_bytes_empty global_constants[10]
+// '__module__'
+#define const_str_plain___module__ global_constants[11]
+// '__nuitka__'
+#define const_str_plain___nuitka__ global_constants[11]
+// '__class__'
+#define const_str_plain___class__ global_constants[12]
+// '__class_getitem__'
+#define const_str_plain___class_getitem__ global_constants[12]
+// '__name__'
+#define const_str_plain___name__ global_constants[13]
+// '__main__'
+#define const_str_plain___main__ global_constants[13]
+// '__package__'
+#define const_str_plain___package__ global_constants[14]
+// '__metaclass__'
+#define const_str_plain___metaclass__ global_constants[15]
+// '__abstractmethods__'
+#define const_str_plain___abstractmethods__ global_constants[15]
+// '__dict__'
+#define const_str_plain___dict__ global_constants[16]
+// '__doc__'
+#define const_str_plain___doc__ global_constants[17]
+// '__file__'
+#define const_str_plain___file__ global_constants[18]
+// '__path__'
+#define const_str_plain___path__ global_constants[19]
+// '__enter__'
+#define const_str_plain___enter__ global_constants[20]
+// '__aenter__'
+#define const_str_plain___aenter__ global_constants[20]
+// '__exit__'
+#define const_str_plain___exit__ global_constants[21]
+// '__aexit__'
+#define const_str_plain___aexit__ global_constants[21]
+// '__builtins__'
+#define const_str_plain___builtins__ global_constants[22]
+// '__all__'
+#define const_str_plain___all__ global_constants[23]
+// '__cmp__'
+#define const_str_plain___cmp__ global_constants[24]
+// '__init__'
+#define const_str_plain___init__ global_constants[24]
+// '__iter__'
+#define const_str_plain___iter__ global_constants[25]
+// '__subclasscheck__'
+#define const_str_plain___subclasscheck__ global_constants[25]
+// '__compiled__'
+#define const_str_plain___compiled__ global_constants[26]
+// 'inspect'
+#define const_str_plain_inspect global_constants[27]
+// 'compile'
+#define const_str_plain_compile global_constants[28]
+// 'getattr'
+#define const_str_plain_getattr global_constants[28]
+// 'range'
+#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]
+// 'r'
+#define const_str_plain_r 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'
+#define const_str_plain_register global_constants[30]
+// 'close'
+#define const_str_plain_close global_constants[30]
+// 'throw'
+#define const_str_plain_throw global_constants[30]
+// 'send'
+#define const_str_plain_send global_constants[30]
+// 'sum'
+#define const_str_plain_sum global_constants[31]
+// 'format'
+#define const_str_plain_format global_constants[32]
+// '__import__'
+#define const_str_plain___import__ global_constants[33]
+// 'bytearray'
+#define const_str_plain_bytearray global_constants[34]
+// 'staticmethod'
+#define const_str_plain_staticmethod global_constants[35]
+// 'classmethod'
+#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'
+#define const_str_plain_locals global_constants[39]
+// 'fromlist'
+#define const_str_plain_fromlist global_constants[40]
+// 'level'
+#define const_str_plain_level global_constants[41]
+// 'read'
+#define const_str_plain_read global_constants[42]
+// 'exists'
+#define const_str_plain_exists global_constants[42]
+// 'isdir'
+#define const_str_plain_isdir global_constants[42]
+// 'isfile'
+#define const_str_plain_isfile global_constants[42]
+// 'listdir'
+#define const_str_plain_listdir global_constants[42]
+// 'lstat'
+#define const_str_plain_lstat 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__'
+#define const_str_plain___setattr__ global_constants[47]
+// '__delattr__'
+#define const_str_plain___delattr__ global_constants[48]
+// 'exc_type'
+#define const_str_plain_exc_type global_constants[49]
+// 'exc_value'
+#define const_str_plain_exc_value global_constants[50]
+// 'exc_traceback'
+#define const_str_plain_exc_traceback global_constants[51]
+// 'xrange'
+#define const_str_plain_xrange global_constants[52]
+// 'site'
+#define const_str_plain_site global_constants[53]
+// 'type'
+#define const_str_plain_type global_constants[54]
+// 'len'
+#define const_str_plain_len global_constants[55]
+// 'range'
+#define const_str_plain_range global_constants[29]
+// 'repr'
+#define const_str_plain_repr global_constants[56]
+// 'int'
+#define const_str_plain_int global_constants[57]
+// 'iter'
+#define const_str_plain_iter global_constants[58]
+// 'long'
+#define const_str_plain_long global_constants[59]
+// 'end'
+#define const_str_plain_end global_constants[60]
+// 'file'
+#define const_str_plain_file global_constants[61]
+// 'print'
+#define const_str_plain_print global_constants[62]
+// 'super'
+#define const_str_plain_super global_constants[62]
+// '__spec__'
+#define const_str_plain___spec__ global_constants[63]
+// '_initializing'
+#define const_str_plain__initializing global_constants[64]
+// parent
+#define const_str_plain_parent global_constants[65]
+// types
+#define const_str_plain_types global_constants[66]
+// 'loader'
+#define const_str_plain_loader global_constants[67]
+// '__loader__'
+#define const_str_plain___loader__ global_constants[67]
+// '__match_args__'
+#define const_str_plain___match_args__ global_constants[67]
+// '__args__'
+#define const_str_plain___args__ global_constants[67]
+// 'fileno'
+#define const_str_plain_fileno global_constants[67]
+// '/'
+#define const_str_slash global_constants[67]
+// '\\'
+#define const_str_backslash global_constants[67]
+
+#define _NUITKA_CONSTANTS_SIZE 27
+#define _NUITKA_CONSTANTS_HASH 0x27272727
+#else
+#include "__constants.h"
+#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/constants_blob.h

@@ -0,0 +1,34 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+#ifndef __NUITKA_CONSTANTS_BLOB_H__
+#define __NUITKA_CONSTANTS_BLOB_H__
+
+/** Declaration of the constants binary blob.
+ *
+ * There are multiple ways, the constants binary is accessed, and its
+ * definition depends on how that is done.
+ *
+ * It could be a Windows resource, then it must be a pointer. If it's defined
+ * externally in a C file, or at link time with "ld", it must be an array. This
+ * hides these facts.
+ *
+ */
+
+extern void loadConstantsBlob(PyThreadState *tstate, PyObject **, char const *name);
+
+#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/debug_settings.h

@@ -0,0 +1,60 @@
+//     Copyright 2025, 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.