#!/usr/bin/env python EnsureSConsVersion(3, 0, 0) EnsurePythonVersion(3, 5) # System import glob import os import pickle import sys from collections import OrderedDict # Local import methods import gles_builders import version from platform_methods import run_in_subprocess # Scan possible build platforms platform_list = [] # list of platforms platform_opts = {} # options for each platform platform_flags = {} # flags for each platform active_platforms = [] active_platform_ids = [] platform_exporters = [] platform_apis = [] for x in sorted(glob.glob("platform/*")): if not os.path.isdir(x) or not os.path.exists(x + "/detect.py"): continue tmppath = "./" + x sys.path.insert(0, tmppath) import detect if os.path.exists(x + "/export/export.cpp"): platform_exporters.append(x[9:]) if os.path.exists(x + "/api/api.cpp"): platform_apis.append(x[9:]) if detect.is_active(): active_platforms.append(detect.get_name()) active_platform_ids.append(x) if detect.can_build(): x = x.replace("platform/", "") # rest of world x = x.replace("platform\\", "") # win32 platform_list += [x] platform_opts[x] = detect.get_opts() platform_flags[x] = detect.get_flags() sys.path.remove(tmppath) sys.modules.pop("detect") methods.save_active_platforms(active_platforms, active_platform_ids) custom_tools = ["default"] platform_arg = ARGUMENTS.get("platform", ARGUMENTS.get("p", False)) if os.name == "nt" and (platform_arg == "android" or ARGUMENTS.get("use_mingw", False)): custom_tools = ["mingw"] elif platform_arg == "javascript": # Use generic POSIX build toolchain for Emscripten. custom_tools = ["cc", "c++", "ar", "link", "textfile", "zip"] env_base = Environment(tools=custom_tools) if "TERM" in os.environ: env_base["ENV"]["TERM"] = os.environ["TERM"] env_base.AppendENVPath("PATH", os.getenv("PATH")) env_base.AppendENVPath("PKG_CONFIG_PATH", os.getenv("PKG_CONFIG_PATH")) env_base.disabled_modules = [] env_base.use_ptrcall = False env_base.module_version_string = "" env_base.msvc = False env_base.__class__.disable_module = methods.disable_module env_base.__class__.add_module_version_string = methods.add_module_version_string env_base.__class__.add_source_files = methods.add_source_files env_base.__class__.use_windows_spawn_fix = methods.use_windows_spawn_fix env_base.__class__.add_shared_library = methods.add_shared_library env_base.__class__.add_library = methods.add_library env_base.__class__.add_program = methods.add_program env_base.__class__.CommandNoCache = methods.CommandNoCache env_base.__class__.disable_warnings = methods.disable_warnings env_base.__class__.module_check_dependencies = methods.module_check_dependencies env_base["x86_libtheora_opt_gcc"] = False env_base["x86_libtheora_opt_vc"] = False # avoid issues when building with different versions of python out of the same directory env_base.SConsignFile(".sconsign{0}.dblite".format(pickle.HIGHEST_PROTOCOL)) # Build options customs = ["custom.py"] profile = ARGUMENTS.get("profile", False) if profile: if os.path.isfile(profile): customs.append(profile) elif os.path.isfile(profile + ".py"): customs.append(profile + ".py") opts = Variables(customs, ARGUMENTS) # Target build options opts.Add("arch", "Platform-dependent architecture (arm/arm64/x86/x64/mips/...)", "") opts.Add(EnumVariable("bits", "Target platform bits", "default", ("default", "32", "64"))) opts.Add("p", "Platform (alias for 'platform')", "") opts.Add("platform", "Target platform (%s)" % ("|".join(platform_list),), "") opts.Add(EnumVariable("target", "Compilation target", "debug", ("debug", "release_debug", "release"))) opts.Add(EnumVariable("optimize", "Optimization type", "speed", ("speed", "size"))) opts.Add(BoolVariable("tools", "Build the tools (a.k.a. the Godot editor)", True)) opts.Add(BoolVariable("tests", "Build the unit tests", False)) opts.Add(BoolVariable("use_lto", "Use link-time optimization", False)) opts.Add(BoolVariable("use_precise_math_checks", "Math checks use very precise epsilon (debug option)", False)) # Components opts.Add(BoolVariable("deprecated", "Enable deprecated features", True)) opts.Add(BoolVariable("minizip", "Enable ZIP archive support using minizip", True)) opts.Add(BoolVariable("xaudio2", "Enable the XAudio2 audio driver", False)) opts.Add("custom_modules", "A list of comma-separated directory paths containing custom modules to build.", "") # Advanced options opts.Add(BoolVariable("verbose", "Enable verbose output for the compilation", False)) opts.Add(BoolVariable("progress", "Show a progress indicator during compilation", True)) opts.Add(EnumVariable("warnings", "Level of compilation warnings", "all", ("extra", "all", "moderate", "no"))) opts.Add(BoolVariable("werror", "Treat compiler warnings as errors", False)) opts.Add(BoolVariable("dev", "If yes, alias for verbose=yes warnings=extra werror=yes", False)) opts.Add("extra_suffix", "Custom extra suffix added to the base filename of all generated binary files", "") opts.Add(BoolVariable("vsproj", "Generate a Visual Studio solution", False)) opts.Add(EnumVariable("macports_clang", "Build using Clang from MacPorts", "no", ("no", "5.0", "devel"))) opts.Add(BoolVariable("disable_3d", "Disable 3D nodes for a smaller executable", False)) opts.Add(BoolVariable("disable_advanced_gui", "Disable advanced GUI nodes and behaviors", False)) opts.Add(BoolVariable("no_editor_splash", "Don't use the custom splash screen for the editor", False)) opts.Add("system_certs_path", "Use this path as SSL certificates default for editor (for package maintainers)", "") # Thirdparty libraries # opts.Add(BoolVariable('builtin_assimp', "Use the built-in Assimp library", True)) opts.Add(BoolVariable("builtin_bullet", "Use the built-in Bullet library", True)) opts.Add(BoolVariable("builtin_certs", "Use the built-in SSL certificates bundles", True)) opts.Add(BoolVariable("builtin_enet", "Use the built-in ENet library", True)) opts.Add(BoolVariable("builtin_freetype", "Use the built-in FreeType library", True)) opts.Add(BoolVariable("builtin_glslang", "Use the built-in glslang library", True)) opts.Add(BoolVariable("builtin_libogg", "Use the built-in libogg library", True)) opts.Add(BoolVariable("builtin_libpng", "Use the built-in libpng library", True)) opts.Add(BoolVariable("builtin_libtheora", "Use the built-in libtheora library", True)) opts.Add(BoolVariable("builtin_libvorbis", "Use the built-in libvorbis library", True)) opts.Add(BoolVariable("builtin_libvpx", "Use the built-in libvpx library", True)) opts.Add(BoolVariable("builtin_libwebp", "Use the built-in libwebp library", True)) opts.Add(BoolVariable("builtin_wslay", "Use the built-in wslay library", True)) opts.Add(BoolVariable("builtin_mbedtls", "Use the built-in mbedTLS library", True)) opts.Add(BoolVariable("builtin_miniupnpc", "Use the built-in miniupnpc library", True)) opts.Add(BoolVariable("builtin_opus", "Use the built-in Opus library", True)) opts.Add(BoolVariable("builtin_pcre2", "Use the built-in PCRE2 library", True)) opts.Add(BoolVariable("builtin_pcre2_with_jit", "Use JIT compiler for the built-in PCRE2 library", True)) opts.Add(BoolVariable("builtin_recast", "Use the built-in Recast library", True)) opts.Add(BoolVariable("builtin_rvo2", "Use the built-in RVO2 library", True)) opts.Add(BoolVariable("builtin_squish", "Use the built-in squish library", True)) opts.Add(BoolVariable("builtin_vulkan", "Use the built-in Vulkan loader library and headers", True)) opts.Add(BoolVariable("builtin_xatlas", "Use the built-in xatlas library", True)) opts.Add(BoolVariable("builtin_zlib", "Use the built-in zlib library", True)) opts.Add(BoolVariable("builtin_zstd", "Use the built-in Zstd library", True)) # Compilation environment setup opts.Add("CXX", "C++ compiler") opts.Add("CC", "C compiler") opts.Add("LINK", "Linker") opts.Add("CCFLAGS", "Custom flags for both the C and C++ compilers") opts.Add("CFLAGS", "Custom flags for the C compiler") opts.Add("CXXFLAGS", "Custom flags for the C++ compiler") opts.Add("LINKFLAGS", "Custom flags for the linker") # add platform specific options for k in platform_opts.keys(): opt_list = platform_opts[k] for o in opt_list: opts.Add(o) # Update the environment now as the "custom_modules" option may be # defined in a file rather than specified via the command line. opts.Update(env_base) # Detect modules. modules_detected = OrderedDict() module_search_paths = ["modules"] # Built-in path. if env_base["custom_modules"]: paths = env_base["custom_modules"].split(",") for p in paths: try: module_search_paths.append(methods.convert_custom_modules_path(p)) except ValueError as e: print(e) Exit(255) for path in module_search_paths: # Note: custom modules can override built-in ones. modules_detected.update(methods.detect_modules(path)) include_path = os.path.dirname(path) if include_path: env_base.Prepend(CPPPATH=[include_path]) # Add module options. for name, path in modules_detected.items(): enabled = True sys.path.insert(0, path) import config try: enabled = config.is_enabled() except AttributeError: pass sys.path.remove(path) sys.modules.pop("config") opts.Add(BoolVariable("module_" + name + "_enabled", "Enable module '%s'" % (name,), enabled)) methods.write_modules(modules_detected) # Update the environment again after all the module options are added. opts.Update(env_base) Help(opts.GenerateHelpText(env_base)) # add default include paths env_base.Prepend(CPPPATH=["#"]) # configure ENV for platform env_base.platform_exporters = platform_exporters env_base.platform_apis = platform_apis if env_base["use_precise_math_checks"]: env_base.Append(CPPDEFINES=["PRECISE_MATH_CHECKS"]) if env_base["target"] == "debug": env_base.Append(CPPDEFINES=["DEBUG_MEMORY_ALLOC", "DISABLE_FORCED_INLINE"]) # The two options below speed up incremental builds, but reduce the certainty that all files # will properly be rebuilt. As such, we only enable them for debug (dev) builds, not release. # To decide whether to rebuild a file, use the MD5 sum only if the timestamp has changed. # http://scons.org/doc/production/HTML/scons-user/ch06.html#idm139837621851792 env_base.Decider("MD5-timestamp") # Use cached implicit dependencies by default. Can be overridden by specifying `--implicit-deps-changed` in the command line. # http://scons.org/doc/production/HTML/scons-user/ch06s04.html env_base.SetOption("implicit_cache", 1) if not env_base["tools"]: # Export templates can't run unit test tool. env_base["tests"] = False if env_base["no_editor_splash"]: env_base.Append(CPPDEFINES=["NO_EDITOR_SPLASH"]) if not env_base["deprecated"]: env_base.Append(CPPDEFINES=["DISABLE_DEPRECATED"]) env_base.platforms = {} selected_platform = "" if env_base["platform"] != "": selected_platform = env_base["platform"] elif env_base["p"] != "": selected_platform = env_base["p"] env_base["platform"] = selected_platform else: # Missing `platform` argument, try to detect platform automatically if sys.platform.startswith("linux"): selected_platform = "linuxbsd" elif sys.platform == "darwin": selected_platform = "osx" elif sys.platform == "win32": selected_platform = "windows" else: print("Could not detect platform automatically. Supported platforms:") for x in platform_list: print("\t" + x) print("\nPlease run SCons again and select a valid platform: platform=<string>") if selected_platform != "": print("Automatically detected platform: " + selected_platform) env_base["platform"] = selected_platform if selected_platform in ["linux", "bsd", "x11"]: if selected_platform == "x11": # Deprecated alias kept for compatibility. print('Platform "x11" has been renamed to "linuxbsd" in Godot 4.0. Building for platform "linuxbsd".') # Alias for convenience. selected_platform = "linuxbsd" env_base["platform"] = selected_platform if selected_platform in platform_list: tmppath = "./platform/" + selected_platform sys.path.insert(0, tmppath) import detect if "create" in dir(detect): env = detect.create(env_base) else: env = env_base.Clone() # Compilation DB requires SCons 3.1.1+. from SCons import __version__ as scons_raw_version scons_ver = env._get_major_minor_revision(scons_raw_version) if scons_ver >= (3, 1, 1): env.Tool("compilation_db", toolpath=["misc/scons"]) env.Alias("compiledb", env.CompilationDatabase("compile_commands.json")) if env["dev"]: env["verbose"] = True env["warnings"] = "extra" env["werror"] = True if env["tools"]: env["tests"] = True if env["vsproj"]: env.vs_incs = [] env.vs_srcs = [] def AddToVSProject(sources): for x in sources: if type(x) == type(""): fname = env.File(x).path else: fname = env.File(x)[0].path pieces = fname.split(".") if len(pieces) > 0: basename = pieces[0] basename = basename.replace("\\\\", "/") if os.path.isfile(basename + ".h"): env.vs_incs = env.vs_incs + [basename + ".h"] elif os.path.isfile(basename + ".hpp"): env.vs_incs = env.vs_incs + [basename + ".hpp"] if os.path.isfile(basename + ".c"): env.vs_srcs = env.vs_srcs + [basename + ".c"] elif os.path.isfile(basename + ".cpp"): env.vs_srcs = env.vs_srcs + [basename + ".cpp"] env.AddToVSProject = AddToVSProject env.extra_suffix = "" if env["extra_suffix"] != "": env.extra_suffix += "." + env["extra_suffix"] # Environment flags CCFLAGS = env.get("CCFLAGS", "") env["CCFLAGS"] = "" env.Append(CCFLAGS=str(CCFLAGS).split()) CFLAGS = env.get("CFLAGS", "") env["CFLAGS"] = "" env.Append(CFLAGS=str(CFLAGS).split()) CXXFLAGS = env.get("CXXFLAGS", "") env["CXXFLAGS"] = "" env.Append(CXXFLAGS=str(CXXFLAGS).split()) LINKFLAGS = env.get("LINKFLAGS", "") env["LINKFLAGS"] = "" env.Append(LINKFLAGS=str(LINKFLAGS).split()) # Platform specific flags flag_list = platform_flags[selected_platform] for f in flag_list: if not (f[0] in ARGUMENTS): # allow command line to override platform flags env[f[0]] = f[1] # Must happen after the flags definition, so that they can be used by platform detect detect.configure(env) # Set our C and C++ standard requirements. # C++17 is required as we need guaranteed copy elision as per GH-36436. # Prepending to make it possible to override. # This needs to come after `configure`, otherwise we don't have env.msvc. if not env.msvc: # Specifying GNU extensions support explicitly, which are supported by # both GCC and Clang. Both currently default to gnu11 and gnu++14. env.Prepend(CFLAGS=["-std=gnu11"]) env.Prepend(CXXFLAGS=["-std=gnu++17"]) else: # MSVC doesn't have clear C standard support, /std only covers C++. # We apply it to CCFLAGS (both C and C++ code) in case it impacts C features. env.Prepend(CCFLAGS=["/std:c++17"]) # Enforce our minimal compiler version requirements cc_version = methods.get_compiler_version(env) or [-1, -1] cc_version_major = cc_version[0] cc_version_minor = cc_version[1] if methods.using_gcc(env): # GCC 8 before 8.4 has a regression in the support of guaranteed copy elision # which causes a build failure: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=86521 if cc_version_major == 8 and cc_version_minor < 4: print( "Detected GCC 8 version < 8.4, which is not supported due to a " "regression in its C++17 guaranteed copy elision support. Use a " 'newer GCC version, or Clang 6 or later by passing "use_llvm=yes" ' "to the SCons command line." ) Exit(255) elif cc_version_major < 7: print( "Detected GCC version older than 7, which does not fully support " "C++17. Supported versions are GCC 7, 9 and later. Use a newer GCC " 'version, or Clang 6 or later by passing "use_llvm=yes" to the ' "SCons command line." ) Exit(255) elif methods.using_clang(env): # Apple LLVM versions differ from upstream LLVM version \o/, compare # in https://en.wikipedia.org/wiki/Xcode#Toolchain_versions if env["platform"] == "osx" or env["platform"] == "iphone": vanilla = methods.is_vanilla_clang(env) if vanilla and cc_version_major < 6: print( "Detected Clang version older than 6, which does not fully support " "C++17. Supported versions are Clang 6 and later." ) Exit(255) elif not vanilla and cc_version_major < 10: print( "Detected Apple Clang version older than 10, which does not fully " "support C++17. Supported versions are Apple Clang 10 and later." ) Exit(255) elif cc_version_major < 6: print( "Detected Clang version older than 6, which does not fully support " "C++17. Supported versions are Clang 6 and later." ) Exit(255) # Configure compiler warnings if env.msvc: # Truncations, narrowing conversions, signed/unsigned comparisons... disable_nonessential_warnings = ["/wd4267", "/wd4244", "/wd4305", "/wd4018", "/wd4800"] if env["warnings"] == "extra": env.Append(CCFLAGS=["/Wall"]) # Implies /W4 elif env["warnings"] == "all": env.Append(CCFLAGS=["/W3"] + disable_nonessential_warnings) elif env["warnings"] == "moderate": env.Append(CCFLAGS=["/W2"] + disable_nonessential_warnings) else: # 'no' env.Append(CCFLAGS=["/w"]) # Set exception handling model to avoid warnings caused by Windows system headers. env.Append(CCFLAGS=["/EHsc"]) if env["werror"]: env.Append(CCFLAGS=["/WX"]) # Force to use Unicode encoding env.Append(MSVC_FLAGS=["/utf8"]) else: # Rest of the world shadow_local_warning = [] all_plus_warnings = ["-Wwrite-strings"] if methods.using_gcc(env): env.Append(CCFLAGS=["-Wno-misleading-indentation"]) if cc_version_major >= 7: shadow_local_warning = ["-Wshadow-local"] if env["warnings"] == "extra": env.Append(CCFLAGS=["-Wall", "-Wextra", "-Wno-unused-parameter"] + all_plus_warnings + shadow_local_warning) env.Append(CXXFLAGS=["-Wctor-dtor-privacy", "-Wnon-virtual-dtor"]) if methods.using_gcc(env): env.Append( CCFLAGS=[ "-Walloc-zero", "-Wduplicated-branches", "-Wduplicated-cond", "-Wstringop-overflow=4", "-Wlogical-op", ] ) # -Wnoexcept was removed temporarily due to GH-36325. env.Append(CXXFLAGS=["-Wplacement-new=1"]) if cc_version_major >= 9: env.Append(CCFLAGS=["-Wattribute-alias=2"]) if methods.using_clang(env): env.Append(CCFLAGS=["-Wimplicit-fallthrough"]) elif env["warnings"] == "all": env.Append(CCFLAGS=["-Wall"] + shadow_local_warning) elif env["warnings"] == "moderate": env.Append(CCFLAGS=["-Wall", "-Wno-unused"] + shadow_local_warning) else: # 'no' env.Append(CCFLAGS=["-w"]) if env["werror"]: env.Append(CCFLAGS=["-Werror"]) # FIXME: Temporary workaround after the Vulkan merge, remove once warnings are fixed. if methods.using_gcc(env): env.Append(CXXFLAGS=["-Wno-error=cpp"]) if cc_version_major == 7: # Bogus warning fixed in 8+. env.Append(CCFLAGS=["-Wno-error=strict-overflow"]) else: env.Append(CXXFLAGS=["-Wno-error=#warnings"]) else: # always enable those errors env.Append(CCFLAGS=["-Werror=return-type"]) if hasattr(detect, "get_program_suffix"): suffix = "." + detect.get_program_suffix() else: suffix = "." + selected_platform if env["target"] == "release": if env["tools"]: print("Tools can only be built with targets 'debug' and 'release_debug'.") Exit(255) suffix += ".opt" env.Append(CPPDEFINES=["NDEBUG"]) elif env["target"] == "release_debug": if env["tools"]: suffix += ".opt.tools" else: suffix += ".opt.debug" else: if env["tools"]: suffix += ".tools" else: suffix += ".debug" if env["arch"] != "": suffix += "." + env["arch"] elif env["bits"] == "32": suffix += ".32" elif env["bits"] == "64": suffix += ".64" suffix += env.extra_suffix sys.path.remove(tmppath) sys.modules.pop("detect") modules_enabled = OrderedDict() env.module_icons_paths = [] env.doc_class_path = {} for name, path in modules_detected.items(): if not env["module_" + name + "_enabled"]: continue sys.path.insert(0, path) env.current_module = name import config if config.can_build(env, selected_platform): config.configure(env) # Get doc classes paths (if present) try: doc_classes = config.get_doc_classes() doc_path = config.get_doc_path() for c in doc_classes: env.doc_class_path[c] = path + "/" + doc_path except: pass # Get icon paths (if present) try: icons_path = config.get_icons_path() env.module_icons_paths.append(path + "/" + icons_path) except: # Default path for module icons env.module_icons_paths.append(path + "/" + "icons") modules_enabled[name] = path sys.path.remove(path) sys.modules.pop("config") env.module_list = modules_enabled methods.update_version(env.module_version_string) env["PROGSUFFIX"] = suffix + env.module_version_string + env["PROGSUFFIX"] env["OBJSUFFIX"] = suffix + env["OBJSUFFIX"] # (SH)LIBSUFFIX will be used for our own built libraries # LIBSUFFIXES contains LIBSUFFIX and SHLIBSUFFIX by default, # so we need to append the default suffixes to keep the ability # to link against thirdparty libraries (.a, .so, .lib, etc.). if os.name == "nt": # On Windows, only static libraries and import libraries can be # statically linked - both using .lib extension env["LIBSUFFIXES"] += [env["LIBSUFFIX"]] else: env["LIBSUFFIXES"] += [env["LIBSUFFIX"], env["SHLIBSUFFIX"]] env["LIBSUFFIX"] = suffix + env["LIBSUFFIX"] env["SHLIBSUFFIX"] = suffix + env["SHLIBSUFFIX"] if env.use_ptrcall: env.Append(CPPDEFINES=["PTRCALL_ENABLED"]) if env["tools"]: env.Append(CPPDEFINES=["TOOLS_ENABLED"]) if env["disable_3d"]: if env["tools"]: print( "Build option 'disable_3d=yes' cannot be used with 'tools=yes' (editor), " "only with 'tools=no' (export template)." ) Exit(255) else: env.Append(CPPDEFINES=["_3D_DISABLED"]) if env["disable_advanced_gui"]: if env["tools"]: print( "Build option 'disable_advanced_gui=yes' cannot be used with 'tools=yes' (editor), " "only with 'tools=no' (export template)." ) Exit(255) else: env.Append(CPPDEFINES=["ADVANCED_GUI_DISABLED"]) if env["minizip"]: env.Append(CPPDEFINES=["MINIZIP_ENABLED"]) editor_module_list = ["regex"] if env["tools"] and not env.module_check_dependencies("tools", editor_module_list): print( "Build option 'module_" + x + "_enabled=no' cannot be used with 'tools=yes' (editor), only with 'tools=no' (export template)." ) Exit(255) if not env["verbose"]: methods.no_verbose(sys, env) if not env["platform"] == "server": env.Append( BUILDERS={ "GLES2_GLSL": env.Builder( action=run_in_subprocess(gles_builders.build_gles2_headers), suffix="glsl.gen.h", src_suffix=".glsl" ) } ) env.Append( BUILDERS={ "RD_GLSL": env.Builder( action=run_in_subprocess(gles_builders.build_rd_headers), suffix="glsl.gen.h", src_suffix=".glsl" ) } ) env.Append( BUILDERS={ "GLSL_HEADER": env.Builder( action=run_in_subprocess(gles_builders.build_raw_headers), suffix="glsl.gen.h", src_suffix=".glsl" ) } ) scons_cache_path = os.environ.get("SCONS_CACHE") if scons_cache_path != None: CacheDir(scons_cache_path) print("Scons cache enabled... (path: '" + scons_cache_path + "')") Export("env") # Build subdirs, the build order is dependent on link order. SConscript("core/SCsub") SConscript("servers/SCsub") SConscript("scene/SCsub") SConscript("editor/SCsub") SConscript("drivers/SCsub") SConscript("platform/SCsub") SConscript("modules/SCsub") if env["tests"]: SConscript("tests/SCsub") SConscript("main/SCsub") SConscript("platform/" + selected_platform + "/SCsub") # Build selected platform. # Microsoft Visual Studio Project Generation if env["vsproj"]: env["CPPPATH"] = [Dir(path) for path in env["CPPPATH"]] methods.generate_vs_project(env, GetOption("num_jobs")) methods.generate_cpp_hint_file("cpp.hint") # Check for the existence of headers conf = Configure(env) if "check_c_headers" in env: for header in env["check_c_headers"]: if conf.CheckCHeader(header[0]): env.AppendUnique(CPPDEFINES=[header[1]]) elif selected_platform != "": if selected_platform == "list": print("The following platforms are available:\n") else: print('Invalid target platform "' + selected_platform + '".') print("The following platforms were detected:\n") for x in platform_list: print("\t" + x) print("\nPlease run SCons again and select a valid platform: platform=<string>") if selected_platform == "list": # Exit early to suppress the rest of the built-in SCons messages Exit() else: Exit(255) # The following only makes sense when the 'env' is defined, and assumes it is. if "env" in locals(): methods.show_progress(env) # TODO: replace this with `env.Dump(format="json")` # once we start requiring SCons 4.0 as min version. methods.dump(env)