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

nuitka/build/Backend.scons

@@ -1,21 +1,6 @@
 # -*- python -*-
-#     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
+
 
 """
 The Nuitka scons file. If you have Scons or platform knowledge, please be
@@ -53,7 +38,14 @@ from nuitka.Tracing import (
     scons_logger,
     setQuiet,
 )
-from nuitka.utils.Execution import check_output
+from nuitka.utils.FileOperations import (
+    changeFilenameExtension,
+    deleteFile,
+    getExternalUsePath,
+    getFilenameExtension,
+    getNormalizedPath,
+    isFilesystemEncodable,
+)
 from nuitka.utils.Json import loadJsonFromFilename
 from nuitka.utils.Utils import (
     isDebianBasedLinux,
@@ -101,7 +93,7 @@ from .SconsUtils import (
     writeSconsReport,
 )
 
-# spell-checker: ignore ccversion,ccflags,werror,cppdefines,cpppath
+# spell-checker: ignore ccversion,cflags,ccflags,werror,cppdefines,cpppath,linkflags,libpath
 
 # Set the arguments.
 setArguments(ARGUMENTS)
@@ -118,18 +110,12 @@ source_dir = getArgumentRequired("source_dir")
 nuitka_src = getArgumentRequired("nuitka_src")
 static_src = os.path.join(source_dir, "static")
 
-# The name of executable or extension module that we produce.
-result_basepath = getArgumentRequired("result_name")
-
-# The name of executable that we produce (in executable mode).
-result_exe = getArgumentDefaulted("result_exe", None)
+# The name of executable that we are supposed to produce.
+result_exe = getArgumentRequired("result_exe")
 
 # Name of the main program (in executable mode, typically __main__ but can be in a package too.)
 main_module_name = getArgumentDefaulted("main_module_name", "__main__")
 
-# The suffix for an extension module (in module mode).
-module_suffix = getArgumentDefaulted("module_suffix", None)
-
 # Full names shall be used, no remapping for cacheable filenames.
 full_names = getArgumentBool("full_names", False)
 
@@ -139,6 +125,10 @@ module_mode = getArgumentBool("module_mode", False)
 # Debug mode: Less optimizations, debug information in the resulting binary.
 debug_mode = getArgumentBool("debug_mode", False)
 
+# Debugger mode: Debug information in the resulting binary and intention to run
+# in debugger.
+debugger_mode = getArgumentBool("debugger_mode", False)
+
 # Profiling mode: Outputs vmprof based information from program run.
 profile_mode = getArgumentBool("profile_mode", False)
 
@@ -146,8 +136,14 @@ profile_mode = getArgumentBool("profile_mode", False)
 python_version_str = getArgumentRequired("python_version")
 python_version = tuple(int(d) for d in python_version_str.split("."))
 
+gil_mode = getArgumentBool("gil_mode")
+
 # The ABI flags to target.
 abiflags = getArgumentDefaulted("abiflags", "")
+
+if not gil_mode and "t" not in abiflags:
+    abiflags = "t" + abiflags
+
 python_abi_version = python_version_str + abiflags
 
 # Python debug mode: reference count checking, assertions in CPython core.
@@ -167,6 +163,9 @@ deployment_mode = getArgumentBool("deployment", False)
 # Experimental indications. Do things that are not yet safe to do.
 no_deployment = getArgumentList("no_deployment", "")
 
+# Debug mode indications. Do check things with fine granularity.
+debug_modes = getArgumentList("debug_modes", "")
+
 # Tracing mode. Output program progress.
 trace_mode = getArgumentBool("trace_mode", False)
 
@@ -177,12 +176,8 @@ lto_mode = getArgumentDefaulted("lto_mode", "auto")
 # PGO mode: Use profile guided optimization of C compiler if available.
 pgo_mode = getArgumentDefaulted("pgo_mode", "no")
 
-# Windows target mode: Compile for Windows. Used to be an option, but we
-# no longer cross compile this way.
-win_target = os.name == "nt"
-
-# Windows subsystem mode: Disable console for windows builds.
-disable_console = getArgumentBool("disable_console", False)
+# Console mode specified
+console_mode = getArgumentDefaulted("console_mode", "attach")
 
 # Windows might be running a Python whose DLL we have to use.
 uninstalled_python = getArgumentBool("uninstalled_python", False)
@@ -203,7 +198,7 @@ clang_mode = getArgumentBool("clang_mode", False)
 # Clang on Windows with no requirement to use MinGW64 or using MSYS2 MinGW flavor,
 # is changed to ClangCL from Visual Studio.
 clangcl_mode = False
-if win_target and not mingw_mode and clang_mode:
+if os.name == "nt" and not mingw_mode and clang_mode:
     clang_mode = False
     clangcl_mode = True
 
@@ -217,6 +212,9 @@ standalone_mode = getArgumentBool("standalone_mode", False)
 # Onefile mode
 onefile_mode = getArgumentBool("onefile_mode", False)
 
+# MacOS bundle
+macos_bundle_mode = getArgumentBool("macos_bundle_mode", False)
+
 # Onefile temp mode
 onefile_temp_mode = getArgumentBool("onefile_temp_mode", False)
 
@@ -227,13 +225,15 @@ forced_stderr_path = getArgumentDefaulted("forced_stderr_path", None)
 show_scons_mode = getArgumentBool("show_scons", False)
 scons_details_logger.is_quiet = not show_scons_mode
 
-if int(os.environ.get("NUITKA_QUIET", "0")):
+if int(os.getenv("NUITKA_QUIET", "0")):
     setQuiet()
 
 # Home of Python to be compiled against, used to find include files and
 # libraries to link against.
 python_prefix = getArgumentRequired("python_prefix")
 
+python_prefix_external = getExternalUsePath(python_prefix)
+
 # Forced MSVC version (windows-only)
 msvc_version = getArgumentDefaulted("msvc_version", None)
 
@@ -261,6 +261,10 @@ python_sysflag_unicode = getArgumentBool("python_sysflag_unicode", False)
 python_sysflag_utf8 = getArgumentBool("python_sysflag_utf8", False)
 # python_sysflag_optimize
 python_sysflag_optimize = getArgumentInt("python_sysflag_optimize", 0)
+# python_sysflag_dontwritebytecode
+python_sysflag_dontwritebytecode = getArgumentBool(
+    "python_sysflag_dontwritebytecode", False
+)
 # python_flag_no_asserts
 python_flag_no_asserts = getArgumentBool("python_flag_no_asserts", False)
 # python_flag_no_docstrings
@@ -287,6 +291,9 @@ cpp_include_dirs = getArgumentList("cpp_include_dirs", "")
 link_dirs = getArgumentList("link_dirs", "")
 link_libraries = getArgumentList("link_libraries", "")
 
+# From statically compiled modules of the Python
+link_module_libs = getArgumentList("link_module_libs", "")
+
 # Allow automatic downloads for ccache, etc.
 assume_yes_for_downloads = getArgumentBool("assume_yes_for_downloads", False)
 
@@ -299,6 +306,9 @@ macos_min_version = getArgumentDefaulted("macos_min_version", "")
 # Target arch for macOS.
 macos_target_arch = getArgumentDefaulted("macos_target_arch", "")
 
+# gcc compiler cf_protection option
+cf_protection = getArgumentDefaulted("cf_protection", "auto")
+
 if getArgumentBool("progress_bar", True) and not show_scons_mode:
     enableSconsProgressBar()
 
@@ -319,6 +329,7 @@ env = createEnvironment(
     target_arch=target_arch,
     experimental=experimental,
     no_deployment=no_deployment,
+    debug_modes=debug_modes,
 )
 
 scons_details_logger.info("Initial CC: %r" % env.get("CC"))
@@ -335,7 +346,7 @@ if "CC" in os.environ:
 elif clangcl_mode:
     # If possible, add Clang directory from MSVC if available.
     addClangClPathFromMSVC(env=env)
-elif clang_mode:
+elif clang_mode and not mingw_mode:
     # If requested by the user, use the clang compiler, overriding what was
     # said in environment.
 
@@ -356,9 +367,11 @@ env.the_compiler = env["CC"]
 env.the_cc_name = os.path.normcase(os.path.basename(env.the_compiler))
 env.standalone_mode = standalone_mode
 env.debug_mode = debug_mode
+env.debugger_mode = debugger_mode
 env.unstripped_mode = unstripped_mode
-env.disable_console = disable_console
+env.console_mode = console_mode
 env.source_dir = source_dir
+env.nuitka_src = nuitka_src
 env.low_memory = low_memory
 env.macos_min_version = macos_min_version
 env.macos_target_arch = macos_target_arch
@@ -374,10 +387,25 @@ env.gcc_mode = isGccName(env.the_cc_name) or clang_mode
 env.clang_mode = clang_mode
 
 # Only use MSVC if not already clear, we are using MinGW.
-env.msvc_mode = win_target and not env.gcc_mode
-env.mingw_mode = win_target and env.gcc_mode
+env.msvc_mode = os.name == "nt" and not env.gcc_mode
+env.mingw_mode = os.name == "nt" and env.gcc_mode
 env.clangcl_mode = clangcl_mode
 
+# For Python3.13, we need to enforce it for now to use MSVC
+if os.name == "nt" and not env.msvc_mode and python_version >= (3, 13):
+    scons_logger.sysexit(
+        """\
+Sorry, non-MSVC is not currently supported with Python 3.13,
+due to differences in layout internal structures of Python.
+
+Newer Nuitka will work to solve this. Use Python 3.12 or
+option "--msvc=latest" as a workaround for now and wait
+for updates of Nuitka to add MinGW64 support back."""
+    )
+
+# gcc compiler cf_protection option
+env.cf_protection = cf_protection
+
 # Consider switching from gcc to its g++ compiler as a workaround that makes us work without C11.
 switchFromGccToGpp(
     env=env,
@@ -392,7 +420,7 @@ if show_scons_mode:
     my_print("Scons: Compiler used", end=" ")
     my_print(getExecutablePath(env.the_compiler, env=env), end=" ")
 
-    if win_target and env.msvc_mode:
+    if os.name == "nt" and env.msvc_mode:
         my_print("(MSVC %s)" % getMsvcVersionString(env))
 
     my_print()
@@ -409,6 +437,7 @@ setupCCompiler(
     lto_mode=lto_mode,
     pgo_mode=pgo_mode,
     job_count=job_count,
+    onefile_compile=False,
 )
 
 
@@ -422,14 +451,14 @@ if env.gcc_mode and not env.clang_mode and env.gcc_version >= (8,):
                 "--file-prefix-map=%s=%s" % (os.path.normpath(source_dir), "."),
                 "--file-prefix-map=%s=%s"
                 % (
-                    os.path.normpath(os.path.join(source_dir, "static_src")),
-                    os.path.normpath(os.path.join(nuitka_src, "static_src")),
+                    os.path.normpath(os.path.join(env.source_dir, "static_src")),
+                    os.path.normpath(os.path.join(env.nuitka_src, "static_src")),
                 ),
             ]
         )
 
 if env.msvc_mode:
-    # With Clang on Windows, there is also an linker to use.
+    # With Clang on Windows, there is also an linker to use. spell-checker: ignore bigobj
     env.Append(
         CCFLAGS=[
             "/EHsc",  # No C++ exception handling code.
@@ -444,7 +473,7 @@ if env.msvc_mode:
 
     if module_mode:
         # Make sure we handle import library on our own and put it into the
-        # build directory.
+        # build directory, spell-checker: ignore IMPLIB
 
         no_import_lib = True
         env.Append(
@@ -460,10 +489,19 @@ if env.debug_mode:
     if env.gcc_mode:
         # Allow gcc/clang to point out all kinds of inconsistency to us by
         # raising an error.
+
+        if "allow-c-warnings" not in env.experimental_flags and not env.debugger_mode:
+            env.Append(
+                CCFLAGS=[
+                    "-Wall",
+                    "-Werror",
+                ]
+            )
+        else:
+            env.Append(CCFLAGS=["-Wno-unused-but-set-variable"])
+
         env.Append(
             CCFLAGS=[
-                "-Wall",
-                "-Werror",
                 # Unfortunately Py_INCREF(Py_False) triggers aliasing warnings,
                 # which are unfounded, so disable them.
                 "-Wno-error=strict-aliasing",
@@ -495,6 +533,9 @@ if env.debug_mode:
         if python_version >= (3, 4):
             env.Append(CCFLAGS=["/wd4512", "/wd4510", "/wd4610"])
 
+        if python_version >= (3, 13):
+            env.Append(CCFLAGS=["/wd4324"])
+
         # We use null arrays in our structure Python declarations, which C11 does
         # not really allow, but should work.
         env.Append(CCFLAGS=["/wd4200"])
@@ -515,6 +556,9 @@ if trace_mode:
 if env.standalone_mode:
     env.Append(CPPDEFINES=["_NUITKA_STANDALONE"])
 
+if macos_bundle_mode:
+    env.Append(CPPDEFINES=["_NUITKA_MACOS_BUNDLE"])
+
 if onefile_mode:
     env.Append(CPPDEFINES=["_NUITKA_ONEFILE_MODE"])
 
@@ -538,44 +582,17 @@ if env.static_libpython:
     env.Append(CPPDEFINES=["Py_NO_ENABLE_SHARED"])
 
 
-def detectHostMultiArch():
-    stdout = check_output("dpkg-architecture")
-
-    for line in stdout.splitlines():
-        line = line.strip()
-
-        if line.startswith(b"DEB_HOST_MULTI_ARCH="):
-            return line.split("=", 1)[1].decode("utf8")
-
-    return None
-
-
-if env.gcc_mode and env.debian_python:
-    # TODO: Seems rather meaningless nowadays and hard codes this to not be
-    # self compiled or so.
-    if python_version == (3, 3):
-        host_multi_arch = detectHostMultiArch()
-
-        if host_multi_arch is not None:
-            env.Append(
-                CCFLAGS=[
-                    "-I"
-                    + os.path.join(
-                        "/usr/include/", host_multi_arch, "python" + python_abi_version
-                    )
-                ]
-            )
-
-
 def _detectPythonHeaderPath():
-    if win_target:
+    if os.name == "nt":
         # On Windows, the CPython installation layout is relatively fixed, but on MSYS2
         # compiled for mingw64, it's more standard.
 
         candidates = [
-            os.path.join(python_prefix, "include"),
+            os.path.join(python_prefix_external, "include"),
             # On MSYS2 with MinGW64 Python, it is also the other form.
-            os.path.join(python_prefix, "include", "python" + python_abi_version),
+            os.path.join(
+                python_prefix_external, "include", "python" + python_abi_version
+            ),
         ]
     else:
         # The python header path is a combination of python version and debug
@@ -583,10 +600,14 @@ def _detectPythonHeaderPath():
         # include path.
 
         candidates = [
-            os.path.join(python_prefix, "include", "python" + python_abi_version),
+            os.path.join(
+                python_prefix_external, "include", "python" + python_abi_version
+            ),
+            # CPython source code checkout
+            os.path.join(python_prefix_external, "Include"),
             # Haiku specific paths:
             os.path.join(
-                python_prefix, "develop/headers", "python" + python_abi_version
+                python_prefix_external, "develop/headers", "python" + python_abi_version
             ),
         ]
 
@@ -594,7 +615,7 @@ def _detectPythonHeaderPath():
         if python_debug and "d" in python_abi_version:
             candidates.append(
                 os.path.join(
-                    python_prefix,
+                    python_prefix_external,
                     "include",
                     "python" + python_abi_version.replace("d", ""),
                 )
@@ -602,55 +623,67 @@ def _detectPythonHeaderPath():
 
     for candidate in candidates:
         if os.path.exists(os.path.join(candidate, "Python.h")):
-            return candidate
-
-    if win_target:
-        scons_logger.sysexit(
-            """Error, you seem to be using the unsupported embeddable CPython distribution."""
-        )
+            yield candidate
+            break
     else:
-        scons_logger.sysexit(
-            """\
+        if os.name == "nt":
+            scons_logger.sysexit(
+                """\
+Error, you seem to be using the unsupported embeddable CPython distribution \
+use a full Python instead."""
+            )
+        else:
+            scons_logger.sysexit(
+                """\
 Error, no 'Python.h' %s headers can be found at '%s', dependency \
 not satisfied!"""
-            % ("debug" if python_debug else "development", candidates)
-        )
+                % ("debug" if python_debug else "development", candidates)
+            )
 
+    if python_version >= (3, 13):
+        yield os.path.join(candidate, "internal", "mimalloc")
 
-env.Append(CPPPATH=[_detectPythonHeaderPath()])
+    if env.self_compiled_python_uninstalled:
+        yield python_prefix_external
+
+
+env.Append(CPPPATH=list(_detectPythonHeaderPath()))
 
 # To support self-built Python on Windows, need to also add the "PC" directory,
 # that a normal install won't have.
 if os.name == "nt":
-    python_header_path = os.path.join(python_prefix, "PC")
+    python_header_path = os.path.join(python_prefix_external, "PC")
 
     if os.path.exists(python_header_path):
         env.Append(CPPPATH=[python_header_path])
 
-
-def getWindowsPythonDLLPath():
-    return os.environ["NUITKA_PYTHON_DLL_PATH"]
-
-
 if env.nuitka_python:
     env.Append(CPPDEFINES=["_NUITKA_PYTHON"])
 
 if env.static_libpython:
     env.Append(CPPDEFINES=["_NUITKA_STATIC_LIBPYTHON"])
 
-if env.static_libpython and (not win_target or env.nuitka_python):
+if not gil_mode:
+    env.Append(CPPDEFINES="Py_GIL_DISABLED")
+
+# TODO: This ought to be decided outside of scons and per flavor maybe.
+if env.static_libpython and (
+    (not os.name == "nt" and not isMacOS()) or env.nuitka_python
+):
     env.Append(CPPDEFINES=["_NUITKA_USE_UNEXPOSED_API"])
 
-if win_target:
+if os.name == "nt":
     if env.nuitka_python:
         env.Append(
             LINKFLAGS=[
                 "/LTCG",
-                "/USEPROFILE:PGD=" + os.path.join(python_prefix, "python.pgd"),
+                "/USEPROFILE:PGD=" + os.path.join(python_prefix_external, "python.pgd"),
             ]
         )
 
-        link_data = loadJsonFromFilename(os.path.join(python_prefix, "link.json"))
+        link_data = loadJsonFromFilename(
+            os.path.join(python_prefix_external, "link.json")
+        )
         env.Append(LIBS=link_data["libraries"])
         env.Append(LIBPATH=link_data["library_dirs"])
         for define, value in link_data["macros"]:
@@ -683,7 +716,7 @@ if win_target:
                 pc_build_dir = "PCBuild"
 
             for candidate in ("libs", pc_build_dir):
-                win_lib_path = os.path.join(python_prefix, candidate)
+                win_lib_path = os.path.join(python_prefix_external, candidate)
 
                 if os.path.exists(os.path.join(win_lib_path, win_lib_name + ".lib")):
                     break
@@ -697,17 +730,26 @@ if win_target:
             addWinLib()
 elif not module_mode:
     # Add the python library path to the library path
-    python_lib_path = os.path.join(python_prefix, "lib")
+    if env.self_compiled_python_uninstalled:
+        python_lib_path = python_prefix_external
+    else:
+        python_lib_path = os.path.join(python_prefix_external, "lib")
+
     env.Append(LIBPATH=[python_lib_path])
 
+    # Any module libs that are for self-compiled Python to be static.
+    env.Append(_LIBFLAGS=["-l" + lib_desc for lib_desc in link_module_libs])
+
     if env.nuitka_python:
-        link_data = loadJsonFromFilename(os.path.join(python_prefix, "link.json"))
+        link_data = loadJsonFromFilename(
+            os.path.join(python_prefix_external, "link.json")
+        )
         for lib in link_data["libraries"]:
             # Need to prevent Scons from stripping .a from the passed in libs.
-            if os.path.isfile(lib):
-                env.Append(_LIBFLAGS=[lib])
-            elif lib.startswith(":") and lib.endswith(".a"):
+            if lib.startswith(":") and lib.endswith(".a"):
                 env.Append(_LIBFLAGS=["-l" + lib])
+            elif os.path.isfile(lib):
+                env.Append(_LIBFLAGS=[lib])
             else:
                 env.Append(LIBS=[lib])
         env.Append(LIBPATH=link_data["library_dirs"])
@@ -725,19 +767,22 @@ elif not module_mode:
         env.Append(LIBS=[env.File(env.static_libpython)])
 
         # The linker won't succeed in searching for those for system Python of Debian
-        # compiled Pythons. Help that. For self-compiled,
-        if python_prefix == "/usr" and isDebianBasedLinux():
+        # compiled Pythons. Help that. spell-checker: ignore rdynamic,Xlinker,pthread
+        if python_prefix_external == "/usr" and isDebianBasedLinux():
             env.Append(LIBS=["z", "m", "util", "pthread"])
 
             if python_version >= (3,):
                 env.Append(LIBS=["expat"])
 
             env.Append(LINKFLAGS=["-Xlinker", "-export-dynamic", "-rdynamic"])
+
+        if env.arch_python:
+            env.Append(LINKFLAGS=["-rdynamic"])
     else:
         # Fedora, Debian and Ubuntu distinguish the system libraries like this.
         if (
             python_debug
-            and python_prefix == "/usr"
+            and python_prefix_external == "/usr"
             and python_version < (3,)
             and (isDebianBasedLinux() or isFedoraBasedLinux())
         ):
@@ -745,7 +790,7 @@ elif not module_mode:
         else:
             env.Append(LIBS=["python" + python_abi_version])
 
-    if python_prefix != "/usr" and "linux" in sys.platform:
+    if python_prefix_external != "/usr" and "linux" in sys.platform:
         env.Append(LIBS=["dl", "pthread", "util", "rt", "m"])
 
         if env.gcc_mode:
@@ -764,11 +809,12 @@ if isMacOS():
         env.Append(LINKFLAGS=["-undefined", "dynamic_lookup"])
     else:
         # For macOS we need to make sure install_name_tool can do its work
+        # spell-checker: ignore headerpad
         env.Append(LINKFLAGS=["-headerpad_max_install_names"])
 
 # The static include files reside in Nuitka installation, which may be where
 # the "nuitka.build" package lives.
-nuitka_include = os.path.join(nuitka_src, "include")
+nuitka_include = os.path.join(env.nuitka_src, "include")
 
 if not os.path.exists(os.path.join(nuitka_include, "nuitka", "prelude.h")):
     scons_logger.sysexit(
@@ -778,10 +824,29 @@ if not os.path.exists(os.path.join(nuitka_include, "nuitka", "prelude.h")):
 
 # We have include files in the build directory and the static include directory
 # that is located inside Nuitka installation.
-env.Append(CPPPATH=[source_dir, nuitka_include, os.path.join(nuitka_src, "static_src")])
+env.Append(
+    CPPPATH=[
+        source_dir,
+        nuitka_include,
+        os.path.join(env.nuitka_src, "static_src"),
+        os.path.join(env.nuitka_src, "inline_copy", "libbacktrace"),
+    ]
+)
+
+if env.static_libpython and python_version >= (3, 12):
+    env.Append(
+        CPPPATH=[
+            os.path.join(env.nuitka_src, "inline_copy", "python_hacl", "hacl_312"),
+            os.path.join(
+                env.nuitka_src, "inline_copy", "python_hacl", "hacl_312", "include"
+            ),
+        ]
+    )
+
+    env.Append(CPPDEFINES=["_NUITKA_INLINE_COPY_HACL"])
 
 # Set load libpython from binary directory default
-if env.gcc_mode and not isMacOS() and not win_target and not module_mode:
+if env.gcc_mode and not isMacOS() and not os.name == "nt" and not module_mode:
     if env.standalone_mode:
         rpath = "$$ORIGIN"
     else:
@@ -792,6 +857,7 @@ if env.gcc_mode and not isMacOS() and not win_target and not module_mode:
     # The rpath is no longer used unless we do this on modern Linux. The
     # option name is not very revealing, but basically without this, the
     # rpath in the binary will be ignored by the loader.
+    # spell-checker: ignore dtags
     if "linux" in sys.platform:
         env.Append(LINKFLAGS=["-Wl,--disable-new-dtags"])
 
@@ -820,8 +886,8 @@ else:
         # For complete outputs, we have to match the C runtime of the Python DLL, if any,
         # for Nuitka-Python there is of course none.
         if not env.nuitka_python and (
-            forced_stdout_path not in ("%NONE%", "%NULL%", None)
-            or forced_stderr_path not in ("%NONE%", "%NULL%", None)
+            forced_stdout_path not in ("{NONE}", "{NULL}", None)
+            or forced_stderr_path not in ("{NONE}", "{NULL}", None)
         ):
             env.Append(CCFLAGS=["/MD"])  # Multithreaded, dynamic version of C run time.
         else:
@@ -857,9 +923,8 @@ def discoverSourceFiles():
 
     result += [
         provideStaticSourceFile(
+            env=env,
             sub_path=filename,
-            nuitka_src=nuitka_src,
-            source_dir=source_dir,
             c11_mode=env.c11_mode,
         )
         for filename in static_src_filenames
@@ -870,13 +935,39 @@ def discoverSourceFiles():
 
 source_files = discoverSourceFiles()
 
+# Remove the target file to avoid cases where it falsely doesn't get rebuild
+# and then lingers from previous builds,
+deleteFile(result_exe, must_exist=False)
+
+# Workaround for MinGW64 not supporting unicode result paths for "-o" basename.
+if os.name == "nt" and not isFilesystemEncodable(result_exe):
+    result_exe = os.path.join(
+        os.path.dirname(result_exe),
+        "_nuitka_temp.pyd" if module_mode else "_nuitka_temp.exe",
+    )
+
+    if not isFilesystemEncodable(result_exe):
+        result_exe = getNormalizedPath(os.path.relpath(result_exe))
+
+    deleteFile(result_exe, must_exist=False)
+
 if module_mode:
-    # For Python modules, the standard shared library extension is not what
-    # gets used.
+    # For Python modules, the standard shared library extension is not what gets
+    # used. spell-checker: ignore SHLIBSUFFIX
+    module_suffix = getFilenameExtension(result_exe)
+    result_base_path = changeFilenameExtension(result_exe, "")
+
+    extra_suffix = getFilenameExtension(result_base_path)
+    if extra_suffix != "":
+        module_suffix = extra_suffix + module_suffix
+        result_base_path = changeFilenameExtension(result_base_path, "")
+
+    assert getFilenameExtension(result_base_path) == "", result_base_path
+
     env["SHLIBSUFFIX"] = module_suffix
 
     target = env.SharedLibrary(
-        result_basepath, source_files, no_import_lib=no_import_lib
+        result_base_path, source_files, no_import_lib=no_import_lib
     )
 else:
     target = env.Program(result_exe, source_files)
@@ -884,10 +975,6 @@ else:
 # Use compiler/linker flags provided via environment variables
 importEnvironmentVariableSettings(env)
 
-# Remove the target file to avoid cases where it falsely doesn't get rebuild
-# and then lingers from previous builds,
-if os.path.exists(target[0].abspath):
-    os.unlink(target[0].abspath)
 
 if job_count:
     scons_details_logger.info("Told to run compilation on %d CPUs." % job_count)
@@ -897,6 +984,7 @@ def createBuildDefinitionsFile():
     build_definitions = {}
 
     if uninstalled_python and not env.static_libpython:
+        # Use the non-external one, so it's not a short path.
         build_definitions["PYTHON_HOME_PATH"] = python_prefix
 
     build_definitions["NO_PYTHON_WARNINGS"] = 1 if no_python_warnings else 0
@@ -924,6 +1012,10 @@ def createBuildDefinitionsFile():
 
     build_definitions["SYSFLAG_OPTIMIZE"] = python_sysflag_optimize
 
+    build_definitions["SYSFLAG_DONTWRITEBYTECODE"] = (
+        1 if python_sysflag_dontwritebytecode else 0
+    )
+
     build_definitions["_NUITKA_NO_ASSERTS"] = 1 if python_flag_no_asserts else 0
 
     build_definitions["_NUITKA_NO_DOCSTRINGS"] = 1 if python_flag_no_docstrings else 0
@@ -939,25 +1031,23 @@ def createBuildDefinitionsFile():
     build_definitions["SYSFLAG_ISOLATED"] = 1 if python_sysflag_isolated else 0
 
     if forced_stdout_path:
-        if forced_stdout_path == "%NONE%":
+        if forced_stdout_path == "{NONE}":
             build_definitions["NUITKA_FORCED_STDOUT_NONE_BOOL"] = 1
-        elif forced_stdout_path == "%NULL%":
+        elif forced_stdout_path == "{NULL}":
             build_definitions["NUITKA_FORCED_STDOUT_NULL_BOOL"] = 1
         else:
             build_definitions["NUITKA_FORCED_STDOUT_PATH"] = forced_stdout_path
 
     if forced_stderr_path:
-        if forced_stderr_path == "%NONE%":
+        if forced_stderr_path == "{NONE}":
             build_definitions["NUITKA_FORCED_STDERR_NONE_BOOL"] = 1
-        elif forced_stderr_path == "%NULL%":
+        elif forced_stderr_path == "{NULL}":
             build_definitions["NUITKA_FORCED_STDERR_NULL_BOOL"] = 1
         else:
             build_definitions["NUITKA_FORCED_STDERR_PATH"] = forced_stderr_path
 
     build_definitions["NUITKA_MAIN_MODULE_NAME"] = main_module_name
-
-    if main_module_name != "__main__":
-        build_definitions["NUITKA_MAIN_PACKAGE_MODE"] = 1
+    build_definitions["NUITKA_MAIN_IS_PACKAGE_BOOL"] = main_module_name != "__main__"
 
     createDefinitionsFile(source_dir, "build_definitions.h", build_definitions)
 
@@ -966,7 +1056,7 @@ if forced_stderr_path and not forced_stdout_path:
     env.Append(CPPDEFINES=["NUITKA_STDERR_NOT_VISIBLE"])
 
 if file_reference_mode == "original":
-    env.Append(CPPDEFINES=["NUITKA_FILE_REFERENCE_ORIGINAL_MODE"])
+    env.Append(CPPDEFINES=["_NUITKA_FILE_REFERENCE_ORIGINAL_MODE"])
 
 
 createBuildDefinitionsFile()
@@ -998,7 +1088,6 @@ env.Append(LIBS=link_libraries)
 # Work around windows bugs and use watchdogs to track progress of compilation.
 enableSpawnMonitoring(
     env=env,
-    win_target=win_target,
     module_mode=module_mode,
     source_files=source_files,
 )
@@ -1008,12 +1097,13 @@ enableSpawnMonitoring(
 changeKeyboardInterruptToErrorExit()
 
 # Check if ccache is installed, and complain if it is not.
-if env.gcc_mode and not disable_ccache:
+if env.gcc_mode:
     enableCcache(
         env=env,
         source_dir=source_dir,
-        python_prefix=python_prefix,
+        python_prefix=python_prefix_external,
         assume_yes_for_downloads=assume_yes_for_downloads,
+        disable_ccache=disable_ccache,
     )
 
 if env.msvc_mode and not disable_ccache:
@@ -1022,12 +1112,24 @@ if env.msvc_mode and not disable_ccache:
         source_dir=source_dir,
     )
 
-writeSconsReport(
-    env=env,
-    source_dir=source_dir,
-)
+writeSconsReport(env=env, target=target)
 
 setSconsProgressBarTotal(name=env.progressbar_name, total=len(source_files))
 
 scons_details_logger.info("Launching Scons target: %s" % target)
 env.Default(target)
+
+#     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.