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

nuitka/build/SconsCompilerSettings.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
+
+
 """ This contains the tuning of the compilers towards defined goals.
 
 """
@@ -48,15 +34,16 @@ from .SconsUtils import (
     getMsvcVersionString,
     isClangName,
     isGccName,
+    isZigName,
     raiseNoCompilerFoundErrorExit,
     setEnvironmentVariable,
 )
 
-# spell-checker: ignore CPPDEFINES,CPPPATH,CXXVERSION,CCFLAGS,LINKFLAGS,CXXFLAGS
+# spell-checker: ignore LIBPATH,CPPDEFINES,CPPPATH,CXXVERSION,CCFLAGS,LINKFLAGS,CXXFLAGS
 # spell-checker: ignore -flto,-fpartial-inlining,-freorder-functions,-defsym,-fprofile
 # spell-checker: ignore -fwrapv,-Wunused,fcompare,-ftrack,-fvisibility,-municode,
 # spell-checker: ignore -feliminate,noexecstack,implib
-# spell-checker: ignore LTCG,GENPROFILE,USEPROFILE,
+# spell-checker: ignore LTCG,GENPROFILE,USEPROFILE,CGTHREADS
 
 
 def _detectWindowsSDK(env):
@@ -113,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:
@@ -120,13 +111,13 @@ def _enableC11Settings(env):
 
     if c11_mode:
         if env.gcc_mode:
-            env.Append(CCFLAGS=["-std=c11"])
+            env.Append(CFLAGS=["-std=c11"])
         elif env.msvc_mode:
-            env.Append(CCFLAGS=["/std:c11"])
+            env.Append(CFLAGS=["/std:c11"])
 
     if env.msvc_mode and c11_mode:
         # Windows SDK shows this even in non-debug mode in C11 mode.
-        env.Append(CCFLAGS=["/wd5105"])
+        env.Append(CCFLAGS=["/wd5105", "/wd4391"])
 
     if not c11_mode:
         env.Append(CPPDEFINES=["_NUITKA_NON_C11_MODE"])
@@ -161,6 +152,12 @@ def _enableLtoSettings(
     elif env.nuitka_python:
         lto_mode = True
         reason = "known to be supported (Nuitka-Python)"
+    elif env.fedora_python:
+        lto_mode = True
+        reason = "known to be supported (Fedora Python)"
+    elif env.arch_python:
+        lto_mode = True
+        reason = "known to be supported (Arch Python)"
     elif (
         env.debian_python
         and env.gcc_mode
@@ -173,8 +170,12 @@ def _enableLtoSettings(
         lto_mode = False
         reason = "known to be not supported (CondaCC)"
     elif isMacOS() and env.gcc_mode and env.clang_mode:
-        lto_mode = True
-        reason = "known to be supported (macOS clang)"
+        if env.debugger_mode:
+            lto_mode = False
+            reason = "must be disabled to see line numbers (macOS clang)"
+        else:
+            lto_mode = True
+            reason = "known to be supported (macOS clang)"
     elif env.mingw_mode and env.clang_mode:
         lto_mode = False
         reason = "known to not be supported (new MinGW64 Clang)"
@@ -191,6 +192,7 @@ def _enableLtoSettings(
         orig_lto_mode == "auto"
         and lto_mode
         and env.module_count > module_count_threshold
+        and not env.nuitka_python
     ):
         lto_mode = False
         reason = "might to be too slow %s (>= %d threshold), force with --lto=yes" % (
@@ -210,26 +212,31 @@ version for lto mode (>= 4.6). Disabled."""
         reason = "gcc 4.6 is doesn't have good enough LTO support"
 
     if env.gcc_mode and lto_mode:
-        env.Append(CCFLAGS=["-flto"])
-
         if env.clang_mode:
+            env.Append(CCFLAGS=["-flto"])
             env.Append(LINKFLAGS=["-flto"])
         else:
+            env.Append(CCFLAGS=["-flto=%d" % job_count])
+            env.Append(LINKFLAGS=["-flto=%d" % job_count])
+
             env.Append(CCFLAGS=["-fuse-linker-plugin", "-fno-fat-lto-objects"])
             env.Append(LINKFLAGS=["-fuse-linker-plugin"])
 
-            env.Append(LINKFLAGS=["-flto=%d" % job_count])
-
             # Need to tell the linker these things are OK.
             env.Append(LINKFLAGS=["-fpartial-inlining", "-freorder-functions"])
 
+            if env.mingw_mode and "MAKE" not in os.environ:
+                setEnvironmentVariable(env, "MAKE", "mingw32-make.exe")
+
     # Tell compiler to use link time optimization for MSVC
     if env.msvc_mode and lto_mode:
         env.Append(CCFLAGS=["/GL"])
 
         if not env.clangcl_mode:
             env.Append(LINKFLAGS=["/LTCG"])
-            env.Append(LINKFLAGS=["/CGTHREADS:%d" % job_count])
+
+            if getMsvcVersion(env) >= (14, 3):
+                env.Append(LINKFLAGS=["/CGTHREADS:%d" % job_count])
 
     if orig_lto_mode == "auto":
         scons_details_logger.info(
@@ -251,7 +258,7 @@ def checkWindowsCompilerFound(
     env, target_arch, clang_mode, msvc_version, assume_yes_for_downloads
 ):
     """Remove compiler of wrong arch or too old gcc and replace with downloaded winlibs gcc."""
-    # Many cases to deal with, pylint: disable=too-many-branches
+    # Many cases to deal with, pylint: disable=too-many-branches,too-many-statements
 
     if os.name == "nt":
         # On Windows, in case MSVC was not found and not previously forced, use the
@@ -259,7 +266,8 @@ def checkWindowsCompilerFound(
         compiler_path = getExecutablePath(env["CC"], env=env)
 
         scons_details_logger.info(
-            "Checking usability of '%s' from '%s'." % (compiler_path, env["CC"])
+            "Checking usability of binary '%s' from environment '%s'."
+            % (compiler_path, env["CC"])
         )
 
         # On MSYS2, cannot use the POSIX compiler, drop that even before we check arches, since that
@@ -288,6 +296,14 @@ def checkWindowsCompilerFound(
                 compiler_path = None
                 env["CC"] = None
 
+        if compiler_path is not None:
+            the_cc_name = os.path.basename(compiler_path)
+
+            if clang_mode and not isClangName(the_cc_name):
+                # This will trigger using it to use our own clang in branch below.
+                compiler_path = None
+                env["CC"] = None
+
         # Drop wrong arch compiler, most often found by scans. There might be wrong gcc or cl on the PATH.
         if compiler_path is not None:
             the_cc_name = os.path.basename(compiler_path)
@@ -361,16 +377,10 @@ For Python version %s MSVC %s or later is required, not %s which is too old."""
             the_cc_name = os.path.basename(compiler_path)
 
             if isGccName(the_cc_name):
-                gcc_version = myDetectVersion(env, compiler_path)
-
-                min_version = (11, 2)
-                if gcc_version is not None and (
-                    gcc_version < min_version
-                    or "force-winlibs-gcc" in env.experimental_flags
-                ):
+                if "force-accept-windows-gcc" not in env.experimental_flags:
                     scons_logger.info(
-                        "Too old gcc '%s' (%r < %r) ignored!"
-                        % (compiler_path, gcc_version, min_version)
+                        "Non downloaded winlibs-gcc '%s' is being ignored, Nuitka is very dependent on the precise one."
+                        % (compiler_path,)
                     )
 
                     # This also will trigger using it to use our own gcc in branch below.
@@ -379,7 +389,7 @@ For Python version %s MSVC %s or later is required, not %s which is too old."""
 
         if compiler_path is None and msvc_version is None:
             scons_details_logger.info(
-                "No usable C compiler, attempt fallback to winlibs gcc."
+                "No usable C compiler, attempt fallback to winlibs gcc or clang."
             )
 
             # This will download "gcc.exe" (and "clang.exe") when all others have been
@@ -398,6 +408,7 @@ For Python version %s MSVC %s or later is required, not %s which is too old."""
                     target_arch=target_arch,
                     experimental=env.experimental_flags,
                     no_deployment=env.no_deployment_flags,
+                    debug_modes=env.debug_modes_flags,
                 )
 
                 if clang_mode:
@@ -491,6 +502,11 @@ unsigned char const *getConstantsBlobData(void) {
         # Indicate "linker" resource mode.
         env.Append(CPPDEFINES=["_NUITKA_CONSTANTS_FROM_LINKER"])
 
+        # For MinGW the symbol name to be used is more low level.
+        constant_bin_link_name = "constant_bin_data"
+        if env.mingw_mode:
+            constant_bin_link_name = "_" + constant_bin_link_name
+
         env.Append(
             LINKFLAGS=[
                 "-Wl,-b",
@@ -503,9 +519,9 @@ unsigned char const *getConstantsBlobData(void) {
                     mingw_mode=env.mingw_mode or isPosixWindows(),
                 ),
                 "-Wl,-defsym",
-                "-Wl,%sconstant_bin_data=_binary_%s___constants_bin_start"
+                "-Wl,%s=_binary_%s___constants_bin_start"
                 % (
-                    "_" if env.mingw_mode else "",
+                    constant_bin_link_name,
                     "".join(re.sub("[^a-zA-Z0-9_]", "_", c) for c in env.source_dir),
                 ),
             ]
@@ -573,7 +589,7 @@ def enableWindowsStackSize(env, target_arch):
         env.Append(LINKFLAGS=["-Wl,--stack,%d" % stack_size])
 
 
-def setupCCompiler(env, lto_mode, pgo_mode, job_count):
+def setupCCompiler(env, lto_mode, pgo_mode, job_count, onefile_compile):
     # This is driven by many branches on purpose and has a lot of things
     # to deal with for LTO checks and flags, pylint: disable=too-many-branches,too-many-statements
 
@@ -615,6 +631,9 @@ def setupCCompiler(env, lto_mode, pgo_mode, job_count):
             # compilation more memory hungry, but also faster.
             env.Append(CCFLAGS="-pipe")
 
+        # gcc compiler cf_protection option
+        if env.cf_protection != "auto":
+            env.Append(CCFLAGS=["-fcf-protection=%s" % env.cf_protection])
     # Support for clang.
     if "clang" in env.the_cc_name:
         env.Append(CCFLAGS=["-w"])
@@ -623,14 +642,14 @@ def setupCCompiler(env, lto_mode, pgo_mode, job_count):
         # Don't export anything by default, this should create smaller executables.
         env.Append(CCFLAGS=["-fvisibility=hidden", "-fvisibility-inlines-hidden"])
 
-        if env.debug_mode:
+        if env.debug_mode and "allow-c-warnings" not in env.experimental_flags:
             env.Append(CCFLAGS=["-Wunused-but-set-variable"])
 
     # Support for macOS standalone to run on older OS versions.
     if isMacOS():
         setEnvironmentVariable(env, "MACOSX_DEPLOYMENT_TARGET", env.macos_min_version)
 
-        target_flag = "--target=%s-apple-macos%s" % (
+        target_flag = "--target=%s-macos%s" % (
             env.macos_target_arch,
             env.macos_min_version,
         )
@@ -712,9 +731,13 @@ def setupCCompiler(env, lto_mode, pgo_mode, job_count):
             # 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"
+                    )
                 ]
             )
 
@@ -731,9 +754,13 @@ def setupCCompiler(env, lto_mode, pgo_mode, job_count):
         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:
@@ -758,19 +785,29 @@ def setupCCompiler(env, lto_mode, pgo_mode, job_count):
         if not env.clang_mode:
             env.Append(LINKFLAGS=["-Wl,--enable-auto-import"])
 
-        if env.disable_console:
+    # Even if console is forced, for Win32 it means to specify Windows
+    # subsystem, we can still attach or create.
+    if env.console_mode in ("attach", "disable"):
+        if env.mingw_mode:
             env.Append(LINKFLAGS=["-Wl,--subsystem,windows"])
-
-    if env.mingw_mode or env.msvc_mode:
-        if env.disable_console:
             env.Append(CPPDEFINES=["_NUITKA_WINMAIN_ENTRY_POINT"])
+        elif env.msvc_mode:
+            env.Append(LINKFLAGS=["/SUBSYSTEM:windows"])
+            env.Append(CPPDEFINES=["_NUITKA_WINMAIN_ENTRY_POINT"])
+
+    if env.console_mode == "attach" and os.name == "nt":
+        env.Append(CPPDEFINES=["_NUITKA_ATTACH_CONSOLE_WINDOW"])
+
+    if env.console_mode == "hide" and os.name == "nt":
+        env.Append(CPPDEFINES=["_NUITKA_HIDE_CONSOLE_WINDOW"])
+        env.Append(LIBS=["User32"])
 
-    # Avoid dependency on MinGW libraries.
+    # Avoid dependency on MinGW libraries, spell-checker: ignore libgcc
     if env.mingw_mode and not env.clang_mode:
         env.Append(LINKFLAGS=["-static-libgcc"])
 
     # MinGW64 for 64 bits needs this due to CPython bugs.
-    if env.mingw_mode and env.target_arch == "x86_64":
+    if env.mingw_mode and env.target_arch == "x86_64" and env.python_version < (3, 12):
         env.Append(CPPDEFINES=["MS_WIN64"])
 
     # For shell API usage to lookup app folders we need this. Note that on Windows ARM
@@ -783,6 +820,24 @@ def setupCCompiler(env, lto_mode, pgo_mode, job_count):
     if isFedoraBasedLinux():
         env.Append(CCFLAGS=["-fPIC"])
 
+    # We use zlib for crc32 functionality
+    zlib_inline_copy_dir = os.path.join(env.nuitka_src, "inline_copy", "zlib")
+    if os.path.exists(os.path.join(zlib_inline_copy_dir, "crc32.c")):
+        env.Append(
+            CPPPATH=[
+                zlib_inline_copy_dir,
+            ],
+        )
+    else:
+        # TODO: Should only happen for official Debian packages, and there we
+        # can use the zlib static linking maybe, but for onefile it's not easy
+        # to get it, so just use slow checksum for now.
+        if onefile_compile:
+            env.Append(CPPDEFINES=["_NUITKA_USE_OWN_CRC32"])
+        else:
+            env.Append(CPPDEFINES=["_NUITKA_USE_SYSTEM_CRC32"])
+            env.Append(LIBS="z")
+
 
 def _enablePgoSettings(env, pgo_mode):
     if pgo_mode == "no":
@@ -907,20 +962,29 @@ version (>= 5.3)."""
         )
 
     if env.gcc_version < (5,):
-        scons_logger.info("The provided gcc is too old, switching to its g++ instead.")
+        if env.python_version < (3, 11):
+            scons_logger.info(
+                "The provided gcc is too old, switching to its g++ instead.",
+                mnemonic="too-old-gcc",
+            )
 
-        # Switch to g++ from gcc then if possible, when C11 mode is false.
-        the_gpp_compiler = os.path.join(
-            os.path.dirname(env.the_compiler),
-            os.path.basename(env.the_compiler).replace("gcc", "g++"),
-        )
+            # Switch to g++ from gcc then if possible, when C11 mode is false.
+            the_gpp_compiler = os.path.join(
+                os.path.dirname(env.the_compiler),
+                os.path.basename(env.the_compiler).replace("gcc", "g++"),
+            )
 
-        if getExecutablePath(the_gpp_compiler, env=env):
-            env.the_compiler = the_gpp_compiler
-            env.the_cc_name = env.the_cc_name.replace("gcc", "g++")
+            if getExecutablePath(the_gpp_compiler, env=env):
+                env.the_compiler = the_gpp_compiler
+                env.the_cc_name = env.the_cc_name.replace("gcc", "g++")
+            else:
+                scons_logger.sysexit(
+                    "Error, your gcc is too old for C11 support, and no related g++ to workaround that is found."
+                )
         else:
             scons_logger.sysexit(
-                "Error, your gcc is too old for C11 support, and no related g++ to workaround that is found."
+                "Error, your gcc is too old for C11 support, install a newer one.",
+                mnemonic="too-old-gcc",
             )
 
 
@@ -929,6 +993,25 @@ def reportCCompiler(env, context, output_func):
 
     if env.the_cc_name == "cl":
         cc_output = "%s %s" % (env.the_cc_name, getMsvcVersionString(env))
+    elif isGccName(env.the_cc_name):
+        if env.gcc_version is None:
+            env.gcc_version = myDetectVersion(env, env.the_compiler)
+
+        cc_output = "%s %s" % (
+            env.the_cc_name,
+            ".".join(str(d) for d in env.gcc_version),
+        )
+    elif isClangName(env.the_cc_name):
+        clang_version = myDetectVersion(env, env.the_cc_name)
+        if clang_version is None:
+            clang_version = "not found"
+        else:
+            clang_version = ".".join(str(d) for d in clang_version)
+
+        cc_output = "%s %s" % (
+            env.the_cc_name,
+            clang_version,
+        )
     else:
         cc_output = env.the_cc_name
 
@@ -966,3 +1049,19 @@ def importEnvironmentVariableSettings(env):
             "Scons: Inherited LDFLAGS='%s' variable." % os.environ["LDFLAGS"]
         )
         env.Append(LINKFLAGS=os.environ["LDFLAGS"].split())
+
+
+#     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/SconsHacks.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
+
+
 """ Hacks for scons that we apply.
 
 We block some tools from the standard scan, there is e.g. no need to ask
@@ -26,7 +12,6 @@ version.
 
 """
 
-
 import os
 import re
 
@@ -93,6 +78,7 @@ def _myDetectVersion(cc):
         command = (
             cc,
             "-dumpversion",
+            "-dumpfullversion",
         )
     else:
         command = (
@@ -156,7 +142,11 @@ def myDetect(self, progs):
             return None
 
     # Note: Actually, with our inline copy, this is maybe not supposed to
-    # happen at all
+    # happen a lot at all. It's a bit hard to pass debug flag to here, or
+    # else we could assert it.
+    # for p in progs:
+    #     if p not in ("x86_64-conda-linux-gnu-gcc", "gcc", "cc", "g++"):
+    #         assert False, p
 
     return orig_detect(self, progs)
 
@@ -207,3 +197,19 @@ def makeGccUseLinkerFile(source_files, module_mode, env):
             tmpfile.write('"%s"\n' % filename)
 
         tmpfile.write(env.subst("$SOURCES"))
+
+
+#     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.