Nuitka-winsvc 2.1.6__cp311-cp311-win_amd64.whl → 2.2.1__cp311-cp311-win_amd64.whl

nuitka/build/SconsCaching.py

@@ -30,6 +30,7 @@ from .SconsProgress import updateSconsProgressBar
 from .SconsUtils import (
     getExecutablePath,
     getSconsReportValue,
+    isZigName,
     setEnvironmentVariable,
 )
 
@@ -100,21 +101,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
@@ -126,58 +123,79 @@ 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 = 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 = os.path.abspath(
+            os.path.join(source_dir, "ccache-%d.txt" % os.getpid())
         )
-        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):

nuitka/build/SconsCompilerSettings.py

@@ -34,6 +34,7 @@ from .SconsUtils import (
     getMsvcVersionString,
     isClangName,
     isGccName,
+    isZigName,
     raiseNoCompilerFoundErrorExit,
     setEnvironmentVariable,
 )
@@ -99,6 +100,10 @@ def _enableC11Settings(env):
         c11_mode = True
     elif env.clang_mode:
         c11_mode = True
+
+        # For now, zig doesn't support C11 mode in the form needed by Nuitka
+        if isZigName(env.the_cc_name):
+            c11_mode = False
     elif env.gcc_mode and env.gcc_version >= (5,):
         c11_mode = True
     else:
@@ -721,9 +726,13 @@ def setupCCompiler(env, lto_mode, pgo_mode, job_count, onefile_compile):
             # thing, and Nuitka-Python is not affected.
             env.Append(
                 LINKFLAGS=[
-                    "-O3"
-                    if env.nuitka_python or os.name == "nt" or not env.static_libpython
-                    else "-O2"
+                    (
+                        "-O3"
+                        if env.nuitka_python
+                        or os.name == "nt"
+                        or not env.static_libpython
+                        else "-O2"
+                    )
                 ]
             )
 
@@ -740,9 +749,13 @@ def setupCCompiler(env, lto_mode, pgo_mode, job_count, onefile_compile):
         if env.gcc_mode:
             env.Append(
                 CCFLAGS=[
-                    "-O3"
-                    if env.nuitka_python or os.name == "nt" or not env.static_libpython
-                    else "-O2"
+                    (
+                        "-O3"
+                        if env.nuitka_python
+                        or os.name == "nt"
+                        or not env.static_libpython
+                        else "-O2"
+                    )
                 ]
             )
         elif env.msvc_mode:

nuitka/build/SconsHacks.py

@@ -12,7 +12,6 @@ version.
 
 """
 
-
 import os
 import re
 

nuitka/build/SconsInterface.py

@@ -30,17 +30,22 @@ from nuitka.PythonVersions import (
     python_version,
     python_version_str,
 )
+from nuitka.utils.AppDirs import getCacheDirEnvironmentVariableName
+from nuitka.utils.Download import getDownloadCacheDir, getDownloadCacheName
 from nuitka.utils.Execution import (
     getExecutablePath,
     withEnvironmentVarsOverridden,
 )
 from nuitka.utils.FileOperations import (
+    changeFilenameExtension,
     deleteFile,
     getDirectoryRealPath,
     getExternalUsePath,
     getWindowsShortPathName,
     hasFilenameExtension,
     listDir,
+    makePath,
+    putTextFileContents,
     withDirectoryChange,
 )
 from nuitka.utils.InstalledPythons import findInstalledPython
@@ -105,7 +110,16 @@ def _getPythonForSconsExePath():
     if python_exe is not None:
         return python_exe
 
-    scons_supported_pythons = ("3.5", "3.6", "3.7", "3.8", "3.9", "3.10", "3.11")
+    scons_supported_pythons = (
+        "3.5",
+        "3.6",
+        "3.7",
+        "3.8",
+        "3.9",
+        "3.10",
+        "3.11",
+        "3.12",
+    )
     if not isWin32Windows():
         scons_supported_pythons += ("2.7", "2.6")
 
@@ -159,6 +173,14 @@ def _setupSconsEnvironment2():
 
     os.environ["NUITKA_PACKAGE_DIR"] = os.path.abspath(nuitka.__path__[0])
 
+    # When downloading in Scons, use the external path.
+    if isWin32Windows():
+        download_cache_dir = getDownloadCacheDir()
+        makePath(download_cache_dir)
+        os.environ[getCacheDirEnvironmentVariableName(getDownloadCacheName())] = (
+            getExternalUsePath(download_cache_dir)
+        )
+
     yield
 
     if old_pythonpath is not None:
@@ -247,6 +269,61 @@ def _buildSconsCommand(options, scons_filename):
     return scons_command
 
 
+def _createSconsDebugScript(source_dir, scons_command):
+    # we wrote debug shell script only if build process called, not "--version" call.
+    scons_debug_python_name = "scons-debug.py"
+
+    putTextFileContents(
+        filename=os.path.join(source_dir, scons_debug_python_name),
+        contents="""\
+# -*- coding: utf-8 -*-
+
+import sys
+import os
+import subprocess
+
+exit_code = subprocess.call(
+    %(scons_command)r,
+    env=%(env)r,
+    shell=False
+)"""
+        % {"scons_command": scons_command, "env": dict(os.environ)},
+        encoding="utf8",
+    )
+
+    if isWin32Windows():
+        script_extension = ".bat"
+
+        script_prelude = """\
+cd "%~dp0"
+                    """
+    else:
+        script_extension = ".sh"
+
+        script_prelude = """\
+#!/bin/bash
+cd "${0%/*}"
+"""
+
+    putTextFileContents(
+        filename=os.path.join(
+            source_dir,
+            changeFilenameExtension(scons_debug_python_name, script_extension),
+        ),
+        contents="""\
+%(script_prelude)s
+
+'%(scons_python)s' '%(scons_debug_script_name)s'
+"""
+        % {
+            "script_prelude": script_prelude,
+            "scons_python": scons_command[0],
+            "scons_debug_script_name": scons_debug_python_name,
+        },
+        encoding="utf8",
+    )
+
+
 def runScons(options, env_values, scons_filename):
     with _setupSconsEnvironment():
         env_values["_NUITKA_BUILD_DEFINITIONS_CATALOG"] = ",".join(env_values.keys())
@@ -287,6 +364,12 @@ def runScons(options, env_values, scons_filename):
         Tracing.flushStandardOutputs()
 
         with withEnvironmentVarsOverridden(env_values):
+            # Create debug script to quickly re-run this step only.
+            if source_dir is not None:
+                _createSconsDebugScript(
+                    source_dir=source_dir, scons_command=scons_command
+                )
+
             try:
                 result = subprocess.call(scons_command, shell=False, cwd=source_dir)
             except KeyboardInterrupt:
@@ -464,12 +547,8 @@ def setCommonSconsOptions(options):
 
     if product_version is None:
         product_version = file_version
-    if product_version is not None:
-        product_version = ".".join(str(d) for d in product_version)
     if file_version is None:
         file_version = product_version
-    else:
-        file_version = ".".join(str(d) for d in file_version)
 
     if product_version != file_version:
         effective_version = "%s-%s" % (

nuitka/build/SconsProgress.py

@@ -7,7 +7,6 @@ This does only the interfacing with tracing and collection of information.
 
 """
 
-
 from nuitka.Progress import (
     closeProgressBar,
     enableProgressBar,

nuitka/build/SconsUtils.py

@@ -205,9 +205,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"]
@@ -537,7 +537,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):

nuitka/build/include/nuitka/allocator.h

@@ -13,7 +13,7 @@
 #define _PyObject_GC_IS_TRACKED(obj) (1)
 #endif
 
-#if PYTHON_VERSION >= 0x380
+#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);
@@ -80,11 +80,16 @@ 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
-    Py_SET_REFCNT(op, 1);
+    op->ob_refcnt = 1;
 }
 #else
 #define Nuitka_Py_NewReference(op) _Py_NewReference(op)

nuitka/build/include/nuitka/compiled_cell.h

@@ -38,6 +38,14 @@ extern int count_allocated_Nuitka_Cell_Type;
 extern int count_released_Nuitka_Cell_Type;
 #endif
 
+NUITKA_MAY_BE_UNUSED static inline void Nuitka_Cell_SET(struct Nuitka_CellObject *cell_object, PyObject *value) {
+    CHECK_OBJECT_X(value);
+    CHECK_OBJECT(cell_object);
+
+    assert(Nuitka_Cell_Check((PyObject *)cell_object));
+    cell_object->ob_ref = value;
+}
+
 #endif
 
 //     Part of "Nuitka", an optimizing Python compiler that is compatible and