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

nuitka/code_generation/templates/CodeTemplatesModules.py

@@ -1,20 +1,6 @@
-#     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
+
+
 """ Main module code templates
 
 This for the main program in case of executables, the module templates and
@@ -23,7 +9,7 @@ stuff related to importing, and of course the generated code license.
 """
 
 template_global_copyright = """\
-/* Generated code for Python module '%(module_name)s'
+/* Generated code for Python module '%(module_identifier)s'
  * created by Nuitka version %(version)s
  *
  * This code is in part copyright %(year)s Kay Hayen.
@@ -73,7 +59,7 @@ static bool constants_created = false;
 /* Function to create module private constants. */
 static void createModuleConstants(PyThreadState *tstate) {
     if (constants_created == false) {
-        loadConstantsBlob(tstate, &mod_consts[0], UNTRANSLATE(%(module_const_blob_name)s));
+        loadConstantsBlob(tstate, &mod_consts[0], UN_TRANSLATE(%(module_const_blob_name)s));
         constants_created = true;
 
 #ifndef __NUITKA_NO_ASSERT__
@@ -130,66 +116,85 @@ extern PyTypeObject Nuitka_Loader_Type;
 // in another process, useful for multiprocessing extensions like dill
 extern void registerDillPluginTables(PyThreadState *tstate, char const *module_name, PyMethodDef *reduce_compiled_function, PyMethodDef *create_compiled_function);
 
-function_impl_code functable_%(module_identifier)s[] = {
+static function_impl_code const function_table_%(module_identifier)s[] = {
 %(module_function_table_entries)s
     NULL
 };
 
-static char const *_reduce_compiled_function_argnames[] = {
-    "func",
-    NULL
-};
-
 static PyObject *_reduce_compiled_function(PyObject *self, PyObject *args, PyObject *kwds) {
     PyObject *func;
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:reduce_compiled_function", (char **)_reduce_compiled_function_argnames, &func, NULL)) {
+    if (!PyArg_ParseTuple(args, "O:reduce_compiled_function", &func, NULL)) {
         return NULL;
     }
 
-    if (Nuitka_Function_Check(func) == false) {
-        PyThreadState *tstate = PyThreadState_GET();
+    PyThreadState *tstate = PyThreadState_GET();
 
-        SET_CURRENT_EXCEPTION_TYPE0_STR_STATE(tstate, PyExc_TypeError, "not a compiled function");
+    if (Nuitka_Function_Check(func) == false) {
+        SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "not a compiled function");
         return NULL;
     }
 
     struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)func;
 
-    function_impl_code *current = functable_%(module_identifier)s;
-    int offset = 0;
-
-    while (*current != NULL) {
-        if (*current == function->m_c_code) {
-            break;
-        }
-
-        current += 1;
-        offset += 1;
-    }
-
-    if (*current == NULL) {
-        PyThreadState *tstate = PyThreadState_GET();
+    int offset = Nuitka_Function_GetFunctionCodeIndex(function, function_table_%(module_identifier)s);
 
+    if (unlikely(offset == -1)) {
+#if 0
+        PRINT_STRING("Looking for:");
+        PRINT_ITEM(func);
+        PRINT_NEW_LINE();
+#endif
         SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "Cannot find compiled function in module.");
         return NULL;
     }
 
-    PyObject *code_object_desc = MAKE_TUPLE_EMPTY(6);
-    PyTuple_SET_ITEM0(code_object_desc, 0, function->m_code_object->co_filename);
-    PyTuple_SET_ITEM0(code_object_desc, 1, function->m_code_object->co_name);
-    PyTuple_SET_ITEM(code_object_desc, 2, PyLong_FromLong(function->m_code_object->co_firstlineno));
-    PyTuple_SET_ITEM0(code_object_desc, 3, function->m_code_object->co_varnames);
-    PyTuple_SET_ITEM(code_object_desc, 4, PyLong_FromLong(function->m_code_object->co_argcount));
-    PyTuple_SET_ITEM(code_object_desc, 5, PyLong_FromLong(function->m_code_object->co_flags));
+    PyObject *code_object_desc = Nuitka_Function_ExtractCodeObjectDescription(tstate, function);
 
-    CHECK_OBJECT_DEEP(code_object_desc);
-
-    PyObject *result = MAKE_TUPLE_EMPTY(4);
+    PyObject *result = MAKE_TUPLE_EMPTY(tstate, 8);
     PyTuple_SET_ITEM(result, 0, PyLong_FromLong(offset));
     PyTuple_SET_ITEM(result, 1, code_object_desc);
     PyTuple_SET_ITEM0(result, 2, function->m_defaults);
-    PyTuple_SET_ITEM0(result, 3, function->m_doc != NULL ? function->m_doc : Py_None);
+#if PYTHON_VERSION >= 0x300
+    PyTuple_SET_ITEM0(result, 3, function->m_kwdefaults ? function->m_kwdefaults : Py_None);
+#else
+    PyTuple_SET_ITEM_IMMORTAL(result, 3, Py_None);
+#endif
+    PyTuple_SET_ITEM0(result, 4, function->m_doc != NULL ? function->m_doc : Py_None);
+
+    if (offset == -5) {
+        CHECK_OBJECT(function->m_constant_return_value);
+        PyTuple_SET_ITEM_IMMORTAL(result, 5, function->m_constant_return_value);
+    } else {
+        PyTuple_SET_ITEM_IMMORTAL(result, 5, Py_None);
+    }
+
+#if PYTHON_VERSION >= 0x300
+    PyTuple_SET_ITEM0(result, 6, function->m_qualname);
+#else
+    PyTuple_SET_ITEM_IMMORTAL(result, 6, Py_None);
+#endif
+
+    PyObject *closure = PyObject_GetAttr(
+        (PyObject *)function,
+        const_str_plain___closure__
+    );
+
+    if (closure != Py_None) {
+        for (Py_ssize_t i=0; i < PyTuple_GET_SIZE(closure); i++) {
+            struct Nuitka_CellObject *cell = (struct Nuitka_CellObject *)PyTuple_GET_ITEM(closure, i);
+
+            assert(Nuitka_Cell_Check((PyObject *)cell));
+
+            PyTuple_SET_ITEM0(
+                closure,
+                i,
+                cell->ob_ref
+            );
+        }
+    }
+
+    PyTuple_SET_ITEM(result, 7, closure);
 
     CHECK_OBJECT_DEEP(result);
 
@@ -197,105 +202,70 @@ static PyObject *_reduce_compiled_function(PyObject *self, PyObject *args, PyObj
 }
 
 static PyMethodDef _method_def_reduce_compiled_function = {"reduce_compiled_function", (PyCFunction)_reduce_compiled_function,
-                                                           METH_VARARGS | METH_KEYWORDS, NULL};
-
-static char const *_create_compiled_function_argnames[] = {
-    "func",
-    "code_object_desc",
-    "defaults",
-    "doc",
-    NULL
-};
+                                                           METH_VARARGS, NULL};
 
 
 static PyObject *_create_compiled_function(PyObject *self, PyObject *args, PyObject *kwds) {
     CHECK_OBJECT_DEEP(args);
 
-    PyObject *func;
+    PyObject *function_index;
     PyObject *code_object_desc;
     PyObject *defaults;
+    PyObject *kw_defaults;
     PyObject *doc;
+    PyObject *constant_return_value;
+    PyObject *function_qualname;
+    PyObject *closure;
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "OOOO:create_compiled_function", (char **)_create_compiled_function_argnames, &func, &code_object_desc, &defaults, &doc, NULL)) {
-        return NULL;
-    }
-
-    int offset = PyLong_AsLong(func);
-
-    if (offset == -1 && HAS_ERROR_OCCURRED(tstate)) {
-        return NULL;
-    }
-
-    if (offset > sizeof(functable_%(module_identifier)s) || offset < 0) {
-        SET_CURRENT_EXCEPTION_TYPE0_STR_STATE(tstate, PyExc_TypeError, "Wrong offset for compiled function.");
+    if (!PyArg_ParseTuple(args, "OOOOOOOO:create_compiled_function", &function_index, &code_object_desc, &defaults, &kw_defaults, &doc, &constant_return_value, &function_qualname, &closure, NULL)) {
         return NULL;
     }
 
-    PyObject *filename = PyTuple_GET_ITEM(code_object_desc, 0);
-    PyObject *function_name = PyTuple_GET_ITEM(code_object_desc, 1);
-    PyObject *line = PyTuple_GET_ITEM(code_object_desc, 2);
-    int line_int = PyLong_AsLong(line);
-    assert(!HAS_ERROR_OCCURRED(tstate));
-
-    PyObject *argnames = PyTuple_GET_ITEM(code_object_desc, 3);
-    PyObject *arg_count = PyTuple_GET_ITEM(code_object_desc, 4);
-    int arg_count_int = PyLong_AsLong(arg_count);
-    assert(!HAS_ERROR_OCCURRED(tstate));
-    PyObject *flags = PyTuple_GET_ITEM(code_object_desc, 5);
-    int flags_int = PyLong_AsLong(flags);
-    assert(!HAS_ERROR_OCCURRED(tstate));
-
-    PyCodeObject *code_object = MAKE_CODE_OBJECT(
-        filename,
-        line_int,
-        flags_int,
-        function_name,
-        function_name, // TODO: function_qualname
-        argnames,
-        NULL, // freevars
-        arg_count_int,
-        0, // TODO: Missing kw_only_count
-        0 // TODO: Missing pos_only_count
-    );
-
-    struct Nuitka_FunctionObject *result = Nuitka_Function_New(
-        functable_%(module_identifier)s[offset],
-        code_object->co_name,
-#if PYTHON_VERSION >= 0x300
-        NULL, // TODO: Not transferring qualname yet
-#endif
-        code_object,
-        defaults,
 #if PYTHON_VERSION >= 0x300
-        NULL, // kwdefaults are done on the outside currently
-        NULL, // TODO: Not transferring annotations
+    if (kw_defaults == Py_None) {
+        kw_defaults = NULL;
+    }
 #endif
+
+    return (PyObject *)Nuitka_Function_CreateFunctionViaCodeIndex(
         module_%(module_identifier)s,
+        function_qualname,
+        function_index,
+        code_object_desc,
+        constant_return_value,
+        defaults,
+        kw_defaults,
         doc,
-        NULL,
-        0
+        closure,
+        function_table_%(module_identifier)s,
+        sizeof(function_table_%(module_identifier)s) / sizeof(function_impl_code)
     );
-
-    return (PyObject *)result;
 }
 
 static PyMethodDef _method_def_create_compiled_function = {
     "create_compiled_function",
     (PyCFunction)_create_compiled_function,
-    METH_VARARGS | METH_KEYWORDS, NULL
+    METH_VARARGS, NULL
 };
 
 
 #endif
 
+// Actual name might be different when loaded as a package.
+#if defined(_NUITKA_MODULE) && %(is_top)d
+static char const *module_full_name = %(module_name_cstr)s;
+#endif
+
 // Internal entry point for module code.
 PyObject *modulecode_%(module_identifier)s(PyThreadState *tstate, PyObject *module, struct Nuitka_MetaPathBasedLoaderEntry const *loader_entry) {
     // Report entry to PGO.
-    PGO_onModuleEntered("%(module_name)s");
+    PGO_onModuleEntered("%(module_identifier)s");
 
     // Store the module for future use.
     module_%(module_identifier)s = module;
 
+    moduledict_%(module_identifier)s = MODULE_DICT(module_%(module_identifier)s);
+
     // Modules can be loaded again in case of errors, avoid the init being done again.
     static bool init_done = false;
 
@@ -304,11 +274,23 @@ PyObject *modulecode_%(module_identifier)s(PyThreadState *tstate, PyObject *modu
         // In case of an extension module loaded into a process, we need to call
         // initialization here because that's the first and potentially only time
         // we are going called.
-
+#if PYTHON_VERSION > 0x350 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_ALLOCATORS)
+        initNuitkaAllocators();
+#endif
         // Initialize the constant values used.
         _initBuiltinModule();
-        createGlobalConstants(tstate);
 
+#if PYTHON_VERSION >= 0x3c0
+        PyObject *real_module_name = PyObject_GetAttrString(module, "__name__");
+        CHECK_OBJECT(real_module_name);
+        module_full_name = strdup(Nuitka_String_AsString(real_module_name));
+#endif
+
+#if PYTHON_VERSION >= 0x3c0
+        createGlobalConstants(tstate, real_module_name);
+#else
+        createGlobalConstants(tstate);
+#endif
         /* Initialize the compiled types of Nuitka. */
         _initCompiledCellType();
         _initCompiledGeneratorType();
@@ -325,9 +307,13 @@ PyObject *modulecode_%(module_identifier)s(PyThreadState *tstate, PyObject *modu
 
         // Enable meta path based loader if not already done.
 #ifdef _NUITKA_TRACE
-        PRINT_STRING("%(module_name)s: Calling setupMetaPathBasedLoader().\n");
+        PRINT_STRING("%(module_identifier)s: Calling setupMetaPathBasedLoader().\n");
 #endif
         setupMetaPathBasedLoader(tstate);
+#if PYTHON_VERSION >= 0x3c0
+        updateMetaPathBasedLoaderModuleRoot(module_full_name);
+#endif
+
 
 #if PYTHON_VERSION >= 0x300
         patchInspectModule(tstate);
@@ -336,7 +322,7 @@ PyObject *modulecode_%(module_identifier)s(PyThreadState *tstate, PyObject *modu
 #endif
 
         /* The constants only used by this module are created now. */
-        NUITKA_PRINT_TRACE("%(module_name)s: Calling createModuleConstants().\n");
+        NUITKA_PRINT_TRACE("%(module_identifier)s: Calling createModuleConstants().\n");
         createModuleConstants(tstate);
 
         createModuleCodeObjects();
@@ -344,12 +330,27 @@ PyObject *modulecode_%(module_identifier)s(PyThreadState *tstate, PyObject *modu
         init_done = true;
     }
 
-    // PRINT_STRING("in init%(module_identifier)s\n");
+#if defined(_NUITKA_MODULE) && %(is_top)d
+    PyObject *pre_load = IMPORT_EMBEDDED_MODULE(tstate, %(module_name_cstr)s "-preLoad");
+    if (pre_load == NULL) {
+        return NULL;
+    }
+#endif
 
-    moduledict_%(module_identifier)s = MODULE_DICT(module_%(module_identifier)s);
+    // PRINT_STRING("in init%(module_identifier)s\n");
 
 #ifdef _NUITKA_PLUGIN_DILL_ENABLED
-    registerDillPluginTables(tstate, loader_entry->name, &_method_def_reduce_compiled_function, &_method_def_create_compiled_function);
+    {
+        char const *module_name_c;
+        if (loader_entry != NULL) {
+            module_name_c = loader_entry->name;
+        } else {
+            PyObject *module_name = GET_STRING_DICT_VALUE(moduledict_%(module_identifier)s, (Nuitka_StringObject *)const_str_plain___name__);
+            module_name_c = Nuitka_String_AsString(module_name);
+        }
+
+        registerDillPluginTables(tstate, module_name_c, &_method_def_reduce_compiled_function, &_method_def_create_compiled_function);
+    }
 #endif
 
     // Set "__compiled__" to what version information we have.
@@ -422,7 +423,7 @@ PyObject *modulecode_%(module_identifier)s(PyThreadState *tstate, PyObject *modu
         UPDATE_STRING_DICT0(moduledict_%(module_identifier)s, (Nuitka_StringObject *)const_str_plain___builtins__, value);
     }
 
-    UPDATE_STRING_DICT0(moduledict_%(module_identifier)s, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type);
+    UPDATE_STRING_DICT0(moduledict_%(module_identifier)s, (Nuitka_StringObject *)const_str_plain___loader__, Nuitka_Loader_New(loader_entry));
 
 #if PYTHON_VERSION >= 0x340
 // Set the "__spec__" value
@@ -461,11 +462,23 @@ PyObject *modulecode_%(module_identifier)s(PyThreadState *tstate, PyObject *modu
     // Temp variables if any
 %(temps_decl)s
 
+    // Module init code if any
+%(module_init_codes)s
+
     // Module code.
-%(module_code)s
+%(module_codes)s
 
     // Report to PGO about leaving the module without error.
-    PGO_onModuleExit("%(module_name)s", false);
+    PGO_onModuleExit("%(module_identifier)s", false);
+
+#if defined(_NUITKA_MODULE) && %(is_top)d
+    {
+        PyObject *post_load = IMPORT_EMBEDDED_MODULE(tstate, %(module_name_cstr)s "-postLoad");
+        if (post_load == NULL) {
+            return NULL;
+        }
+    }
+#endif
 
     Py_INCREF(module_%(module_identifier)s);
     return module_%(module_identifier)s;
@@ -504,18 +517,10 @@ template_module_external_entry_point = r"""
 #define NUITKA_MODULE_INIT_FUNCTION PyMODINIT_FUNC
 #endif
 
-/* The name of the entry point for DLLs changed between CPython versions, and
- * this is here to hide that.
- */
-#if PYTHON_VERSION < 0x300
-#define MOD_INIT_DECL(name) NUITKA_MODULE_INIT_FUNCTION init##name(void)
-#else
-#define MOD_INIT_DECL(name) NUITKA_MODULE_INIT_FUNCTION PyInit_##name(void)
-#endif
+static PyObject *orig_dunder_file_value;
 
 #if PYTHON_VERSION >= 0x300
 static setattrofunc orig_PyModule_Type_tp_setattro;
-static PyObject *orig_dunder_file_value;
 
 /* This is used one time only. */
 static int Nuitka_TopLevelModule_tp_setattro(PyObject *module, PyObject *name, PyObject *value) {
@@ -545,27 +550,88 @@ static struct PyModuleDef mdef_%(module_identifier)s = {
     PyModuleDef_HEAD_INIT,
     NULL,                /* m_name, filled later */
     NULL,                /* m_doc */
-    -1,                  /* m_size */
+    %(module_def_size)s, /* m_size */
     NULL,                /* m_methods */
-    NULL,                /* m_reload */
+    NULL,                /* m_slots */
     NULL,                /* m_traverse */
     NULL,                /* m_clear */
     NULL,                /* m_free */
 };
 #endif
 
+#if PYTHON_VERSION < 0x300
+static void onModuleFileValueRelease(void *v) {
+    if (orig_dunder_file_value != NULL) {
+        UPDATE_STRING_DICT0(
+            moduledict_%(module_identifier)s,
+            (Nuitka_StringObject *)const_str_plain___file__,
+            orig_dunder_file_value
+        );
+    }
+}
+#endif
+
 /* The exported interface to CPython. On import of the module, this function
  * gets called. It has to have an exact function name, in cases it's a shared
- * library export. This is hidden behind the MOD_INIT_DECL macro.
+ * library export.
  */
 
-// Actual name might be different when loaded as a package.
-static char const *module_full_name = "%(module_name)s";
 
-MOD_INIT_DECL(%(module_identifier)s) {
+static PyObject *%(module_dll_entry_point)s_phase2(PyObject *module) {
+    PyThreadState *tstate = PyThreadState_GET();
+
+    PyObject *result = modulecode_%(module_identifier)s(tstate, module, NULL);
+
+#if PYTHON_VERSION < 0x300
+    // Our "__file__" value will not be respected by CPython and one
+    // way we can avoid it, is by having a capsule type, that when
+    // it gets released, we are called and repair the value.
+
+    if (HAS_ERROR_OCCURRED(tstate) == false) {
+        orig_dunder_file_value = DICT_GET_ITEM_WITH_HASH_ERROR1(tstate, (PyObject *)moduledict_%(module_identifier)s, const_str_plain___file__);
+
+        PyObject *fake_file_value = PyCObject_FromVoidPtr(NULL, onModuleFileValueRelease);
+
+        UPDATE_STRING_DICT1(
+            moduledict_%(module_identifier)s,
+            (Nuitka_StringObject *)const_str_plain___file__,
+            fake_file_value
+        );
+    }
+#else
+    if (result != NULL) {
+        // Make sure we undo the change of the "__file__" attribute during importing. We do not
+        // know how to achieve it for Python2 though. TODO: Find something for Python2 too.
+        orig_PyModule_Type_tp_setattro = PyModule_Type.tp_setattro;
+        PyModule_Type.tp_setattro = Nuitka_TopLevelModule_tp_setattro;
+
+        orig_dunder_file_value = DICT_GET_ITEM_WITH_HASH_ERROR1(tstate, (PyObject *)moduledict_%(module_identifier)s, const_str_plain___file__);
+    }
+#endif
+
+    return result;
+}
+
+#if %(module_def_size)s >= 0
+static int %(module_dll_entry_point)s_slot(PyObject *module) {
+    PyObject *result = %(module_dll_entry_point)s_phase2(module);
+
+    if (result == NULL) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+#endif
+
+NUITKA_MODULE_INIT_FUNCTION (%(module_dll_entry_point)s)(void) {
+#if PYTHON_VERSION < 0x3c0
     if (_Py_PackageContext != NULL) {
-        module_full_name = _Py_PackageContext;
+        if (strcmp(module_full_name, _Py_PackageContext) != 0) {
+            module_full_name = strdup(_Py_PackageContext);
+        }
     }
+#endif
 
 #if PYTHON_VERSION < 0x300
     PyObject *module = Py_InitModule4(
@@ -580,34 +646,32 @@ MOD_INIT_DECL(%(module_identifier)s) {
     );
 #else
     mdef_%(module_identifier)s.m_name = module_full_name;
+
+#if %(module_def_size)s == -1
     PyObject *module = PyModule_Create(&mdef_%(module_identifier)s);
     CHECK_OBJECT(module);
 
-    bool res = Nuitka_SetModuleString(module_full_name, module);
-    assert(res != false);
+    {
+        NUITKA_MAY_BE_UNUSED bool res = Nuitka_SetModuleString(module_full_name, module);
+        assert(res != false);
+    }
+
+#endif
 #endif
 
-    PyThreadState *tstate = PyThreadState_GET();
+#if %(module_def_size)s >= 0
+    static PyModuleDef_Slot _module_slots[] = {
+        {Py_mod_exec, %(module_dll_entry_point)s_slot},
+        {0, NULL}
+    };
 
-#if PYTHON_VERSION < 0x300
-    modulecode_%(module_identifier)s(tstate, module, NULL);
+    mdef_%(module_identifier)s.m_slots = _module_slots;
 
-    // TODO: Our "__file__" value will not be respected by CPython and one
-    // way we could avoid it, is by having a capsule type, that when it gets
-    // released, we are called.
+    return PyModuleDef_Init(&mdef_%(module_identifier)s);
+#elif PYTHON_VERSION >= 0x300
+    return %(module_dll_entry_point)s_phase2(module);
 #else
-    PyObject *result = modulecode_%(module_identifier)s(tstate, module, NULL);
-
-    if (result != NULL) {
-        // Make sure we undo the change of the "__file__" attribute during importing. We do not
-        // know how to achieve it for Python2 though. TODO: Find something for Python2 too.
-        orig_PyModule_Type_tp_setattro = PyModule_Type.tp_setattro;
-        PyModule_Type.tp_setattro = Nuitka_TopLevelModule_tp_setattro;
-
-        orig_dunder_file_value = DICT_GET_ITEM_WITH_HASH_ERROR1(tstate, (PyObject *)moduledict_%(module_identifier)s, const_str_plain___file__);
-    }
-
-    return result;
+    %(module_dll_entry_point)s_phase2(module);
 #endif
 }
 """
@@ -654,3 +718,18 @@ template_header_guard = """\
 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.