Added platform detection code from pandemonium.

compat.py

@@ -0,0 +1,97 @@
+import sys
+
+if sys.version_info < (3,):
+
+    def isbasestring(s):
+        return isinstance(s, basestring)
+
+    def open_utf8(filename, mode):
+        return open(filename, mode)
+
+    def byte_to_str(x):
+        return str(ord(x))
+
+    import cStringIO
+
+    def StringIO():
+        return cStringIO.StringIO()
+
+    def encode_utf8(x):
+        return x
+
+    def decode_utf8(x):
+        return x
+
+    def iteritems(d):
+        return d.iteritems()
+
+    def itervalues(d):
+        return d.itervalues()
+
+    def escape_string(s):
+        if isinstance(s, unicode):
+            s = s.encode("ascii")
+        result = ""
+        for c in s:
+            if not (32 <= ord(c) < 127) or c in ("\\", '"'):
+                result += "\\%03o" % ord(c)
+            else:
+                result += c
+        return result
+
+    def qualname(obj):
+        # Not properly equivalent to __qualname__ in py3, but it doesn't matter.
+        return obj.__name__
+
+
+else:
+
+    def isbasestring(s):
+        return isinstance(s, (str, bytes))
+
+    def open_utf8(filename, mode):
+        return open(filename, mode, encoding="utf-8")
+
+    def byte_to_str(x):
+        return str(x)
+
+    import io
+
+    def StringIO():
+        return io.StringIO()
+
+    import codecs
+
+    def encode_utf8(x):
+        return codecs.utf_8_encode(x)[0]
+
+    def decode_utf8(x):
+        return codecs.utf_8_decode(x)[0]
+
+    def iteritems(d):
+        return iter(d.items())
+
+    def itervalues(d):
+        return iter(d.values())
+
+    def charcode_to_c_escapes(c):
+        rev_result = []
+        while c >= 256:
+            c, low = (c // 256, c % 256)
+            rev_result.append("\\%03o" % low)
+        rev_result.append("\\%03o" % c)
+        return "".join(reversed(rev_result))
+
+    def escape_string(s):
+        result = ""
+        if isinstance(s, str):
+            s = s.encode("utf-8")
+        for c in s:
+            if not (32 <= c < 127) or c in (ord("\\"), ord('"')):
+                result += charcode_to_c_escapes(c)
+            else:
+                result += chr(c)
+        return result
+
+    def qualname(obj):
+        return obj.__qualname__

platform/SCsub

@@ -0,0 +1,12 @@
+#!/usr/bin/env python
+
+from compat import open_utf8
+
+Import("env")
+
+env.platform_sources = []
+
+env.add_source_files(env.platform_sources, "sfwl.cpp")
+
+lib = env.add_library("platform", env.platform_sources)
+env.Prepend(LIBS=[lib])

platform/osx/detect.py

@@ -0,0 +1,220 @@
+import os
+import sys
+from methods import detect_darwin_sdk_path, get_compiler_version, is_vanilla_clang
+
+
+def is_active():
+    return True
+
+
+def get_name():
+    return "OSX"
+
+
+def can_build():
+    if sys.platform == "darwin" or ("OSXCROSS_ROOT" in os.environ):
+        return True
+
+    return False
+
+
+def get_opts():
+    from SCons.Variables import BoolVariable, EnumVariable
+
+    return [
+        ("osxcross_sdk", "OSXCross SDK version", "darwin14"),
+        ("MACOS_SDK_PATH", "Path to the macOS SDK", ""),
+        EnumVariable("macports_clang", "Build using Clang from MacPorts", "no", ("no", "5.0", "devel")),
+        BoolVariable("debug_symbols", "Add debugging symbols to release/release_debug builds", True),
+        BoolVariable("separate_debug_symbols", "Create a separate file containing debugging symbols", False),
+        BoolVariable("use_ubsan", "Use LLVM/GCC compiler undefined behavior sanitizer (UBSAN)", False),
+        BoolVariable("use_asan", "Use LLVM/GCC compiler address sanitizer (ASAN))", False),
+        BoolVariable("use_lsan", "Use LLVM/GCC compiler leak sanitizer (LSAN))", False),
+        BoolVariable("use_tsan", "Use LLVM/GCC compiler thread sanitizer (TSAN))", False),
+    ]
+
+
+def get_flags():
+    return []
+
+
+def configure(env):
+    ## Build type
+
+    if env["target"] == "release":
+        if env["optimize"] == "speed":  # optimize for speed (default)
+            env.Prepend(CCFLAGS=["-O3"])
+        elif env["optimize"] == "size":  # optimize for size
+            env.Prepend(CCFLAGS=["-Os"])
+        if env["arch"] != "arm64":
+            env.Prepend(CCFLAGS=["-msse2"])
+
+        if env["debug_symbols"]:
+            env.Prepend(CCFLAGS=["-g2"])
+
+    elif env["target"] == "release_debug":
+        if env["optimize"] == "speed":  # optimize for speed (default)
+            env.Prepend(CCFLAGS=["-O2"])
+        elif env["optimize"] == "size":  # optimize for size
+            env.Prepend(CCFLAGS=["-Os"])
+
+        if env["debug_symbols"]:
+            env.Prepend(CCFLAGS=["-g2"])
+
+    elif env["target"] == "debug":
+        env.Prepend(CCFLAGS=["-g3"])
+        env.Prepend(LINKFLAGS=["-Xlinker", "-no_deduplicate"])
+
+    ## Architecture
+
+    # Mac OS X no longer runs on 32-bit since 10.7 which is unsupported since 2014
+    # As such, we only support 64-bit
+    env["bits"] = "64"
+
+    ## Compiler configuration
+
+    # Save this in environment for use by other modules
+    if "OSXCROSS_ROOT" in os.environ:
+        env["osxcross"] = True
+
+    if env["arch"] == "arm64":
+        print("Building for macOS 11.0+, platform arm64.")
+        env.Append(ASFLAGS=["-arch", "arm64", "-mmacosx-version-min=11.0"])
+        env.Append(CCFLAGS=["-arch", "arm64", "-mmacosx-version-min=11.0"])
+        env.Append(LINKFLAGS=["-arch", "arm64", "-mmacosx-version-min=11.0"])
+    else:
+        print("Building for macOS 10.12+, platform x86-64.")
+        env.Append(ASFLAGS=["-arch", "x86_64", "-mmacosx-version-min=10.12"])
+        env.Append(CCFLAGS=["-arch", "x86_64", "-mmacosx-version-min=10.12"])
+        env.Append(LINKFLAGS=["-arch", "x86_64", "-mmacosx-version-min=10.12"])
+
+    cc_version = get_compiler_version(env) or [-1, -1]
+    vanilla = is_vanilla_clang(env)
+
+    # Workaround for Xcode 15 linker bug.
+    if not vanilla and cc_version[0] == 15 and cc_version[1] == 0:
+        env.Prepend(LINKFLAGS=["-ld_classic"])
+
+    if not "osxcross" in env:  # regular native build
+        if env["macports_clang"] != "no":
+            mpprefix = os.environ.get("MACPORTS_PREFIX", "/opt/local")
+            mpclangver = env["macports_clang"]
+            env["CC"] = mpprefix + "/libexec/llvm-" + mpclangver + "/bin/clang"
+            env["CXX"] = mpprefix + "/libexec/llvm-" + mpclangver + "/bin/clang++"
+            env["AR"] = mpprefix + "/libexec/llvm-" + mpclangver + "/bin/llvm-ar"
+            env["RANLIB"] = mpprefix + "/libexec/llvm-" + mpclangver + "/bin/llvm-ranlib"
+            env["AS"] = mpprefix + "/libexec/llvm-" + mpclangver + "/bin/llvm-as"
+            env.Append(CPPDEFINES=["__MACPORTS__"])  # hack to fix libvpx MM256_BROADCASTSI128_SI256 define
+        else:
+            env["CC"] = "clang"
+            env["CXX"] = "clang++"
+
+        detect_darwin_sdk_path("osx", env)
+        env.Append(CCFLAGS=["-isysroot", "$MACOS_SDK_PATH"])
+        env.Append(LINKFLAGS=["-isysroot", "$MACOS_SDK_PATH"])
+
+    else:  # osxcross build
+        root = os.environ.get("OSXCROSS_ROOT", 0)
+        if env["arch"] == "arm64":
+            basecmd = root + "/target/bin/arm64-apple-" + env["osxcross_sdk"] + "-"
+        else:
+            basecmd = root + "/target/bin/x86_64-apple-" + env["osxcross_sdk"] + "-"
+
+        ccache_path = os.environ.get("CCACHE")
+        if ccache_path is None:
+            env["CC"] = basecmd + "cc"
+            env["CXX"] = basecmd + "c++"
+        else:
+            # there aren't any ccache wrappers available for OS X cross-compile,
+            # to enable caching we need to prepend the path to the ccache binary
+            env["CC"] = ccache_path + " " + basecmd + "cc"
+            env["CXX"] = ccache_path + " " + basecmd + "c++"
+        env["AR"] = basecmd + "ar"
+        env["RANLIB"] = basecmd + "ranlib"
+        env["AS"] = basecmd + "as"
+        env.Append(CPPDEFINES=["__MACPORTS__"])  # hack to fix libvpx MM256_BROADCASTSI128_SI256 define
+
+    # LTO
+
+    if env["lto"] == "auto":  # LTO benefits for macOS (size, performance) haven't been clearly established yet.
+        env["lto"] = "none"
+
+    if env["lto"] != "none":
+        if env["lto"] == "thin":
+            env.Append(CCFLAGS=["-flto=thin"])
+            env.Append(LINKFLAGS=["-flto=thin"])
+        else:
+            env.Append(CCFLAGS=["-flto"])
+            env.Append(LINKFLAGS=["-flto"])
+
+    # Sanitizers
+
+    if env["use_ubsan"] or env["use_asan"] or env["use_lsan"] or env["use_tsan"]:
+        env.extra_suffix += "s"
+
+        if env["use_ubsan"]:
+            env.Append(CCFLAGS=["-fsanitize=undefined"])
+            env.Append(LINKFLAGS=["-fsanitize=undefined"])
+
+        if env["use_asan"]:
+            env.Append(CCFLAGS=["-fsanitize=address"])
+            env.Append(LINKFLAGS=["-fsanitize=address"])
+
+        if env["use_lsan"]:
+            env.Append(CCFLAGS=["-fsanitize=leak"])
+            env.Append(LINKFLAGS=["-fsanitize=leak"])
+
+        if env["use_tsan"]:
+            env.Append(CCFLAGS=["-fsanitize=thread"])
+            env.Append(LINKFLAGS=["-fsanitize=thread"])
+
+    ## Dependencies
+
+    if env["builtin_libtheora"]:
+        if env["arch"] != "arm64":
+            env["x86_libtheora_opt_gcc"] = True
+
+    ## Flags
+
+    env.Prepend(CPPPATH=["#platform/osx"])
+    env.Append(
+        CPPDEFINES=[
+            "OSX_ENABLED",
+            "UNIX_ENABLED",
+            "GLES_ENABLED",
+            "APPLE_STYLE_KEYS",
+            "COREAUDIO_ENABLED",
+            "COREMIDI_ENABLED",
+            "GL_SILENCE_DEPRECATION",
+        ]
+    )
+    env.Append(
+        LINKFLAGS=[
+            "-framework",
+            "Cocoa",
+            "-framework",
+            "Carbon",
+            "-framework",
+            "OpenGL",
+            "-framework",
+            "AGL",
+            "-framework",
+            "AudioUnit",
+            "-framework",
+            "CoreAudio",
+            "-framework",
+            "CoreMIDI",
+            "-lz",
+            "-framework",
+            "IOKit",
+            "-framework",
+            "ForceFeedback",
+            "-framework",
+            "AVFoundation",
+            "-framework",
+            "CoreMedia",
+            "-framework",
+            "CoreVideo",
+        ]
+    )
+    env.Append(LIBS=["pthread"])

platform/windows/detect.py

@@ -0,0 +1,492 @@
+import methods
+import os
+
+# To match other platforms
+STACK_SIZE = 8388608
+
+
+def is_active():
+    return True
+
+
+def get_name():
+    return "Windows"
+
+
+def can_build():
+    if os.name == "nt":
+        # Building natively on Windows
+        # If VCINSTALLDIR is set in the OS environ, use traditional Pandemonium logic to set up MSVC
+        if os.getenv("VCINSTALLDIR"):  # MSVC, manual setup
+            return True
+
+        # Otherwise, let SCons find MSVC if installed, or else Mingw.
+        # Since we're just returning True here, if there's no compiler
+        # installed, we'll get errors when it tries to build with the
+        # null compiler.
+        return True
+
+    if os.name == "posix":
+        # Cross-compiling with MinGW-w64 (old MinGW32 is not supported)
+        mingw32 = "i686-w64-mingw32-"
+        mingw64 = "x86_64-w64-mingw32-"
+
+        if os.getenv("MINGW32_PREFIX"):
+            mingw32 = os.getenv("MINGW32_PREFIX")
+        if os.getenv("MINGW64_PREFIX"):
+            mingw64 = os.getenv("MINGW64_PREFIX")
+
+        test = "gcc --version > /dev/null 2>&1"
+        if os.system(mingw64 + test) == 0 or os.system(mingw32 + test) == 0:
+            return True
+
+    return False
+
+
+def get_opts():
+    from SCons.Variables import BoolVariable, EnumVariable
+
+    mingw32 = ""
+    mingw64 = ""
+    if os.name == "posix":
+        mingw32 = "i686-w64-mingw32-"
+        mingw64 = "x86_64-w64-mingw32-"
+
+    if os.getenv("MINGW32_PREFIX"):
+        mingw32 = os.getenv("MINGW32_PREFIX")
+    if os.getenv("MINGW64_PREFIX"):
+        mingw64 = os.getenv("MINGW64_PREFIX")
+
+    return [
+        ("mingw_prefix_32", "MinGW prefix (Win32)", mingw32),
+        ("mingw_prefix_64", "MinGW prefix (Win64)", mingw64),
+        # Targeted Windows version: 7 (and later), minimum supported version
+        # XP support dropped after EOL due to missing API for IPv6 and other issues
+        # Vista support dropped after EOL due to GH-10243
+        ("target_win_version", "Targeted Windows version, >= 0x0601 (Windows 7)", "0x0601"),
+        BoolVariable("debug_symbols", "Add debugging symbols to release/release_debug builds", True),
+        EnumVariable("windows_subsystem", "Windows subsystem", "gui", ("gui", "console")),
+        BoolVariable("separate_debug_symbols", "Create a separate file containing debugging symbols", False),
+        ("msvc_version", "MSVC version to use. Ignored if VCINSTALLDIR is set in shell env.", None),
+        BoolVariable("use_mingw", "Use the Mingw compiler, even if MSVC is installed.", False),
+        BoolVariable("use_llvm", "Use the LLVM compiler", False),
+        BoolVariable("use_static_cpp", "Link MinGW/MSVC C++ runtime libraries statically", True),
+        BoolVariable("use_asan", "Use address sanitizer (ASAN)", False),
+        BoolVariable("incremental_link", "Use MSVC incremental linking. May increase or decrease build times.", False),
+    ]
+
+
+def get_flags():
+    return []
+
+
+def build_res_file(target, source, env):
+    if env["bits"] == "32":
+        cmdbase = env["mingw_prefix_32"]
+    else:
+        cmdbase = env["mingw_prefix_64"]
+    cmdbase = cmdbase + "windres --include-dir . "
+    import subprocess
+
+    for x in range(len(source)):
+        cmd = cmdbase + "-i " + str(source[x]) + " -o " + str(target[x])
+        try:
+            out = subprocess.Popen(cmd, shell=True, stderr=subprocess.PIPE).communicate()
+            if len(out[1]):
+                return 1
+        except Exception:
+            return 1
+    return 0
+
+
+def setup_msvc_manual(env):
+    """Set up env to use MSVC manually, using VCINSTALLDIR"""
+    if env["bits"] != "default":
+        print(
+            """
+            Bits argument is not supported for MSVC compilation. Architecture depends on the Native/Cross Compile Tools Prompt/Developer Console
+            (or Visual Studio settings) that is being used to run SCons. As a consequence, bits argument is disabled. Run scons again without bits
+            argument (example: scons p=windows) and SCons will attempt to detect what MSVC compiler will be executed and inform you.
+            """
+        )
+        raise SCons.Errors.UserError("Bits argument should not be used when using VCINSTALLDIR")
+
+    # Force bits arg
+    # (Actually msys2 mingw can support 64-bit, we could detect that)
+    env["bits"] = "32"
+    env["x86_libtheora_opt_vc"] = True
+
+    # find compiler manually
+    compiler_version_str = methods.detect_visual_c_compiler_version(env["ENV"])
+    print("Found MSVC compiler: " + compiler_version_str)
+
+    # If building for 64bit architecture, disable assembly optimisations for 32 bit builds (theora as of writing)... vc compiler for 64bit can not compile _asm
+    if compiler_version_str == "amd64" or compiler_version_str == "x86_amd64":
+        env["bits"] = "64"
+        env["x86_libtheora_opt_vc"] = False
+        print("Compiled program architecture will be a 64 bit executable (forcing bits=64).")
+    elif compiler_version_str == "x86" or compiler_version_str == "amd64_x86":
+        print("Compiled program architecture will be a 32 bit executable. (forcing bits=32).")
+    else:
+        print(
+            "Failed to manually detect MSVC compiler architecture version... Defaulting to 32bit executable settings (forcing bits=32). Compilation attempt will continue, but SCons can not detect for what architecture this build is compiled for. You should check your settings/compilation setup, or avoid setting VCINSTALLDIR."
+        )
+
+
+def setup_msvc_auto(env):
+    """Set up MSVC using SCons's auto-detection logic"""
+
+    # If MSVC_VERSION is set by SCons, we know MSVC is installed.
+    # But we may want a different version or target arch.
+
+    # The env may have already been set up with default MSVC tools, so
+    # reset a few things so we can set it up with the tools we want.
+    # (Ideally we'd decide on the tool config before configuring any
+    # environment, and just set the env up once, but this function runs
+    # on an existing env so this is the simplest way.)
+    env["MSVC_SETUP_RUN"] = False  # Need to set this to re-run the tool
+    env["MSVS_VERSION"] = None
+    env["MSVC_VERSION"] = None
+    env["TARGET_ARCH"] = None
+    if env["bits"] != "default":
+        env["TARGET_ARCH"] = {"32": "x86", "64": "x86_64"}[env["bits"]]
+    if "msvc_version" in env:
+        env["MSVC_VERSION"] = env["msvc_version"]
+    env.Tool("msvc")
+    env.Tool("mssdk")  # we want the MS SDK
+    # Note: actual compiler version can be found in env['MSVC_VERSION'], e.g. "14.1" for VS2015
+    # Get actual target arch into bits (it may be "default" at this point):
+    if env["TARGET_ARCH"] in ("amd64", "x86_64"):
+        env["bits"] = "64"
+    else:
+        env["bits"] = "32"
+    print("Found MSVC version %s, arch %s, bits=%s" % (env["MSVC_VERSION"], env["TARGET_ARCH"], env["bits"]))
+    if env["TARGET_ARCH"] in ("amd64", "x86_64"):
+        env["x86_libtheora_opt_vc"] = False
+
+
+def setup_mingw(env):
+    """Set up env for use with mingw"""
+    # Nothing to do here
+    print("Using MinGW")
+
+
+def configure_msvc(env, manual_msvc_config):
+    """Configure env to work with MSVC"""
+
+    # Build type
+
+    if env["target"] == "release":
+        if env["optimize"] == "speed":  # optimize for speed (default)
+            env.Append(CCFLAGS=["/O2"])
+            env.Append(LINKFLAGS=["/OPT:REF"])
+        elif env["optimize"] == "size":  # optimize for size
+            env.Append(CCFLAGS=["/O1"])
+            env.Append(LINKFLAGS=["/OPT:REF"])
+
+    elif env["target"] == "release_debug":
+        if env["optimize"] == "speed":  # optimize for speed (default)
+            env.Append(CCFLAGS=["/O2"])
+            env.Append(LINKFLAGS=["/OPT:REF"])
+        elif env["optimize"] == "size":  # optimize for size
+            env.Append(CCFLAGS=["/O1"])
+            env.Append(LINKFLAGS=["/OPT:REF"])
+
+    elif env["target"] == "debug":
+        env.AppendUnique(CCFLAGS=["/Zi", "/FS", "/Od"])
+        env.Append(LINKFLAGS=["/DEBUG"])
+
+    if env["windows_subsystem"] == "gui":
+        env.Append(LINKFLAGS=["/SUBSYSTEM:WINDOWS"])
+    else:
+        env.Append(LINKFLAGS=["/SUBSYSTEM:CONSOLE"])
+        env.AppendUnique(CPPDEFINES=["WINDOWS_SUBSYSTEM_CONSOLE"])
+
+    env.Append(LINKFLAGS=["/ENTRY:mainCRTStartup"])
+
+    if env["debug_symbols"]:
+        env.AppendUnique(CCFLAGS=["/Zi", "/FS"])
+        env.AppendUnique(LINKFLAGS=["/DEBUG"])
+
+    ## Compile/link flags
+
+    if env["use_static_cpp"]:
+        env.AppendUnique(CCFLAGS=["/MT"])
+    else:
+        env.AppendUnique(CCFLAGS=["/MD"])
+
+    # MSVC incremental linking is broken and may _increase_ link time (GH-77968).
+    if not env["incremental_link"]:
+        env.Append(LINKFLAGS=["/INCREMENTAL:NO"])
+
+    env.AppendUnique(CCFLAGS=["/Gd", "/nologo"])
+    env.AppendUnique(CCFLAGS=["/utf-8"])  # Force to use Unicode encoding.
+    env.AppendUnique(CXXFLAGS=["/TP"])  # assume all sources are C++
+    # Once it was thought that only debug builds would be too large,
+    # but this has recently stopped being true. See the mingw function
+    # for notes on why this shouldn't be enabled for gcc
+    env.AppendUnique(CCFLAGS=["/bigobj"])
+
+    if manual_msvc_config:  # should be automatic if SCons found it
+        if os.getenv("WindowsSdkDir") is not None:
+            env.Prepend(CPPPATH=[os.getenv("WindowsSdkDir") + "/Include"])
+        else:
+            print("Missing environment variable: WindowsSdkDir")
+
+    env.AppendUnique(
+        CPPDEFINES=[
+            "WINDOWS_ENABLED",
+            "OPENGL_ENABLED",
+            "WASAPI_ENABLED",
+            "WINMIDI_ENABLED",
+            "TYPED_METHOD_BIND",
+            "WIN32",
+            "MSVC",
+            "WINVER=%s" % env["target_win_version"],
+            "_WIN32_WINNT=%s" % env["target_win_version"],
+        ]
+    )
+    env.AppendUnique(CPPDEFINES=["NOMINMAX"])  # disable bogus min/max WinDef.h macros
+    if env["bits"] == "64":
+        env.AppendUnique(CPPDEFINES=["_WIN64"])
+
+    ## Libs
+
+    LIBS = [
+        "winmm",
+        "opengl32",
+        "dsound",
+        "kernel32",
+        "ole32",
+        "oleaut32",
+        "user32",
+        "gdi32",
+        "IPHLPAPI",
+        "Shlwapi",
+        "wsock32",
+        "Ws2_32",
+        "shell32",
+        "advapi32",
+        "dinput8",
+        "dxguid",
+        "imm32",
+        "bcrypt",
+        "Avrt",
+        "dwmapi",
+    ]
+    env.Append(LINKFLAGS=[p + env["LIBSUFFIX"] for p in LIBS])
+
+    if manual_msvc_config:
+        if os.getenv("WindowsSdkDir") is not None:
+            env.Append(LIBPATH=[os.getenv("WindowsSdkDir") + "/Lib"])
+        else:
+            print("Missing environment variable: WindowsSdkDir")
+
+    ## LTO
+
+    if env["lto"] == "auto":  # No LTO by default for MSVC, doesn't help.
+        env["lto"] = "none"
+
+    if env["lto"] != "none":
+        if env["lto"] == "thin":
+            print("ThinLTO is only compatible with LLVM, use `use_llvm=yes` or `lto=full`.")
+            sys.exit(255)
+        env.AppendUnique(CCFLAGS=["/GL"])
+        env.AppendUnique(ARFLAGS=["/LTCG"])
+        if env["progress"]:
+            env.AppendUnique(LINKFLAGS=["/LTCG:STATUS"])
+        else:
+            env.AppendUnique(LINKFLAGS=["/LTCG"])
+
+    if manual_msvc_config:
+        env.Prepend(CPPPATH=[p for p in os.getenv("INCLUDE").split(";")])
+        env.Append(LIBPATH=[p for p in os.getenv("LIB").split(";")])
+
+    # Sanitizers
+    if env["use_asan"]:
+        env.extra_suffix += ".s"
+        env.Append(LINKFLAGS=["/INFERASANLIBS"])
+        env.Append(CCFLAGS=["/fsanitize=address"])
+
+    # Incremental linking fix
+    env["BUILDERS"]["ProgramOriginal"] = env["BUILDERS"]["Program"]
+    env["BUILDERS"]["Program"] = methods.precious_program
+
+    env.AppendUnique(LINKFLAGS=["/STACK:" + str(STACK_SIZE)])
+
+
+def configure_mingw(env):
+    # Workaround for MinGW. See:
+    # http://www.scons.org/wiki/LongCmdLinesOnWin32
+    env.use_windows_spawn_fix()
+
+    ## Build type
+
+    if env["target"] == "release":
+        env.Append(CCFLAGS=["-msse2"])
+
+        if env["optimize"] == "speed":  # optimize for speed (default)
+            if env["bits"] == "64":
+                env.Append(CCFLAGS=["-O3"])
+            else:
+                env.Append(CCFLAGS=["-O2"])
+        else:  # optimize for size
+            env.Prepend(CCFLAGS=["-Os"])
+        if env["debug_symbols"]:
+            env.Prepend(CCFLAGS=["-g2"])
+
+    elif env["target"] == "release_debug":
+        env.Append(CCFLAGS=["-O2"])
+        if env["debug_symbols"]:
+            env.Prepend(CCFLAGS=["-g2"])
+        if env["optimize"] == "speed":  # optimize for speed (default)
+            env.Append(CCFLAGS=["-O2"])
+        else:  # optimize for size
+            env.Prepend(CCFLAGS=["-Os"])
+
+    elif env["target"] == "debug":
+        env.Append(CCFLAGS=["-g3"])
+        # Allow big objects. It's supposed not to have drawbacks but seems to break
+        # GCC LTO, so enabling for debug builds only (which are not built with LTO
+        # and are the only ones with too big objects).
+        env.Append(CCFLAGS=["-Wa,-mbig-obj"])
+
+    if env["windows_subsystem"] == "gui":
+        env.Append(LINKFLAGS=["-Wl,--subsystem,windows"])
+    else:
+        env.Append(LINKFLAGS=["-Wl,--subsystem,console"])
+        env.AppendUnique(CPPDEFINES=["WINDOWS_SUBSYSTEM_CONSOLE"])
+
+    ## Compiler configuration
+
+    if os.name == "nt":
+        # Force splitting libmodules.a in multiple chunks to work around
+        # issues reaching the linker command line size limit, which also
+        # seem to induce huge slowdown for 'ar' (GH-30892).
+        env["split_libmodules"] = True
+    else:
+        env["PROGSUFFIX"] = env["PROGSUFFIX"] + ".exe"  # for linux cross-compilation
+
+    if env["bits"] == "default":
+        if os.name == "nt":
+            env["bits"] = "64" if "PROGRAMFILES(X86)" in os.environ else "32"
+        else:  # default to 64-bit on Linux
+            env["bits"] = "64"
+
+    mingw_prefix = ""
+
+    if env["bits"] == "32":
+        if env["use_static_cpp"]:
+            env.Append(LINKFLAGS=["-static"])
+            env.Append(LINKFLAGS=["-static-libgcc"])
+            env.Append(LINKFLAGS=["-static-libstdc++"])
+        mingw_prefix = env["mingw_prefix_32"]
+    else:
+        if env["use_static_cpp"]:
+            env.Append(LINKFLAGS=["-static"])
+        mingw_prefix = env["mingw_prefix_64"]
+
+    if env["use_llvm"]:
+        env["CC"] = mingw_prefix + "clang"
+        env["CXX"] = mingw_prefix + "clang++"
+        env["AS"] = mingw_prefix + "as"
+        env["AR"] = mingw_prefix + "ar"
+        env["RANLIB"] = mingw_prefix + "ranlib"
+    else:
+        env["CC"] = mingw_prefix + "gcc"
+        env["CXX"] = mingw_prefix + "g++"
+        env["AS"] = mingw_prefix + "as"
+        env["AR"] = mingw_prefix + "gcc-ar"
+        env["RANLIB"] = mingw_prefix + "gcc-ranlib"
+
+    env["x86_libtheora_opt_gcc"] = True
+
+    ## LTO
+
+    if env["lto"] == "auto":  # Full LTO for production with MinGW.
+        env["lto"] = "full"
+
+    if env["lto"] != "none":
+        if env["lto"] == "thin":
+            if not env["use_llvm"]:
+                print("ThinLTO is only compatible with LLVM, use `use_llvm=yes` or `lto=full`.")
+                sys.exit(255)
+            env.Append(CCFLAGS=["-flto=thin"])
+            env.Append(LINKFLAGS=["-flto=thin"])
+        elif not env["use_llvm"] and env.GetOption("num_jobs") > 1:
+            env.Append(CCFLAGS=["-flto"])
+            env.Append(LINKFLAGS=["-flto=" + str(env.GetOption("num_jobs"))])
+        else:
+            env.Append(CCFLAGS=["-flto"])
+            env.Append(LINKFLAGS=["-flto"])
+
+    env.Append(LINKFLAGS=["-Wl,--stack," + str(STACK_SIZE)])
+
+    ## Compile flags
+
+    env.Append(CCFLAGS=["-mwindows"])
+    env.Append(LINKFLAGS=["-Wl,--nxcompat"])  # DEP protection. Not enabling ASLR for now, Mono crashes.
+    env.Append(CPPDEFINES=["WINDOWS_ENABLED", "OPENGL_ENABLED", "WASAPI_ENABLED", "WINMIDI_ENABLED"])
+    env.Append(CPPDEFINES=[("WINVER", env["target_win_version"]), ("_WIN32_WINNT", env["target_win_version"])])
+    env.Append(
+        LIBS=[
+            "mingw32",
+            "opengl32",
+            "dsound",
+            "ole32",
+            "d3d9",
+            "winmm",
+            "gdi32",
+            "iphlpapi",
+            "shlwapi",
+            "wsock32",
+            "ws2_32",
+            "kernel32",
+            "oleaut32",
+            "dinput8",
+            "dxguid",
+            "ksuser",
+            "imm32",
+            "bcrypt",
+            "avrt",
+            "uuid",
+            "dwmapi",
+        ]
+    )
+
+    env.Append(CPPDEFINES=["MINGW_ENABLED", ("MINGW_HAS_SECURE_API", 1)])
+
+    # resrc
+    env.Append(BUILDERS={"RES": env.Builder(action=build_res_file, suffix=".o", src_suffix=".rc")})
+
+
+def configure(env):
+    # At this point the env has been set up with basic tools/compilers.
+    env.Prepend(CPPPATH=["#platform/windows"])
+
+    print("Configuring for Windows: target=%s, bits=%s" % (env["target"], env["bits"]))
+
+    if os.name == "nt":
+        env["ENV"] = os.environ  # this makes build less repeatable, but simplifies some things
+        env["ENV"]["TMP"] = os.environ["TMP"]
+
+    # First figure out which compiler, version, and target arch we're using
+    if os.getenv("VCINSTALLDIR") and not env["use_mingw"]:
+        # Manual setup of MSVC
+        setup_msvc_manual(env)
+        env.msvc = True
+        manual_msvc_config = True
+    elif env.get("MSVC_VERSION", "") and not env["use_mingw"]:
+        setup_msvc_auto(env)
+        env.msvc = True
+        manual_msvc_config = False
+    else:
+        setup_mingw(env)
+        env.msvc = False
+
+    # Now set compiler/linker flags
+    if env.msvc:
+        configure_msvc(env, manual_msvc_config)
+
+    else:  # MinGW
+        configure_mingw(env)

platform/x11/detect.py

@@ -0,0 +1,423 @@
+import os
+import platform
+import sys
+from methods import get_compiler_version, using_gcc, using_clang
+
+
+def is_active():
+    return True
+
+
+def get_name():
+    return "X11"
+
+
+def can_build():
+    if os.name != "posix" or sys.platform == "darwin":
+        return False
+
+    # Check the minimal dependencies
+    x11_error = os.system("pkg-config --version > /dev/null")
+    if x11_error:
+        print("Error: pkg-config not found. Aborting.")
+        return False
+
+    x11_error = os.system("pkg-config x11 --modversion > /dev/null")
+    if x11_error:
+        print("Error: X11 libraries not found. Aborting.")
+        return False
+
+    x11_error = os.system("pkg-config xcursor --modversion > /dev/null")
+    if x11_error:
+        print("Error: Xcursor library not found. Aborting.")
+        return False
+
+    x11_error = os.system("pkg-config xinerama --modversion > /dev/null")
+    if x11_error:
+        print("Error: Xinerama library not found. Aborting.")
+        return False
+
+    x11_error = os.system("pkg-config xext --modversion > /dev/null")
+    if x11_error:
+        print("Error: Xext library not found. Aborting.")
+        return False
+
+    x11_error = os.system("pkg-config xrandr --modversion > /dev/null")
+    if x11_error:
+        print("Error: XrandR library not found. Aborting.")
+        return False
+
+    x11_error = os.system("pkg-config xrender --modversion > /dev/null")
+    if x11_error:
+        print("Error: XRender library not found. Aborting.")
+        return False
+
+    x11_error = os.system("pkg-config xi --modversion > /dev/null")
+    if x11_error:
+        print("Error: Xi library not found. Aborting.")
+        return False
+
+    return True
+
+
+def get_opts():
+    from SCons.Variables import BoolVariable, EnumVariable
+
+    return [
+        EnumVariable("linker", "Linker program", "default", ("default", "bfd", "gold", "lld", "mold")),
+        BoolVariable("use_llvm", "Use the LLVM compiler", False),
+        BoolVariable("use_static_cpp", "Link libgcc and libstdc++ statically for better portability", True),
+        BoolVariable('use_coverage', 'Test Pandemonium coverage', False),
+        BoolVariable("use_ubsan", "Use LLVM/GCC compiler undefined behavior sanitizer (UBSAN)", False),
+        BoolVariable("use_asan", "Use LLVM/GCC compiler address sanitizer (ASAN))", False),
+        BoolVariable("use_lsan", "Use LLVM/GCC compiler leak sanitizer (LSAN))", False),
+        BoolVariable("use_tsan", "Use LLVM/GCC compiler thread sanitizer (TSAN))", False),
+        BoolVariable("use_msan", "Use LLVM/GCC compiler memory sanitizer (MSAN))", False),
+        BoolVariable("pulseaudio", "Detect and use PulseAudio", True),
+        BoolVariable("udev", "Use udev for gamepad connection callbacks", True),
+        BoolVariable("debug_symbols", "Add debugging symbols to release/release_debug builds", True),
+        BoolVariable("separate_debug_symbols", "Create a separate file containing debugging symbols", False),
+        BoolVariable("touch", "Enable touch events", True),
+        BoolVariable("execinfo", "Use libexecinfo on systems where glibc is not available", False),
+    ]
+
+
+def get_flags():
+    return []
+
+
+def configure(env):
+    ## Build type
+
+    if env["target"] == "release":
+        if env["optimize"] == "speed":  # optimize for speed (default)
+            env.Prepend(CCFLAGS=["-O3"])
+        elif env["optimize"] == "size":  # optimize for size
+            env.Prepend(CCFLAGS=["-Os"])
+
+        if env["debug_symbols"]:
+            env.Prepend(CCFLAGS=["-g2"])
+
+    elif env["target"] == "release_debug":
+        if env["optimize"] == "speed":  # optimize for speed (default)
+            env.Prepend(CCFLAGS=["-O2"])
+        elif env["optimize"] == "size":  # optimize for size
+            env.Prepend(CCFLAGS=["-Os"])
+
+        if env["debug_symbols"]:
+            env.Prepend(CCFLAGS=["-g2"])
+
+    elif env["target"] == "debug":
+        env.Prepend(CCFLAGS=["-ggdb"])
+        env.Prepend(CCFLAGS=["-g3"])
+        env.Append(LINKFLAGS=["-rdynamic"])
+
+    if env["debug_symbols"]:
+        # Adding dwarf-4 explicitly makes stacktraces work with clang builds,
+        # otherwise addr2line doesn't understand them
+        env.Append(CCFLAGS=["-gdwarf-4"])
+
+    ## Architecture
+
+    is64 = sys.maxsize > 2**32
+    if env["bits"] == "default":
+        env["bits"] = "64" if is64 else "32"
+
+    machines = {
+        "riscv64": "rv64",
+        "ppc64le": "ppc64",
+        "ppc64": "ppc64",
+        "ppcle": "ppc",
+        "ppc": "ppc",
+    }
+
+    if env["arch"] == "" and platform.machine() in machines:
+        env["arch"] = machines[platform.machine()]
+
+    if env["arch"] == "rv64":
+        # G = General-purpose extensions, C = Compression extension (very common).
+        env.Append(CCFLAGS=["-march=rv64gc"])
+
+    ## Compiler configuration
+
+    if "CXX" in env and "clang" in os.path.basename(env["CXX"]):
+        # Convenience check to enforce the use_llvm overrides when CXX is clang(++)
+        env["use_llvm"] = True
+
+    if env["use_llvm"]:
+        if "clang++" not in os.path.basename(env["CXX"]):
+            env["CC"] = "clang"
+            env["CXX"] = "clang++"
+        env.extra_suffix = ".llvm" + env.extra_suffix
+
+    # Linker
+
+    if env["linker"] != "default":
+        print("Using linker program: " + env["linker"])
+        if env["linker"] == "mold" and using_gcc(env):  # GCC < 12.1 doesn't support -fuse-ld=mold.
+            cc_semver = tuple(get_compiler_version(env))
+            if cc_semver < (12, 1):
+                found_wrapper = False
+                for path in ["/usr/libexec", "/usr/local/libexec", "/usr/lib", "/usr/local/lib"]:
+                    if os.path.isfile(path + "/mold/ld"):
+                        env.Append(LINKFLAGS=["-B" + path + "/mold"])
+                        found_wrapper = True
+                        break
+                if not found_wrapper:
+                    print("Couldn't locate mold installation path. Make sure it's installed in /usr or /usr/local.")
+                    sys.exit(255)
+            else:
+                env.Append(LINKFLAGS=["-fuse-ld=mold"])
+        else:
+            env.Append(LINKFLAGS=["-fuse-ld=%s" % env["linker"]])
+
+    if env['use_coverage']:
+        env.Append(CCFLAGS=['-ftest-coverage', '-fprofile-arcs'])
+        env.Append(LINKFLAGS=['-ftest-coverage', '-fprofile-arcs'])
+
+    # Sanitizers
+    if env["use_ubsan"] or env["use_asan"] or env["use_lsan"] or env["use_tsan"] or env["use_msan"]:
+        env.extra_suffix += "s"
+
+        if env["use_ubsan"]:
+            env.Append(
+                CCFLAGS=[
+                    "-fsanitize=undefined,shift,shift-exponent,integer-divide-by-zero,unreachable,vla-bound,null,return,signed-integer-overflow,bounds,float-divide-by-zero,float-cast-overflow,nonnull-attribute,returns-nonnull-attribute,bool,enum,vptr,pointer-overflow,builtin"
+                ]
+            )
+
+            if env["use_llvm"]:
+                env.Append(
+                    CCFLAGS=[
+                        "-fsanitize=nullability-return,nullability-arg,function,nullability-assign,implicit-integer-sign-change,implicit-signed-integer-truncation,implicit-unsigned-integer-truncation"
+                    ]
+                )
+            else:
+                env.Append(CCFLAGS=["-fsanitize=bounds-strict"])
+        env.Append(LINKFLAGS=["-fsanitize=undefined"])
+
+        if env["use_asan"]:
+            env.Append(CCFLAGS=["-fsanitize=address,pointer-subtract,pointer-compare"])
+            env.Append(LINKFLAGS=["-fsanitize=address"])
+
+        if env["use_lsan"]:
+            env.Append(CCFLAGS=["-fsanitize=leak"])
+            env.Append(LINKFLAGS=["-fsanitize=leak"])
+
+        if env["use_tsan"]:
+            env.Append(CCFLAGS=["-fsanitize=thread"])
+            env.Append(LINKFLAGS=["-fsanitize=thread"])
+
+        if env["use_msan"]:
+            env.Append(CCFLAGS=["-fsanitize=memory"])
+            env.Append(LINKFLAGS=["-fsanitize=memory"])
+
+    # LTO
+
+    if env["lto"] == "auto":  # Full LTO for production.
+        env["lto"] = "full"
+
+    if env["lto"] != "none":
+        if env["lto"] == "thin":
+            if not env["use_llvm"]:
+                print("ThinLTO is only compatible with LLVM, use `use_llvm=yes` or `lto=full`.")
+                sys.exit(255)
+            env.Append(CCFLAGS=["-flto=thin"])
+            env.Append(LINKFLAGS=["-flto=thin"])
+        elif not env["use_llvm"] and env.GetOption("num_jobs") > 1:
+            env.Append(CCFLAGS=["-flto"])
+            env.Append(LINKFLAGS=["-flto=" + str(env.GetOption("num_jobs"))])
+        else:
+            env.Append(CCFLAGS=["-flto"])
+            env.Append(LINKFLAGS=["-flto"])
+
+        if not env["use_llvm"]:
+            env["RANLIB"] = "gcc-ranlib"
+            env["AR"] = "gcc-ar"
+
+    env.Append(CCFLAGS=["-pipe"])
+
+    # Check for gcc version >= 6 before adding -no-pie
+    version = get_compiler_version(env) or [-1, -1]
+    if using_gcc(env):
+        if version[0] >= 6:
+            env.Append(CCFLAGS=["-fpie"])
+            env.Append(LINKFLAGS=["-no-pie"])
+    # Do the same for clang should be fine with Clang 4 and higher
+    if using_clang(env):
+        if version[0] >= 4:
+            env.Append(CCFLAGS=["-fpie"])
+            env.Append(LINKFLAGS=["-no-pie"])
+
+    ## Dependencies
+
+    env.ParseConfig("pkg-config x11 --cflags --libs")
+    env.ParseConfig("pkg-config xcursor --cflags --libs")
+    env.ParseConfig("pkg-config xinerama --cflags --libs")
+    env.ParseConfig("pkg-config xext --cflags --libs")
+    env.ParseConfig("pkg-config xrandr --cflags --libs")
+    env.ParseConfig("pkg-config xrender --cflags --libs")
+    env.ParseConfig("pkg-config xi --cflags --libs")
+
+    if env["touch"]:
+        env.Append(CPPDEFINES=["TOUCH_ENABLED"])
+
+    # FIXME: Check for existence of the libs before parsing their flags with pkg-config
+
+    # freetype depends on libpng and zlib, so bundling one of them while keeping others
+    # as shared libraries leads to weird issues
+    if env["builtin_freetype"] or env["builtin_libpng"] or env["builtin_zlib"]:
+        env["builtin_freetype"] = True
+        env["builtin_libpng"] = True
+        env["builtin_zlib"] = True
+
+    if not env["builtin_freetype"]:
+        env.ParseConfig("pkg-config freetype2 --cflags --libs")
+
+    if not env["builtin_libpng"]:
+        env.ParseConfig("pkg-config libpng16 --cflags --libs")
+
+    if False:  # not env['builtin_assimp']:
+        # FIXME: Add min version check
+        env.ParseConfig("pkg-config assimp --cflags --libs")
+
+    if not env["builtin_enet"]:
+        env.ParseConfig("pkg-config libenet --cflags --libs")
+
+    if not env["builtin_squish"]:
+        env.ParseConfig("pkg-config libsquish --cflags --libs")
+
+    if not env["builtin_zstd"]:
+        env.ParseConfig("pkg-config libzstd --cflags --libs")
+
+    # Sound and video libraries
+    # Keep the order as it triggers chained dependencies (ogg needed by others, etc.)
+
+    if not env["builtin_libtheora"]:
+        env["builtin_libogg"] = False  # Needed to link against system libtheora
+        env["builtin_libvorbis"] = False  # Needed to link against system libtheora
+        env.ParseConfig("pkg-config theora theoradec --cflags --libs")
+    else:
+        list_of_x86 = ["x86_64", "x86", "i386", "i586"]
+        if env["arch"] == "":
+            if any(platform.machine() in s for s in list_of_x86):
+                env["x86_libtheora_opt_gcc"] = True
+        else:
+            if any(env["arch"] in s for s in list_of_x86):
+                env["x86_libtheora_opt_gcc"] = True
+
+    if not env["builtin_libvorbis"]:
+        env["builtin_libogg"] = False  # Needed to link against system libvorbis
+        env.ParseConfig("pkg-config vorbis vorbisfile --cflags --libs")
+
+    if not env["builtin_opus"]:
+        env["builtin_libogg"] = False  # Needed to link against system opus
+        env.ParseConfig("pkg-config opus opusfile --cflags --libs")
+
+    if not env["builtin_libogg"]:
+        env.ParseConfig("pkg-config ogg --cflags --libs")
+
+    if not env["builtin_mbedtls"]:
+        # mbedTLS does not provide a pkgconfig config yet. See https://github.com/ARMmbed/mbedtls/issues/228
+        env.Append(LIBS=["mbedtls", "mbedcrypto", "mbedx509"])
+
+    if not env["builtin_wslay"]:
+        env.ParseConfig("pkg-config libwslay --cflags --libs")
+
+    if not env["builtin_miniupnpc"]:
+        # No pkgconfig file so far, hardcode default paths.
+        env.Prepend(CPPPATH=["/usr/include/miniupnpc"])
+        env.Append(LIBS=["miniupnpc"])
+
+    # On Linux wchar_t should be 32-bits
+    # 16-bit library shouldn't be required due to compiler optimisations
+    if not env["builtin_pcre2"]:
+        env.ParseConfig("pkg-config libpcre2-32 --cflags --libs")
+
+    ## Flags
+
+    if os.system("pkg-config --exists alsa") == 0:  # 0 means found
+        env["alsa"] = True
+        env.Append(CPPDEFINES=["ALSA_ENABLED", "ALSAMIDI_ENABLED"])
+        env.ParseConfig("pkg-config alsa --cflags")  # Only cflags, we dlopen the library.
+    else:
+        print("Warning: ALSA libraries not found. Disabling the ALSA audio driver.")
+
+    if env["pulseaudio"]:
+        if os.system("pkg-config --exists libpulse") == 0:  # 0 means found
+            env.Append(CPPDEFINES=["PULSEAUDIO_ENABLED"])
+            env.ParseConfig("pkg-config libpulse --cflags")  # Only cflags, we dlopen the library.
+        else:
+            print("Warning: PulseAudio development libraries not found. Disabling the PulseAudio audio driver.")
+
+    if platform.system() == "Linux":
+        env.Append(CPPDEFINES=["JOYDEV_ENABLED"])
+        if env["udev"]:
+            if os.system("pkg-config --exists libudev") == 0:  # 0 means found
+                env.Append(CPPDEFINES=["UDEV_ENABLED"])
+                env.ParseConfig("pkg-config libudev --cflags")  # Only cflags, we dlopen the library.
+            else:
+                print("Warning: libudev development libraries not found. Disabling controller hotplugging support.")
+    else:
+        env["udev"] = False  # Linux specific
+
+    # Linkflags below this line should typically stay the last ones
+    if not env["builtin_zlib"]:
+        env.ParseConfig("pkg-config zlib --cflags --libs")
+
+    env.Prepend(CPPPATH=["#platform/x11"])
+    env.Append(CPPDEFINES=["X11_ENABLED", "UNIX_ENABLED", "OPENGL_ENABLED", "GLES_ENABLED", ("_FILE_OFFSET_BITS", 64)])
+
+    env.ParseConfig("pkg-config gl --cflags --libs")
+
+    env.Append(LIBS=["pthread"])
+
+    if platform.system() == "Linux":
+        env.Append(LIBS=["dl"])
+
+    if not env["execinfo"] and platform.libc_ver()[0] != "glibc":
+        # The default crash handler depends on glibc, so if the host uses
+        # a different libc (BSD libc, musl), fall back to libexecinfo.
+        print("Note: Using `execinfo=yes` for the crash handler as required on platforms where glibc is missing.")
+        env["execinfo"] = True
+
+    if env["execinfo"]:
+        env.Append(LIBS=["execinfo"])
+
+    if True:#not env["tools"]:
+        import subprocess
+        import re
+
+        linker_version_str = subprocess.check_output(
+            [env.subst(env["LINK"]), "-Wl,--version"] + env.subst(env["LINKFLAGS"])
+        ).decode("utf-8")
+        gnu_ld_version = re.search("^GNU ld [^$]*(\d+\.\d+)$", linker_version_str, re.MULTILINE)
+        if not gnu_ld_version:
+            print(
+                "Warning: Creating export template binaries enabled for PCK embedding is currently only supported with GNU ld, not gold, LLD or mold."
+            )
+        else:
+            if float(gnu_ld_version.group(1)) >= 2.30:
+                env.Append(LINKFLAGS=["-T", "platform/x11/pck_embed.ld"])
+            else:
+                env.Append(LINKFLAGS=["-T", "platform/x11/pck_embed.legacy.ld"])
+
+    ## Cross-compilation
+
+    if is64 and env["bits"] == "32":
+        env.Append(CCFLAGS=["-m32"])
+        env.Append(LINKFLAGS=["-m32", "-L/usr/lib/i386-linux-gnu"])
+    elif not is64 and env["bits"] == "64":
+        env.Append(CCFLAGS=["-m64"])
+        env.Append(LINKFLAGS=["-m64", "-L/usr/lib/i686-linux-gnu"])
+
+    # Link those statically for portability
+    if env["use_static_cpp"]:
+        env.Append(LINKFLAGS=["-static-libgcc", "-static-libstdc++"])
+        if env["use_llvm"] and platform.system() != "FreeBSD":
+            #env["LINKCOM"] = env["LINKCOM"] + " -l:libatomic.a"
+            env["LINKCOM"] = env["LINKCOM"] + " -latomic"
+
+    else:
+        if env["use_llvm"] and platform.system() != "FreeBSD":
+            env.Append(LIBS=["atomic"])

platform_methods.py

@@ -0,0 +1,81 @@
+import os
+import sys
+import json
+import uuid
+import functools
+import subprocess
+
+# NOTE: The multiprocessing module is not compatible with SCons due to conflict on cPickle
+
+if sys.version_info[0] < 3:
+    JSON_SERIALIZABLE_TYPES = (bool, int, long, float, basestring)
+else:
+    JSON_SERIALIZABLE_TYPES = (bool, int, float, str)
+
+
+def run_in_subprocess(builder_function):
+    @functools.wraps(builder_function)
+    def wrapper(target, source, env):
+
+        # Convert SCons Node instances to absolute paths
+        target = [node.srcnode().abspath for node in target]
+        source = [node.srcnode().abspath for node in source]
+
+        # Short circuit on non-Windows platforms, no need to run in subprocess
+        if sys.platform not in ("win32", "cygwin"):
+            return builder_function(target, source, env)
+
+        # Identify module
+        module_name = builder_function.__module__
+        function_name = builder_function.__name__
+        module_path = sys.modules[module_name].__file__
+        if module_path.endswith(".pyc") or module_path.endswith(".pyo"):
+            module_path = module_path[:-1]
+
+        # Subprocess environment
+        subprocess_env = os.environ.copy()
+        subprocess_env["PYTHONPATH"] = os.pathsep.join([os.getcwd()] + sys.path)
+
+        # Keep only JSON serializable environment items
+        filtered_env = dict((key, value) for key, value in env.items() if isinstance(value, JSON_SERIALIZABLE_TYPES))
+
+        # Save parameters
+        args = (target, source, filtered_env)
+        data = dict(fn=function_name, args=args)
+        json_path = os.path.join(os.environ["TMP"], uuid.uuid4().hex + ".json")
+        with open(json_path, "wt") as json_file:
+            json.dump(data, json_file, indent=2)
+        json_file_size = os.stat(json_path).st_size
+
+        print(
+            "Executing builder function in subprocess: "
+            "module_path=%r, parameter_file=%r, parameter_file_size=%r, target=%r, source=%r"
+            % (module_path, json_path, json_file_size, target, source)
+        )
+        try:
+            exit_code = subprocess.call([sys.executable, module_path, json_path], env=subprocess_env)
+        finally:
+            try:
+                os.remove(json_path)
+            except (OSError, IOError) as e:
+                # Do not fail the entire build if it cannot delete a temporary file
+                print(
+                    "WARNING: Could not delete temporary file: path=%r; [%s] %s" % (json_path, e.__class__.__name__, e)
+                )
+
+        # Must succeed
+        if exit_code:
+            raise RuntimeError(
+                "Failed to run builder function in subprocess: module_path=%r; data=%r" % (module_path, data)
+            )
+
+    return wrapper
+
+
+def subprocess_main(namespace):
+
+    with open(sys.argv[1]) as json_file:
+        data = json.load(json_file)
+
+    fn = namespace[data["fn"]]
+    fn(*data["args"])