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

nuitka/build/SconsCaching.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
+
+
 """ Caching of C compiler output.
 
 """
@@ -38,12 +24,13 @@ from nuitka.utils.FileOperations import (
     makePath,
 )
 from nuitka.utils.Importing import importFromInlineCopy
-from nuitka.utils.Utils import hasMacOSIntelSupport, isMacOS, isWin32Windows
+from nuitka.utils.Utils import hasMacOSIntelSupport, isMacOS
 
 from .SconsProgress import updateSconsProgressBar
 from .SconsUtils import (
     getExecutablePath,
     getSconsReportValue,
+    isZigName,
     setEnvironmentVariable,
 )
 
@@ -53,8 +40,8 @@ def _getPythonDirCandidates(python_prefix):
 
     for python_dir in (
         sys.prefix,
-        os.environ.get("CONDA_PREFIX"),
-        os.environ.get("CONDA"),
+        os.getenv("CONDA_PREFIX"),
+        os.getenv("CONDA"),
     ):
         if python_dir and python_dir not in result:
             result.append(python_dir)
@@ -63,15 +50,7 @@ def _getPythonDirCandidates(python_prefix):
 
 
 def _getCcacheGuessedPaths(python_prefix):
-    if isWin32Windows():
-        # Search the compiling Python, the Scons Python (likely the same, but not necessarily)
-        # and then Anaconda, if an environment variable present from activated, or installed in
-        # CI like GitHub actions.
-        for python_dir in _getPythonDirCandidates(python_prefix):
-            yield os.path.join(python_dir, "bin", "ccache.exe")
-            yield os.path.join(python_dir, "scripts", "ccache.exe")
-
-    elif isMacOS():
+    if isMacOS():
         # For macOS, we might find Homebrew ccache installed but not in PATH.
         for python_dir in _getPythonDirCandidates(python_prefix):
             yield os.path.join(python_dir, "bin", "ccache")
@@ -81,7 +60,7 @@ def _getCcacheGuessedPaths(python_prefix):
 
 
 def _injectCcache(env, cc_path, python_prefix, assume_yes_for_downloads):
-    ccache_binary = os.environ.get("NUITKA_CCACHE_BINARY")
+    ccache_binary = os.getenv("NUITKA_CCACHE_BINARY")
 
     # If not provided, search it in PATH and guessed directories.
     if ccache_binary is None:
@@ -103,27 +82,17 @@ def _injectCcache(env, cc_path, python_prefix, assume_yes_for_downloads):
                     break
 
         if ccache_binary is None:
-            if isWin32Windows():
-                url = "https://github.com/ccache/ccache/releases/download/v4.6/ccache-4.6-windows-32.zip"
-                ccache_binary = getCachedDownload(
-                    url=url,
-                    is_arch_specific=False,
-                    specificity=url.rsplit("/", 2)[1],
-                    flatten=True,
-                    binary="ccache.exe",
-                    message="Nuitka will make use of ccache to speed up repeated compilation.",
-                    reject=None,
-                    assume_yes_for_downloads=assume_yes_for_downloads,
-                )
-            elif hasMacOSIntelSupport():
+            if hasMacOSIntelSupport():
                 # The 10.14 is the minimum we managed to compile ccache for.
                 if tuple(int(d) for d in platform.release().split(".")) >= (18, 2):
                     url = "https://nuitka.net/ccache/v4.2.1/ccache-4.2.1.zip"
 
                     ccache_binary = getCachedDownload(
+                        name="ccache",
                         url=url,
                         is_arch_specific=False,
                         specificity=url.rsplit("/", 2)[1],
+                        unzip=True,
                         flatten=True,
                         binary="ccache",
                         message="Nuitka will make use of ccache to speed up repeated compilation.",
@@ -133,21 +102,17 @@ def _injectCcache(env, cc_path, python_prefix, assume_yes_for_downloads):
 
     else:
         scons_details_logger.info(
-            "Using ccache '%s' from NUITKA_CCACHE_BINARY environment variable."
+            "Using ccache '%s' from 'NUITKA_CCACHE_BINARY' environment variable."
             % ccache_binary
         )
 
     if ccache_binary is not None and os.path.exists(ccache_binary):
-        # Make sure the
         # In case we are on Windows, make sure the Anaconda form runs outside of Anaconda
         # environment, by adding DLL folder to PATH.
         assert areSamePaths(
             getExecutablePath(os.path.basename(env.the_compiler), env=env), cc_path
         )
 
-        # We use absolute paths for CC, pass it like this, as ccache does not like absolute.
-        env["CXX"] = env["CC"] = '"%s" "%s"' % (ccache_binary, cc_path)
-
         # Spare ccache the detection of the compiler, seems it will also misbehave when it's
         # prefixed with "ccache" on old gcc versions in terms of detecting need for C++ linkage.
         env["LINK"] = '"%s"' % cc_path
@@ -159,58 +124,80 @@ def _injectCcache(env, cc_path, python_prefix, assume_yes_for_downloads):
             "Providing real CC path '%s' via PATH extension." % cc_path
         )
 
+        values = [ccache_binary, cc_path]
+
+        if isZigName(env.the_cc_name):
+            values.append("c++" if env.c11_mode else "cc")
+
+        # We use absolute paths for CC, pass it like this, as ccache does not like absolute.
+        env["CXX"] = env["CC"] = " ".join('"%s"' % value for value in values)
+
+        return True
+
+    return False
+
 
 def enableCcache(
-    env,
-    source_dir,
-    python_prefix,
-    assume_yes_for_downloads,
+    env, source_dir, python_prefix, assume_yes_for_downloads, disable_ccache
 ):
-    # The ccache needs absolute path, otherwise it will not work.
-    ccache_logfile = os.path.abspath(
-        os.path.join(source_dir, "ccache-%d.txt" % os.getpid())
-    )
+    inject_ccache = not disable_ccache
 
-    setEnvironmentVariable(env, "CCACHE_LOGFILE", ccache_logfile)
-    env["CCACHE_LOGFILE"] = ccache_logfile
-
-    # Unless asked to do otherwise, store ccache files in our own directory.
-    if "CCACHE_DIR" not in os.environ:
-        ccache_dir = os.path.join(getCacheDir(), "ccache")
-        makePath(ccache_dir)
-        ccache_dir = getExternalUsePath(ccache_dir)
-        setEnvironmentVariable(env, "CCACHE_DIR", ccache_dir)
-        env["CCACHE_DIR"] = ccache_dir
-
-    if "CLCACHE_MEMCACHED" in os.environ:
-        scons_logger.warning(
-            "The setting of 'CLCACHE_MEMCACHED' environment is not supported with clcache."
+    if inject_ccache:
+        # The ccache needs absolute path, otherwise it will not work.
+        ccache_logfile = getExternalUsePath(
+            os.path.abspath(os.path.join(source_dir, "ccache-%d.txt" % os.getpid())),
+            only_dirname=True,
         )
-        setEnvironmentVariable(env, "CLCACHE_MEMCACHED", None)
 
-    # We know the include files we created are safe to use.
-    setEnvironmentVariable(
-        env, "CCACHE_SLOPPINESS", "include_file_ctime,include_file_mtime"
-    )
+        setEnvironmentVariable(env, "CCACHE_LOGFILE", ccache_logfile)
+        env["CCACHE_LOGFILE"] = ccache_logfile
 
-    # First check if it's not already supposed to be a ccache, then do nothing.
-    cc_path = getExecutablePath(env.the_compiler, env=env)
+        # Unless asked to do otherwise, store ccache files in our own directory.
+        if "CCACHE_DIR" not in os.environ:
+            ccache_dir = getCacheDir("ccache")
+            makePath(ccache_dir)
+            ccache_dir = getExternalUsePath(ccache_dir)
+            setEnvironmentVariable(env, "CCACHE_DIR", ccache_dir)
+            env["CCACHE_DIR"] = ccache_dir
 
-    cc_is_link, cc_link_path = getLinkTarget(cc_path)
-    if cc_is_link and os.path.basename(cc_link_path) == "ccache":
-        scons_details_logger.info(
-            "Chosen compiler %s is pointing to ccache %s already."
-            % (cc_path, cc_link_path)
+        if "CLCACHE_MEMCACHED" in os.environ:
+            scons_logger.warning(
+                "The setting of 'CLCACHE_MEMCACHED' environment is not supported with clcache."
+            )
+            setEnvironmentVariable(env, "CLCACHE_MEMCACHED", None)
+
+        # We know the include files we created are safe to use.
+        setEnvironmentVariable(
+            env, "CCACHE_SLOPPINESS", "include_file_ctime,include_file_mtime"
         )
 
-        return True
+        # First check if it's not already supposed to be a ccache, then do nothing.
+        cc_path = getExecutablePath(env.the_compiler, env=env)
 
-    return _injectCcache(
-        env=env,
-        cc_path=cc_path,
-        python_prefix=python_prefix,
-        assume_yes_for_downloads=assume_yes_for_downloads,
-    )
+        cc_is_link, cc_link_path = getLinkTarget(cc_path)
+        if cc_is_link and os.path.basename(cc_link_path) == "ccache":
+            scons_details_logger.info(
+                "Chosen compiler %s is pointing to ccache %s already."
+                % (cc_path, cc_link_path)
+            )
+
+            inject_ccache = False
+
+    if inject_ccache:
+        inject_ccache = _injectCcache(
+            env=env,
+            cc_path=cc_path,
+            python_prefix=python_prefix,
+            assume_yes_for_downloads=assume_yes_for_downloads,
+        )
+
+    # If we failed to inject zig argument into ccache command line, we need to
+    # do it now.
+    if isZigName(env.the_cc_name) and inject_ccache is False:
+        env["CXX"] = env["CC"] = '"%s" "%s"' % (
+            cc_path,
+            "cc" if env.c11_mode else "c++",
+        )
 
 
 def enableClcache(env, source_dir):
@@ -249,7 +236,7 @@ def enableClcache(env, source_dir):
 
     # Unless asked to do otherwise, store ccache files in our own directory.
     if "CLCACHE_DIR" not in os.environ:
-        clcache_dir = os.path.join(getCacheDir(), "clcache")
+        clcache_dir = getCacheDir("clcache")
         makePath(clcache_dir)
         clcache_dir = getExternalUsePath(clcache_dir)
         setEnvironmentVariable(env, "CLCACHE_DIR", clcache_dir)
@@ -434,3 +421,19 @@ def runClCache(args, env):
     updateSconsProgressBar()
 
     return result
+
+
+#     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.