Nuitka-winsvc 2.7.7__cp313-cp313-win_amd64.whl

nuitka/code_generation/templates/CodeTemplatesFrames.py

@@ -0,0 +1,235 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Code templates for frames of all kinds.
+
+"""
+
+# This uses STORE_GENERATOR_EXCEPTION,STORE_COROUTINE_EXCEPTION,STORE_ASYNCGEN_EXCEPTION
+
+template_frame_guard_normal_main_block = """\
+{% if frame_cache_identifier %}
+if (isFrameUnusable({{frame_cache_identifier}})) {
+    Py_XDECREF({{frame_cache_identifier}});
+
+#if _DEBUG_REFCOUNTS
+    if ({{frame_cache_identifier}} == NULL) {
+        count_active_frame_cache_instances += 1;
+    } else {
+        count_released_frame_cache_instances += 1;
+    }
+    count_allocated_frame_cache_instances += 1;
+#endif
+    {{frame_cache_identifier}} = {{make_frame_code}};
+#if _DEBUG_REFCOUNTS
+} else {
+    count_hit_frame_cache_instances += 1;
+#endif
+}
+
+assert({{frame_cache_identifier}}->m_type_description == NULL);
+{{frame_identifier}} = {{frame_cache_identifier}};
+{% else %}
+{{frame_identifier}} = {{make_frame_code}};
+{% endif %}
+{% if frame_init_code %}
+{{frame_init_code}}
+{% endif %}
+{% if context_identifier %}
+{% if frame_cache_identifier %}
+// Mark the frame object as in use, ref count 1 will be up for reuse.
+Py_INCREF({{context_identifier}}->m_frame);
+assert(Py_REFCNT({{context_identifier}}->m_frame) == 2); // Frame stack
+{% endif %}
+
+{% if is_python3 %}
+Nuitka_SetFrameGenerator({{context_identifier}}->m_frame, (PyObject *){{context_identifier}});
+{% endif %}
+
+assert({{context_identifier}}->m_frame->m_frame.f_back == NULL);
+{% endif %}
+
+// Push the new frame as the currently active one, and we should be exclusively
+// owning it.
+{% if context_identifier %}
+pushFrameStackGeneratorCompiledFrame(tstate, {{frame_identifier}});
+{% else %}
+pushFrameStackCompiledFrame(tstate, {{frame_identifier}});
+{% endif %}
+assert(Py_REFCNT({{frame_identifier}}) == 2);
+
+{% if context_identifier and is_python3 %}
+// Store currently existing exception as the one to publish again when we
+// yield or yield from.
+STORE_{{context_identifier.upper()}}_EXCEPTION(tstate, {{context_identifier}});
+
+{% endif %}
+// Framed code:
+{{codes}}
+
+{% if context_identifier and is_python3 %}
+// Release exception attached to the frame
+DROP_{{context_identifier.upper()}}_EXCEPTION({{context_identifier}});
+
+{% endif %}
+{% if needs_preserve %}
+// Restore frame exception if necessary.
+RESTORE_FRAME_EXCEPTION(tstate, {{frame_identifier}});
+{% endif %}
+
+{% if not context_identifier %}
+// Put the previous frame back on top.
+popFrameStack(tstate);
+{% endif %}
+{% if frame_exit_code %}
+{{frame_exit_code}}
+{% endif %}
+
+goto {{no_exception_exit}};
+"""
+
+template_frame_guard_normal_return_handler = """\
+{{frame_return_exit}}:
+{% if needs_preserve %}
+RESTORE_FRAME_EXCEPTION(tstate, {{frame_identifier}});
+{% endif %}
+
+// Put the previous frame back on top.
+popFrameStack(tstate);
+{% if frame_exit_code %}
+{{frame_exit_code}}s
+{% endif %}
+
+goto {{return_exit}};
+"""
+
+template_frame_attach_locals = """\
+Nuitka_Frame_AttachLocals(
+    %(frame_identifier)s,
+    %(type_description)s%(frame_variable_refs)s
+);
+"""
+
+template_frame_guard_normal_exception_handler = """\
+{{frame_exception_exit}}:
+
+{% if needs_preserve %}
+RESTORE_FRAME_EXCEPTION(tstate, {{frame_identifier}});
+{% endif %}
+
+{
+    PyTracebackObject *exception_tb = GET_EXCEPTION_STATE_TRACEBACK(&{{exception_state_name}});
+    if (exception_tb == NULL) {
+        exception_tb = {{tb_making_code}};
+        SET_EXCEPTION_STATE_TRACEBACK(&{{exception_state_name}}, exception_tb);
+    } else if (exception_tb->tb_frame != &{{frame_identifier}}->m_frame) {
+        exception_tb = ADD_TRACEBACK(exception_tb, {{frame_identifier}}, {{exception_lineno}});
+        SET_EXCEPTION_STATE_TRACEBACK(&{{exception_state_name}}, exception_tb);
+    }
+}
+
+{% if attach_locals_code %}
+// Attaches locals to frame if any.
+{{attach_locals_code}}
+{% endif %}
+
+{% if frame_cache_identifier %}
+// Release cached frame if used for exception.
+if ({{frame_identifier}} == {{frame_cache_identifier}}) {
+#if _DEBUG_REFCOUNTS
+    count_active_frame_cache_instances -= 1;
+    count_released_frame_cache_instances += 1;
+#endif
+    Py_DECREF({{frame_cache_identifier}});
+    {{frame_cache_identifier}} = NULL;
+}
+{% endif %}
+
+assertFrameObject({{frame_identifier}});
+
+// Put the previous frame back on top.
+popFrameStack(tstate);
+{% if frame_exit_code %}
+{{frame_exit_code}}
+{% endif %}
+
+// Return the error.
+goto {{parent_exception_exit}};
+"""
+
+# Coroutines and asyncgen do this
+template_frame_guard_generator_return_handler = """\
+%(frame_return_exit)s:;
+
+#if PYTHON_VERSION >= 0x300
+#if PYTHON_VERSION < 0x3b0
+Py_CLEAR(EXC_TYPE_F(%(context_identifier)s));
+#endif
+Py_CLEAR(EXC_VALUE_F(%(context_identifier)s));
+#if PYTHON_VERSION < 0x3b0
+Py_CLEAR(EXC_TRACEBACK_F(%(context_identifier)s));
+#endif
+#endif
+
+goto %(return_exit)s;
+"""
+
+
+template_frame_guard_generator_exception_handler = """\
+{{frame_exception_exit}}:;
+
+// If it's not an exit exception, consider and create a traceback for it.
+if (!EXCEPTION_STATE_MATCH_GENERATOR(tstate, &{{exception_state_name}})) {
+    PyTracebackObject *exception_tb = GET_EXCEPTION_STATE_TRACEBACK(&{{exception_state_name}});
+    if (exception_tb == NULL) {
+        exception_tb = {{tb_making}};
+        SET_EXCEPTION_STATE_TRACEBACK(&{{exception_state_name}}, exception_tb);
+    } else if (({{exception_lineno}} != 0) && (exception_tb->tb_frame != &{{frame_identifier}}->m_frame)) {
+        exception_tb = ADD_TRACEBACK(exception_tb, {{frame_identifier}}, {{exception_lineno}});
+        SET_EXCEPTION_STATE_TRACEBACK(&{{exception_state_name}}, exception_tb);
+    }
+
+{{attach_locals}}
+
+    // Release cached frame if used for exception.
+    if ({{frame_identifier}} == {{frame_cache_identifier}}) {
+#if _DEBUG_REFCOUNTS
+        count_active_frame_cache_instances -= 1;
+        count_released_frame_cache_instances += 1;
+#endif
+
+        Py_DECREF({{frame_cache_identifier}});
+        {{frame_cache_identifier}} = NULL;
+    }
+
+    assertFrameObject({{frame_identifier}});
+}
+
+{% if is_python3 %}
+// Release exception attached to the frame
+DROP_{{context_identifier.upper()}}_EXCEPTION({{context_identifier}});
+
+{% endif %}
+
+// Return the error.
+goto {{parent_exception_exit}};
+"""
+
+from . import TemplateDebugWrapper  # isort:skip
+
+TemplateDebugWrapper.checkDebug(globals())
+
+#     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/code_generation/templates/CodeTemplatesFunction.py

@@ -0,0 +1,117 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Normal function (no generator, not yielding) related templates.
+
+"""
+
+template_function_make_declaration = """\
+static PyObject *MAKE_FUNCTION_%(function_identifier)s(%(function_creation_args)s);
+"""
+
+template_function_direct_declaration = """\
+%(file_scope)s PyObject *impl_%(function_identifier)s(PyThreadState *tstate, %(direct_call_arg_spec)s);
+"""
+
+template_maker_function_body = """
+static PyObject *%(function_maker_identifier)s(%(function_creation_args)s) {
+    struct Nuitka_FunctionObject *result = Nuitka_Function_New(
+        %(function_impl_identifier)s,
+        %(function_name_obj)s,
+#if PYTHON_VERSION >= 0x300
+        %(function_qualname_obj)s,
+#endif
+        %(code_identifier)s,
+        %(defaults)s,
+#if PYTHON_VERSION >= 0x300
+        %(kw_defaults)s,
+        %(annotations)s,
+#endif
+        %(module_identifier)s,
+        %(function_doc)s,
+        %(closure_name)s,
+        %(closure_count)d
+    );
+%(constant_return_code)s
+
+    return (PyObject *)result;
+}
+"""
+
+template_make_function = """\
+%(closure_copy)s
+%(to_name)s = %(function_maker_identifier)s(%(args)s);
+"""
+
+template_function_body = """\
+static PyObject *impl_%(function_identifier)s(PyThreadState *tstate, %(parameter_objects_decl)s) {
+    // Preserve error status for checks
+#ifndef __NUITKA_NO_ASSERT__
+    NUITKA_MAY_BE_UNUSED bool had_error = HAS_ERROR_OCCURRED(tstate);
+#endif
+
+    // Local variable declarations.
+%(function_locals)s
+
+    // Actual function body.
+%(function_body)s
+
+%(function_exit)s
+}
+"""
+
+template_function_exception_exit = """\
+function_exception_exit:
+%(function_cleanup)s
+    CHECK_EXCEPTION_STATE(&%(exception_state_name)s);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &%(exception_state_name)s);
+
+    return NULL;
+"""
+
+template_function_return_exit = """
+function_return_exit:
+   // Function cleanup code if any.
+%(function_cleanup)s
+
+   // Actual function exit with return value, making sure we did not make
+   // the error status worse despite non-NULL return.
+   CHECK_OBJECT(tmp_return_value);
+   assert(had_error || !HAS_ERROR_OCCURRED(tstate));
+   return tmp_return_value;"""
+
+function_direct_body_template = """\
+%(file_scope)s PyObject *impl_%(function_identifier)s(PyThreadState *tstate, %(direct_call_arg_spec)s) {
+#ifndef __NUITKA_NO_ASSERT__
+    NUITKA_MAY_BE_UNUSED bool had_error = HAS_ERROR_OCCURRED(tstate);
+    assert(!had_error); // Do not enter inlined functions with error set.
+#endif
+
+    // Local variable declarations.
+%(function_locals)s
+
+    // Actual function body.
+%(function_body)s
+
+%(function_exit)s
+}
+"""
+
+from . import TemplateDebugWrapper  # isort:skip
+
+TemplateDebugWrapper.checkDebug(globals())
+
+#     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/code_generation/templates/CodeTemplatesGeneratorFunction.py

@@ -0,0 +1,130 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Generator function (with yield) related templates.
+
+"""
+
+template_generator_context_maker_decl = """\
+static PyObject *%(generator_maker_identifier)s(%(generator_creation_args)s);
+"""
+
+template_generator_context_body_template = """
+#if %(has_heap_declaration)s
+struct %(function_identifier)s_locals {
+%(function_local_types)s
+};
+#endif
+
+static PyObject *%(function_identifier)s_context(PyThreadState *tstate, struct Nuitka_GeneratorObject *generator, PyObject *yield_return_value) {
+    CHECK_OBJECT(generator);
+    assert(Nuitka_Generator_Check((PyObject *)generator));
+    CHECK_OBJECT_X(yield_return_value);
+
+#if %(has_heap_declaration)s
+    // Heap access.
+%(heap_declaration)s
+#endif
+
+    // Dispatch to yield based on return label index:
+%(function_dispatch)s
+
+    // Local variable initialization
+%(function_var_inits)s
+
+    // Actual generator function body.
+%(function_body)s
+
+%(generator_exit)s
+}
+
+static PyObject *%(generator_maker_identifier)s(%(generator_creation_args)s) {
+    return Nuitka_Generator_New(
+        %(function_identifier)s_context,
+        %(generator_module)s,
+        %(generator_name_obj)s,
+#if PYTHON_VERSION >= 0x350
+        %(generator_qualname_obj)s,
+#endif
+        %(code_identifier)s,
+        %(closure_name)s,
+        %(closure_count)d,
+#if %(has_heap_declaration)s
+        sizeof(struct %(function_identifier)s_locals)
+#else
+        0
+#endif
+    );
+}
+"""
+
+template_make_generator = """\
+%(closure_copy)s
+%(to_name)s = %(generator_maker_identifier)s(%(args)s);
+"""
+
+template_make_empty_generator = """\
+%(closure_copy)s
+%(to_name)s = Nuitka_Generator_NewEmpty(
+    %(generator_module)s,
+    %(generator_name_obj)s,
+#if PYTHON_VERSION >= 0x350
+    %(generator_qualname_obj)s,
+#endif
+    %(code_identifier)s,
+    %(closure_name)s,
+    %(closure_count)d
+);
+"""
+
+
+template_generator_exception_exit = """\
+%(function_cleanup)s
+    return NULL;
+
+    function_exception_exit:
+%(function_cleanup)s
+    CHECK_EXCEPTION_STATE(&%(exception_state_name)s);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &%(exception_state_name)s);
+
+    return NULL;
+"""
+
+template_generator_noexception_exit = """\
+    // Return statement need not be present.
+%(function_cleanup)s
+    return NULL;
+"""
+
+template_generator_return_exit = """\
+    NUITKA_CANNOT_GET_HERE("Generator must have exited already.");
+    return NULL;
+
+    function_return_exit:
+#if PYTHON_VERSION >= 0x300
+    generator->m_returned = %(return_value)s;
+#endif
+
+%(function_cleanup)s
+    return NULL;
+"""
+
+
+from . import TemplateDebugWrapper  # isort:skip
+
+TemplateDebugWrapper.checkDebug(globals())
+
+#     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/code_generation/templates/CodeTemplatesIterators.py

@@ -0,0 +1,40 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Templates for the iterator handling.
+
+"""
+
+template_loop_break_next = """\
+if (%(to_name)s == NULL) {
+    if (CHECK_AND_CLEAR_STOP_ITERATION_OCCURRED(tstate)) {
+%(break_indicator_code)s
+        goto %(break_target)s;
+    } else {
+%(release_temps)s
+        FETCH_ERROR_OCCURRED_STATE(tstate, &%(exception_state_name)s);
+%(var_description_code)s
+%(line_number_code)s
+        goto %(exception_target)s;
+    }
+}
+"""
+
+from . import TemplateDebugWrapper  # isort:skip
+
+TemplateDebugWrapper.checkDebug(globals())
+
+#     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/code_generation/templates/CodeTemplatesLoader.py

@@ -0,0 +1,180 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Templates for the loading of embedded modules.
+
+"""
+
+template_metapath_loader_compiled_module_entry = """\
+{%(module_name)s, modulecode_%(module_identifier)s, 0, 0, %(flags)s
+#if defined(_NUITKA_FREEZER_HAS_FILE_PATH)
+, %(file_path)s
+#endif
+},"""
+
+template_metapath_loader_extension_module_entry = """\
+{%(module_name)s, NULL, 0, 0, %(flags)s
+#if defined(_NUITKA_FREEZER_HAS_FILE_PATH)
+, %(file_path)s
+#endif
+},"""
+
+template_metapath_loader_bytecode_module_entry = """\
+{%(module_name)s, NULL, %(bytecode)s, %(size)d, %(flags)s
+#if defined(_NUITKA_FREEZER_HAS_FILE_PATH)
+, %(file_path)s
+#endif
+},"""
+
+
+template_metapath_loader_body = r"""
+/* Code to register embedded modules for meta path based loading if any. */
+
+#include "nuitka/prelude.h"
+
+/* Use a hex version of our own to compare for versions. We do not care about pre-releases */
+#if PY_MICRO_VERSION < 16
+#define PYTHON_VERSION (PY_MAJOR_VERSION * 256 + PY_MINOR_VERSION * 16 + PY_MICRO_VERSION)
+#else
+#define PYTHON_VERSION (PY_MAJOR_VERSION * 256 + PY_MINOR_VERSION * 16 + 15)
+#endif
+
+#include "nuitka/constants_blob.h"
+
+#include "nuitka/tracing.h"
+#include "nuitka/unfreezing.h"
+
+/* Type bool */
+#ifndef __cplusplus
+#include <stdbool.h>
+#endif
+
+#if %(bytecode_count)d > 0
+static unsigned char *bytecode_data[%(bytecode_count)d];
+#else
+static unsigned char **bytecode_data = NULL;
+#endif
+
+/* Table for lookup to find compiled or bytecode modules included in this
+ * binary or module, or put along this binary as extension modules. We do
+ * our own loading for each of these.
+ */
+%(metapath_module_decls)s
+
+static struct Nuitka_MetaPathBasedLoaderEntry meta_path_loader_entries[] = {
+%(metapath_loader_inittab)s
+    {NULL, NULL, 0, 0, 0}
+};
+
+static void _loadBytesCodesBlob(PyThreadState *tstate) {
+    static bool init_done = false;
+
+    if (init_done == false) {
+        // Note needed for mere data.
+        loadConstantsBlob(tstate, (PyObject **)bytecode_data, ".bytecode");
+
+        init_done = true;
+    }
+}
+
+
+void setupMetaPathBasedLoader(PyThreadState *tstate) {
+    static bool init_done = false;
+    if (init_done == false) {
+        _loadBytesCodesBlob(tstate);
+        registerMetaPathBasedLoader(meta_path_loader_entries, bytecode_data);
+
+        init_done = true;
+    }
+}
+
+// This provides the frozen (compiled bytecode) files that are included if
+// any.
+
+// These modules should be loaded as bytecode. They may e.g. have to be loadable
+// during "Py_Initialize" already, or for irrelevance, they are only included
+// in this un-optimized form. These are not compiled by Nuitka, and therefore
+// are not accelerated at all, merely bundled with the binary or module, so
+// that CPython library can start out finding them.
+
+struct frozen_desc {
+    char const *name;
+    int index;
+    int size;
+};
+
+static struct frozen_desc _frozen_modules[] = {
+%(frozen_modules)s
+    {NULL, 0, 0}
+};
+
+
+void copyFrozenModulesTo(struct _frozen *destination) {
+    NUITKA_PRINT_TIMING("copyFrozenModulesTo(): Calling _loadBytesCodesBlob.");
+    _loadBytesCodesBlob(NULL);
+
+    NUITKA_PRINT_TIMING("copyFrozenModulesTo(): Updating frozen module table sizes.");
+
+    struct frozen_desc *current = _frozen_modules;
+
+    for (;;) {
+        destination->name = (char *)current->name;
+        destination->code = bytecode_data[current->index];
+        destination->size = current->size;
+#if PYTHON_VERSION >= 0x3b0
+        destination->is_package = current->size < 0;
+        destination->size = Py_ABS(destination->size);
+#if PYTHON_VERSION < 0x3d0
+        destination->get_code = NULL;
+#endif
+#endif
+        if (destination->name == NULL) break;
+
+        current += 1;
+        destination += 1;
+    };
+}
+
+#if _NUITKA_MODULE_MODE
+
+struct Nuitka_MetaPathBasedLoaderEntry const *getLoaderEntry(char const *name) {
+    struct Nuitka_MetaPathBasedLoaderEntry *current = meta_path_loader_entries;
+
+    while (current->name != NULL) {
+        if ((current->flags & NUITKA_TRANSLATED_FLAG) != 0) {
+            current->name = UN_TRANSLATE(current->name);
+            current->flags -= NUITKA_TRANSLATED_FLAG;
+        }
+
+        if (strcmp(name, current->name) == 0) {
+            return current;
+        }
+
+        current++;
+    }
+
+    assert(false);
+    return NULL;
+}
+#endif
+
+"""
+
+from . import TemplateDebugWrapper  # isort:skip
+
+TemplateDebugWrapper.checkDebug(globals())
+
+#     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.