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

nuitka/build/SconsUtils.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
+
+
 """ Helper functions for the scons file.
 
 """
@@ -22,6 +8,7 @@
 from __future__ import print_function
 
 import os
+import pickle
 import shutil
 import signal
 import sys
@@ -30,13 +17,23 @@ from nuitka.__past__ import basestring, unicode
 from nuitka.containers.OrderedDicts import OrderedDict
 from nuitka.Tracing import scons_details_logger, scons_logger
 from nuitka.utils.Execution import executeProcess
-from nuitka.utils.FileOperations import getFileContentByLine, openTextFile
-from nuitka.utils.Utils import isLinux, isMacOS, isPosixWindows
+from nuitka.utils.FileOperations import (
+    changeFilenameExtension,
+    getFileContentByLine,
+    getFilenameExtension,
+    getWindowsShortPathName,
+    hasFilenameExtension,
+    isFilesystemEncodable,
+    openPickleFile,
+    openTextFile,
+    withFileLock,
+)
+from nuitka.utils.Utils import isLinux, isMacOS, isPosixWindows, isWin32Windows
 
 
 def initScons():
     # Avoid localized outputs.
-    os.environ["LANG"] = "C"
+    os.environ["LC_ALL"] = "C"
 
     def no_sync(self):
         # That's a noop, pylint: disable=unused-argument
@@ -160,7 +157,7 @@ def prepareEnvironment(mingw_mode):
             if os.path.isdir(cc_dirname):
                 addToPATH(None, cc_dirname, prefix=True)
 
-        if win_target and isGccName(os.path.basename(os.environ["CC"])):
+        if os.name == "nt" and isGccName(os.path.basename(os.environ["CC"])):
             scons_details_logger.info(
                 "Environment CC seems to be a gcc, enabling mingw_mode."
             )
@@ -176,7 +173,7 @@ def prepareEnvironment(mingw_mode):
 
 
 def createEnvironment(
-    mingw_mode, msvc_version, target_arch, experimental, no_deployment
+    mingw_mode, msvc_version, target_arch, experimental, no_deployment, debug_modes
 ):
     from SCons.Script import Environment  # pylint: disable=I0021,import-error
 
@@ -210,9 +207,9 @@ def createEnvironment(
         import SCons.Tool.msvc  # pylint: disable=I0021,import-error
 
         SCons.Tool.MSCommon.vc.msvc_setup_env = lambda *args: None
-        SCons.Tool.msvc.msvc_exists = (
-            SCons.Tool.MSCommon.vc.msvc_exists
-        ) = lambda *args: False
+        SCons.Tool.msvc.msvc_exists = SCons.Tool.MSCommon.vc.msvc_exists = (
+            lambda *args: False
+        )
     else:
         # Everything else should use default, that is MSVC tools, but not MinGW64.
         tools = ["default"]
@@ -238,10 +235,14 @@ def createEnvironment(
     env.nuitka_python = getArgumentBool("nuitka_python", False)
     env.debian_python = getArgumentBool("debian_python", False)
     env.fedora_python = getArgumentBool("fedora_python", False)
+    env.arch_python = getArgumentBool("arch_python", False)
     env.msys2_mingw_python = getArgumentBool("msys2_mingw_python", False)
     env.anaconda_python = getArgumentBool("anaconda_python", False)
     env.pyenv_python = getArgumentBool("pyenv_python", False)
     env.apple_python = getArgumentBool("apple_python", False)
+    env.self_compiled_python_uninstalled = getArgumentBool(
+        "self_compiled_python_uninstalled", False
+    )
 
     # Non-elf binary, important for linker settings.
     env.noelf_mode = getArgumentBool("noelf_mode", False)
@@ -270,6 +271,9 @@ def createEnvironment(
     _enableFlagSettings(env, "experimental", experimental)
     env.experimental_flags = experimental
 
+    _enableFlagSettings(env, "debug", debug_modes)
+    env.debug_modes_flags = debug_modes
+
     return env
 
 
@@ -286,11 +290,6 @@ def decodeData(data):
             return data.decode("utf8", "backslashreplace")
 
 
-# Windows target mode: Compile for Windows. Used to be an option, but we
-# no longer cross compile this way.
-win_target = os.name == "nt"
-
-
 def getExecutablePath(filename, env):
     """Find an execute in either normal PATH, or Scons detected PATH."""
 
@@ -303,7 +302,7 @@ def getExecutablePath(filename, env):
         filename = env[filename[1:]]
 
     # Append ".exe" suffix  on Windows if not already present.
-    if win_target and not filename.lower().endswith(".exe"):
+    if os.name == "nt" and not filename.lower().endswith(".exe"):
         filename += ".exe"
 
     # Either look at the initial "PATH" as given from the outside or look at the
@@ -321,7 +320,7 @@ def getExecutablePath(filename, env):
 
         full = os.path.normpath(os.path.join(path_element, filename))
 
-        if os.path.exists(full):
+        if os.path.isfile(full):
             return full
 
     return None
@@ -365,9 +364,9 @@ def addToPATH(env, dirname, prefix):
     setEnvironmentVariable(env, "PATH", os.pathsep.join(path_value))
 
 
-def writeSconsReport(env, source_dir):
+def writeSconsReport(env, target):
     with openTextFile(
-        os.path.join(source_dir, "scons-report.txt"), "w", encoding="utf8"
+        _getSconsReportFilename(env.source_dir), "w", encoding="utf8"
     ) as report_file:
         # We are friends to get at this debug info, pylint: disable=protected-access
         for key, value in sorted(env._dict.items()):
@@ -396,13 +395,33 @@ def writeSconsReport(env, source_dir):
         print("clangcl_mode=%s" % env.clangcl_mode, file=report_file)
 
         print("PATH=%s" % os.environ["PATH"], file=report_file)
+        print("TARGET=%s" % target[0].abspath, file=report_file)
+
+
+def reportSconsUnexpectedOutput(env, cmdline, stdout, stderr):
+    with withFileLock("writing scons error report"):
+        file_handle, pickler = openPickleFile(
+            _getSconsErrorReportFilename(env.source_dir), "ab", protocol=2
+        )
+        pickler.dump((cmdline, stdout, stderr))
+        file_handle.close()
 
 
 _scons_reports = {}
+_scons_error_reports = {}
 
 
 def flushSconsReports():
     _scons_reports.clear()
+    _scons_error_reports.clear()
+
+
+def _getSconsReportFilename(source_dir):
+    return os.path.join(source_dir, "scons-report.txt")
+
+
+def _getSconsErrorReportFilename(source_dir):
+    return os.path.join(source_dir, "scons-error-report.txt")
 
 
 def readSconsReport(source_dir):
@@ -410,7 +429,7 @@ def readSconsReport(source_dir):
         scons_report = OrderedDict()
 
         for line in getFileContentByLine(
-            os.path.join(source_dir, "scons-report.txt"), encoding="utf8"
+            _getSconsReportFilename(source_dir), encoding="utf8"
         ):
             if "=" not in line:
                 continue
@@ -428,6 +447,47 @@ def getSconsReportValue(source_dir, key):
     return readSconsReport(source_dir).get(key)
 
 
+def readSconsErrorReport(source_dir):
+    if source_dir not in _scons_error_reports:
+        scons_error_report = OrderedDict()
+
+        scons_error_report_filename = _getSconsErrorReportFilename(source_dir)
+        if os.path.exists(scons_error_report_filename):
+            file_handle = openTextFile(scons_error_report_filename, "rb")
+            try:
+                while True:
+                    try:
+                        cmd, stdout, stderr = pickle.load(file_handle)
+                    except EOFError:
+                        break
+
+                    if type(cmd) in (tuple, list):
+                        cmd = " ".join(cmd)
+
+                    if cmd not in scons_error_report:
+                        scons_error_report[cmd] = ["", ""]
+
+                    if type(stdout) in (tuple, list):
+                        stdout = "\n".join(stdout)
+
+                    if type(stderr) in (tuple, list):
+                        stderr = "\n".join(stderr)
+
+                    if stdout:
+                        stdout = stdout.replace("\n\r", "\n")
+                        scons_error_report[cmd][0] += stdout
+                    if stderr:
+                        stderr = stderr.replace("\n\r", "\n")
+                        scons_error_report[cmd][1] += stderr
+
+            finally:
+                file_handle.close()
+
+        _scons_error_reports[source_dir] = scons_error_report
+
+    return _scons_error_reports[source_dir]
+
+
 def addClangClPathFromMSVC(env):
     cl_exe = getExecutablePath("cl", env=env)
 
@@ -483,7 +543,11 @@ def isGccName(cc_name):
 
 
 def isClangName(cc_name):
-    return "clang" in cc_name and "-cl" not in cc_name
+    return ("clang" in cc_name and "-cl" not in cc_name) or isZigName(cc_name)
+
+
+def isZigName(cc_name):
+    return "zig" in cc_name
 
 
 def cheapCopyFile(src, dst):
@@ -491,7 +555,7 @@ def cheapCopyFile(src, dst):
     if not os.path.exists(dirname):
         os.makedirs(dirname)
 
-    if win_target:
+    if os.name == "nt":
         # Windows has symlinks these days, but they do not integrate well
         # with Python2 at least. So make a copy in any case.
         if os.path.exists(dst):
@@ -524,11 +588,13 @@ def cheapCopyFile(src, dst):
             shutil.copy(src, dst)
 
 
-def provideStaticSourceFile(sub_path, nuitka_src, source_dir, c11_mode):
-    source_filename = os.path.join(nuitka_src, "static_src", sub_path)
-    target_filename = os.path.join(source_dir, "static_src", os.path.basename(sub_path))
+def provideStaticSourceFile(env, sub_path, c11_mode):
+    source_filename = os.path.join(env.nuitka_src, "static_src", sub_path)
+    target_filename = os.path.join(
+        env.source_dir, "static_src", os.path.basename(sub_path)
+    )
 
-    if target_filename.endswith(".c") and not c11_mode:
+    if hasFilenameExtension(target_filename, ".c") and not c11_mode:
         target_filename += "pp"  # .cpp suffix then.
 
     cheapCopyFile(source_filename, target_filename)
@@ -545,32 +611,40 @@ def scanSourceDir(env, dirname, plugins):
     # name.
     added_path = False
 
-    for filename in sorted(os.listdir(dirname)):
-        if filename.endswith(".h") and plugins and not added_path:
+    for filename_base in sorted(os.listdir(dirname)):
+        if filename_base.endswith(".h") and plugins and not added_path:
             # Adding path for source paths on the fly, spell-checker: ignore cpppath
             env.Append(CPPPATH=[dirname])
             added_path = True
 
         # Only C files are of interest here.
-        if not filename.endswith((".c", "cpp")) or not filename.startswith(
-            ("module.", "__", "plugin.")
-        ):
+        if not hasFilenameExtension(
+            filename_base, (".c", ".cpp")
+        ) or not filename_base.startswith(("module.", "__", "plugin.")):
             continue
 
-        filename = os.path.join(dirname, filename)
+        filename = os.path.join(dirname, filename_base)
+
+        target_filename = filename
 
-        target_file = filename
+        if isWin32Windows() and not isFilesystemEncodable(filename_base):
+            target_filename = getWindowsShortPathName(target_filename)
+
+            # Avoid ".C" suffixes, that MinGW64 wouldn't recognize.
+            target_filename = changeFilenameExtension(
+                target_filename, getFilenameExtension(target_filename).lower()
+            )
 
         # We pretend to use C++ if no C11 compiler is present.
         if env.c11_mode:
-            yield filename
+            yield target_filename
         else:
-            if filename.endswith(".c"):
-                target_file += "pp"  # .cpp" suffix then
+            if hasFilenameExtension(filename, ".c"):
+                target_filename += "pp"  # .cpp" suffix then
 
-                os.rename(filename, target_file)
+                os.rename(filename, target_filename)
 
-            yield target_file
+            yield target_filename
 
 
 def makeCLiteral(value):
@@ -592,6 +666,8 @@ def createDefinitionsFile(source_dir, filename, definitions):
                 continue
 
             if type(value) is int or key.endswith(("_BOOL", "_INT")):
+                if type(value) is bool:
+                    value = int(value)
                 f.write("#define %s %s\n" % (key, value))
             elif type(value) in (str, unicode) and key.endswith("_WIDE_STRING"):
                 f.write("#define %s L%s\n" % (key, makeCLiteral(value)))
@@ -610,7 +686,7 @@ def getMsvcVersion(env):
 
     # TODO: Workaround for prompt being used.
     if value is None:
-        value = os.environ.get("VCToolsVersion", "14.3").rsplit(".", 1)[0]
+        value = os.getenv("VCToolsVersion", "14.3").rsplit(".", 1)[0]
 
     value = value.replace("exp", "")
     return tuple((int(d) for d in value.split(".")))
@@ -665,7 +741,7 @@ def getLinkerArch(target_arch, mingw_mode):
     global _linker_arch_determined, _linker_arch
 
     if not _linker_arch_determined:
-        if win_target:
+        if os.name == "nt":
             if target_arch == "x86_64":
                 _linker_arch = "pei-x86-64"
             elif target_arch == "arm64":
@@ -771,3 +847,19 @@ def addBinaryBlobSection(env, blob_filename, section_name):
         )
     else:
         assert False
+
+
+#     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/__init__.py

@@ -1,5 +1,8 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Dummy file to make this directory a package. """
+
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.
 #
@@ -14,5 +17,3 @@
 #     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 #     See the License for the specific language governing permissions and
 #     limitations under the License.
-#
-""" Dummy file to make this directory a package. """

nuitka/build/include/nuitka/allocator.h

@@ -1,20 +1,5 @@
-//     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-//
-//     Part of "Nuitka", an optimizing Python compiler that is compatible and
-//     integrates with CPython, but also works on its own.
-//
-//     Licensed under the Apache License, Version 2.0 (the "License");
-//     you may not use this file except in compliance with the License.
-//     You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//     Unless required by applicable law or agreed to in writing, software
-//     distributed under the License is distributed on an "AS IS" BASIS,
-//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//     See the License for the specific language governing permissions and
-//     limitations under the License.
-//
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
 #ifndef __NUITKA_ALLOCATOR_H__
 #define __NUITKA_ALLOCATOR_H__
 
@@ -28,7 +13,40 @@
 #define _PyObject_GC_IS_TRACKED(obj) (1)
 #endif
 
-#if PYTHON_VERSION >= 0x380
+// The full API is available for Python 3.5 only
+#if PYTHON_VERSION >= 0x350 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_ALLOCATORS)
+extern void *(*python_obj_malloc)(void *ctx, size_t size);
+extern void *(*python_mem_malloc)(void *ctx, size_t size);
+extern void *(*python_mem_calloc)(void *ctx, size_t nelem, size_t elsize);
+
+#if defined(Py_DEBUG)
+extern void *python_obj_ctx;
+extern void *python_mem_ctx;
+#else
+#define python_obj_ctx (NULL)
+#define python_mem_ctx (NULL)
+#endif
+
+extern void initNuitkaAllocators(void);
+
+// Our version of "PyObject_Malloc".
+NUITKA_MAY_BE_UNUSED static void *NuitkaObject_Malloc(size_t size) { return python_obj_malloc(python_obj_ctx, size); }
+
+// Our version of "PyMem_Malloc".
+NUITKA_MAY_BE_UNUSED static void *NuitkaMem_Malloc(size_t size) { return python_mem_malloc(python_mem_ctx, size); }
+
+// Our version of "PyMem_Calloc".
+NUITKA_MAY_BE_UNUSED static void *NuitkaMem_Calloc(size_t nelem, size_t elsize) {
+    return python_mem_calloc(python_mem_ctx, nelem, elsize);
+}
+
+#else
+#define NuitkaObject_Malloc(size) PyObject_MALLOC(size)
+#define NuitkaMem_Malloc(size) PyMem_MALLOC(size)
+#define NuitkaMem_Calloc(elem, elsize) PyMem_CALLOC(elem, elsize)
+#endif
+
+#if PYTHON_VERSION >= 0x380 && PYTHON_VERSION < 0x3c0
 // Need to make Py_DECREF a macro again that doesn't call an API
 static inline void _Nuitka_Py_DECREF(PyObject *ob) {
     assert(ob != NULL && ob->ob_refcnt >= 0);
@@ -86,6 +104,18 @@ static inline void _Nuitka_Py_XDECREF(PyObject *ob) {
 
 #endif
 
+// For Python3.12, avoid reference management if value is known to be immortal.
+#if PYTHON_VERSION < 0x3c0
+#define Py_INCREF_IMMORTAL(value) Py_INCREF(value)
+#define Py_DECREF_IMMORTAL(value) Py_DECREF(value)
+#elif defined(_NUITKA_DEBUG_DEBUG_IMMORTAL)
+#define Py_INCREF_IMMORTAL(value) assert(Py_REFCNT(value) == _Py_IMMORTAL_REFCNT)
+#define Py_DECREF_IMMORTAL(value) assert(Py_REFCNT(value) == _Py_IMMORTAL_REFCNT)
+#else
+#define Py_INCREF_IMMORTAL(value)
+#define Py_DECREF_IMMORTAL(value)
+#endif
+
 // Macro introduced with Python3.9 or higher, make it generally available.
 #ifndef Py_SET_TYPE
 static inline void _Py_SET_TYPE(PyObject *ob, PyTypeObject *type) { ob->ob_type = type; }
@@ -95,11 +125,25 @@ static inline void _Py_SET_TYPE(PyObject *ob, PyTypeObject *type) { ob->ob_type
 // After Python 3.9 this was moved into the DLL potentially, making
 // it expensive to call.
 #if PYTHON_VERSION >= 0x390
-static void Nuitka_Py_NewReference(PyObject *op) {
+static inline void Nuitka_Py_NewReferenceNoTotal(PyObject *op) { Py_SET_REFCNT(op, 1); }
+static inline void Nuitka_Py_NewReference(PyObject *op) {
 #ifdef Py_REF_DEBUG
+#if PYTHON_VERSION < 0x3c0
     _Py_RefTotal++;
+#else
+    _PyInterpreterState_GET()->object_state.reftotal++;
+#endif
+#endif
+#if !defined(Py_GIL_DISABLED)
+    op->ob_refcnt = 1;
+#else
+    op->ob_tid = _Py_ThreadId();
+    op->_padding = 0;
+    op->ob_mutex = (PyMutex){0};
+    op->ob_gc_bits = 0;
+    op->ob_ref_local = 1;
+    op->ob_ref_shared = 0;
 #endif
-    Py_SET_REFCNT(op, 1);
 }
 #else
 #define Nuitka_Py_NewReference(op) _Py_NewReference(op)
@@ -126,7 +170,7 @@ static PyObject *Nuitka_PyType_AllocNoTrackVar(PyTypeObject *type, Py_ssize_t ni
     const size_t pre_size = Nuitka_PyType_PreHeaderSize(type);
     assert(pre_size == sizeof(PyGC_Head));
 
-    char *alloc = (char *)PyObject_Malloc(size + pre_size);
+    char *alloc = (char *)NuitkaObject_Malloc(size + pre_size);
     assert(alloc);
     PyObject *obj = (PyObject *)(alloc + pre_size);
 
@@ -161,7 +205,7 @@ static PyObject *Nuitka_PyType_AllocNoTrack(PyTypeObject *type) {
     // TODO: This ought to be static for all our types, so remove it as a call.
     const size_t pre_size = Nuitka_PyType_PreHeaderSize(type);
 
-    char *alloc = (char *)PyObject_Malloc(_PyObject_SIZE(type) + pre_size);
+    char *alloc = (char *)NuitkaObject_Malloc(_PyObject_SIZE(type) + pre_size);
     assert(alloc);
     PyObject *obj = (PyObject *)(alloc + pre_size);
 
@@ -239,4 +283,43 @@ NUITKA_MAY_BE_UNUSED static void *Nuitka_GC_New(PyTypeObject *type) {
     return op;
 }
 
+static bool inline Nuitka_GC_IS_TRACKED_X(PyObject *object) {
+    return object == NULL || _PyObject_GC_IS_TRACKED(object);
+}
+
+// To allow us marking some of our own values as immortal.
+#if PYTHON_VERSION >= 0x3c0
+static void inline Py_SET_REFCNT_IMMORTAL(PyObject *object) {
+    // Normally done only with 3.13, but it makes sense to do this.
+    if (_PyObject_IS_GC(object) && _PyObject_GC_IS_TRACKED(object)) {
+        Nuitka_GC_UnTrack(object);
+    }
+
+#ifdef Py_GIL_DISABLED
+    object->ob_tid = _Py_UNOWNED_TID;
+    object->ob_ref_local = _Py_IMMORTAL_REFCNT_LOCAL;
+    object->ob_ref_shared = 0;
+#else
+    object->ob_refcnt = _Py_IMMORTAL_REFCNT;
+#endif
+}
+#else
+#define Py_SET_REFCNT_IMMORTAL(object)
+#endif
+
 #endif
+
+//     Part of "Nuitka", an optimizing Python compiler that is compatible and
+//     integrates with CPython, but also works on its own.
+//
+//     Licensed under the Apache License, Version 2.0 (the "License");
+//     you may not use this file except in compliance with the License.
+//     You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//     Unless required by applicable law or agreed to in writing, software
+//     distributed under the License is distributed on an "AS IS" BASIS,
+//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//     See the License for the specific language governing permissions and
+//     limitations under the License.

nuitka/build/include/nuitka/builtins.h

@@ -1,20 +1,5 @@
-//     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-//
-//     Part of "Nuitka", an optimizing Python compiler that is compatible and
-//     integrates with CPython, but also works on its own.
-//
-//     Licensed under the Apache License, Version 2.0 (the "License");
-//     you may not use this file except in compliance with the License.
-//     You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//     Unless required by applicable law or agreed to in writing, software
-//     distributed under the License is distributed on an "AS IS" BASIS,
-//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//     See the License for the specific language governing permissions and
-//     limitations under the License.
-//
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
 #ifndef __NUITKA_BUILTINS_H__
 #define __NUITKA_BUILTINS_H__
 
@@ -95,3 +80,18 @@ NUITKA_MAY_BE_UNUSED static void Nuitka_SysSetObject(char const *name, PyObject
 }
 
 #endif
+
+//     Part of "Nuitka", an optimizing Python compiler that is compatible and
+//     integrates with CPython, but also works on its own.
+//
+//     Licensed under the Apache License, Version 2.0 (the "License");
+//     you may not use this file except in compliance with the License.
+//     You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//     Unless required by applicable law or agreed to in writing, software
+//     distributed under the License is distributed on an "AS IS" BASIS,
+//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//     See the License for the specific language governing permissions and
+//     limitations under the License.

nuitka/build/include/nuitka/calling.h

@@ -1,20 +1,5 @@
-//     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-//
-//     Part of "Nuitka", an optimizing Python compiler that is compatible and
-//     integrates with CPython, but also works on its own.
-//
-//     Licensed under the Apache License, Version 2.0 (the "License");
-//     you may not use this file except in compliance with the License.
-//     You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//     Unless required by applicable law or agreed to in writing, software
-//     distributed under the License is distributed on an "AS IS" BASIS,
-//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//     See the License for the specific language governing permissions and
-//     limitations under the License.
-//
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
 #ifndef __NUITKA_CALLING_H__
 #define __NUITKA_CALLING_H__
 
@@ -26,7 +11,7 @@
 // For exception test formatting and call code mostly.
 extern char const *GET_CALLABLE_NAME(PyObject *object);
 extern char const *GET_CALLABLE_DESC(PyObject *object);
-extern char const *GET_CLASS_NAME(PyObject *klass);
+extern char const *GET_CLASS_NAME(PyObject *class_object);
 extern char const *GET_INSTANCE_CLASS_NAME(PyThreadState *tstate, PyObject *instance);
 
 // Also used in generated helper code.
@@ -121,3 +106,18 @@ extern void formatCannotInstantiateAbstractClass(PyThreadState *tstate, PyTypeOb
 #include "nuitka/helper/calling_generated.h"
 
 #endif
+
+//     Part of "Nuitka", an optimizing Python compiler that is compatible and
+//     integrates with CPython, but also works on its own.
+//
+//     Licensed under the Apache License, Version 2.0 (the "License");
+//     you may not use this file except in compliance with the License.
+//     You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//     Unless required by applicable law or agreed to in writing, software
+//     distributed under the License is distributed on an "AS IS" BASIS,
+//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//     See the License for the specific language governing permissions and
+//     limitations under the License.