Nuitka-winsvc 1.8__cp311-cp311-win_amd64.whl → 2.5.1__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,21 +8,33 @@
 from __future__ import print_function
 
 import os
+import pickle
 import shutil
 import signal
 import sys
 
 from nuitka.__past__ import basestring, unicode
 from nuitka.containers.OrderedDicts import OrderedDict
+from nuitka.Progress import enableThreading
 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
@@ -47,6 +45,10 @@ def initScons():
 
     SCons.dblite.dblite.sync = no_sync
 
+    # We use threads during build, so keep locks if necessary for progress bar
+    # updates.
+    enableThreading()
+
 
 def setupScons(env, source_dir):
     env["BUILD_DIR"] = source_dir
@@ -160,7 +162,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 +178,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 +212,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 +240,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 +276,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 +295,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 +307,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 +325,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 +369,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 +400,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 +434,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 +452,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 +548,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 +560,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 +593,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 +616,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 +671,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 +691,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 +746,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 +852,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. """