2016-10-17 06:50:25 +00:00
|
|
|
#!/usr/bin/env python
|
|
|
|
|
2017-09-24 20:40:15 +00:00
|
|
|
EnsureSConsVersion(0, 98, 1)
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2019-02-10 14:22:31 +00:00
|
|
|
# System
|
2014-02-10 01:10:30 +00:00
|
|
|
import glob
|
2019-02-10 14:22:31 +00:00
|
|
|
import os
|
2019-12-19 09:03:11 +00:00
|
|
|
import pickle
|
2014-02-10 01:10:30 +00:00
|
|
|
import sys
|
2020-05-28 13:48:19 +00:00
|
|
|
from collections import OrderedDict
|
2019-02-10 14:22:31 +00:00
|
|
|
|
|
|
|
# Local
|
2014-02-10 01:10:30 +00:00
|
|
|
import methods
|
2018-03-17 22:23:55 +00:00
|
|
|
import gles_builders
|
|
|
|
from platform_methods import run_in_subprocess
|
2014-03-07 19:20:06 +00:00
|
|
|
|
2014-02-10 01:10:30 +00:00
|
|
|
# scan possible build platforms
|
|
|
|
|
2016-10-30 17:57:40 +00:00
|
|
|
platform_list = [] # list of platforms
|
2020-12-17 10:30:19 +00:00
|
|
|
platform_opts = {} # options for each platform
|
2016-10-30 17:57:40 +00:00
|
|
|
platform_flags = {} # flags for each platform
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2016-10-30 17:57:40 +00:00
|
|
|
active_platforms = []
|
|
|
|
active_platform_ids = []
|
|
|
|
platform_exporters = []
|
2017-11-16 00:33:48 +00:00
|
|
|
platform_apis = []
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2018-08-28 18:40:51 +00:00
|
|
|
for x in sorted(glob.glob("platform/*")):
|
2020-03-30 06:28:32 +00:00
|
|
|
if not os.path.isdir(x) or not os.path.exists(x + "/detect.py"):
|
2016-10-30 17:44:57 +00:00
|
|
|
continue
|
2016-10-30 17:57:40 +00:00
|
|
|
tmppath = "./" + x
|
2016-10-30 17:44:57 +00:00
|
|
|
|
2019-02-10 14:22:31 +00:00
|
|
|
sys.path.insert(0, tmppath)
|
2016-10-30 17:44:57 +00:00
|
|
|
import detect
|
|
|
|
|
2020-03-30 06:28:32 +00:00
|
|
|
if os.path.exists(x + "/export/export.cpp"):
|
2016-10-30 17:44:57 +00:00
|
|
|
platform_exporters.append(x[9:])
|
2020-03-30 06:28:32 +00:00
|
|
|
if os.path.exists(x + "/api/api.cpp"):
|
2017-11-16 00:33:48 +00:00
|
|
|
platform_apis.append(x[9:])
|
2020-03-30 06:28:32 +00:00
|
|
|
if detect.is_active():
|
2016-10-30 17:57:40 +00:00
|
|
|
active_platforms.append(detect.get_name())
|
2016-10-31 23:24:30 +00:00
|
|
|
active_platform_ids.append(x)
|
2020-03-30 06:28:32 +00:00
|
|
|
if detect.can_build():
|
2016-10-30 17:57:40 +00:00
|
|
|
x = x.replace("platform/", "") # rest of world
|
|
|
|
x = x.replace("platform\\", "") # win32
|
|
|
|
platform_list += [x]
|
2020-12-17 10:30:19 +00:00
|
|
|
platform_opts[x] = detect.get_opts()
|
2016-10-30 17:57:40 +00:00
|
|
|
platform_flags[x] = detect.get_flags()
|
2016-10-30 17:44:57 +00:00
|
|
|
sys.path.remove(tmppath)
|
2020-03-30 06:28:32 +00:00
|
|
|
sys.modules.pop("detect")
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2016-10-30 17:57:40 +00:00
|
|
|
methods.save_active_platforms(active_platforms, active_platform_ids)
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2020-03-30 06:28:32 +00:00
|
|
|
custom_tools = ["default"]
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2016-10-09 19:23:27 +00:00
|
|
|
platform_arg = ARGUMENTS.get("platform", ARGUMENTS.get("p", False))
|
2015-07-24 00:04:50 +00:00
|
|
|
|
2018-03-21 14:51:44 +00:00
|
|
|
if os.name == "nt" and (platform_arg == "android" or ARGUMENTS.get("use_mingw", False)):
|
2020-03-30 06:28:32 +00:00
|
|
|
custom_tools = ["mingw"]
|
|
|
|
elif platform_arg == "javascript":
|
2018-03-21 14:51:44 +00:00
|
|
|
# Use generic POSIX build toolchain for Emscripten.
|
2020-03-30 06:28:32 +00:00
|
|
|
custom_tools = ["cc", "c++", "ar", "link", "textfile", "zip"]
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2016-10-31 23:24:30 +00:00
|
|
|
env_base = Environment(tools=custom_tools)
|
2020-03-30 06:28:32 +00:00
|
|
|
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"))
|
2016-10-30 17:57:40 +00:00
|
|
|
env_base.disabled_modules = []
|
|
|
|
env_base.use_ptrcall = False
|
2017-11-02 02:12:28 +00:00
|
|
|
env_base.module_version_string = ""
|
2018-03-02 19:51:29 +00:00
|
|
|
env_base.msvc = False
|
2016-10-30 17:57:40 +00:00
|
|
|
|
2014-02-10 01:10:30 +00:00
|
|
|
env_base.__class__.disable_module = methods.disable_module
|
|
|
|
|
2017-11-02 02:12:28 +00:00
|
|
|
env_base.__class__.add_module_version_string = methods.add_module_version_string
|
|
|
|
|
2014-02-10 01:10:30 +00:00
|
|
|
env_base.__class__.add_source_files = methods.add_source_files
|
2016-01-25 03:21:04 +00:00
|
|
|
env_base.__class__.use_windows_spawn_fix = methods.use_windows_spawn_fix
|
2016-10-30 16:04:07 +00:00
|
|
|
env_base.__class__.split_lib = methods.split_lib
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2017-11-28 20:27:57 +00:00
|
|
|
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
|
2018-06-21 04:33:25 +00:00
|
|
|
env_base.__class__.CommandNoCache = methods.CommandNoCache
|
2018-09-28 11:29:52 +00:00
|
|
|
env_base.__class__.disable_warnings = methods.disable_warnings
|
2017-11-28 20:27:57 +00:00
|
|
|
|
2016-10-30 17:57:40 +00:00
|
|
|
env_base["x86_libtheora_opt_gcc"] = False
|
|
|
|
env_base["x86_libtheora_opt_vc"] = False
|
2015-11-25 03:28:03 +00:00
|
|
|
|
2019-12-19 09:03:11 +00:00
|
|
|
# avoid issues when building with different versions of python out of the same directory
|
|
|
|
env_base.SConsignFile(".sconsign{0}.dblite".format(pickle.HIGHEST_PROTOCOL))
|
|
|
|
|
2016-11-02 23:23:55 +00:00
|
|
|
# Build options
|
|
|
|
|
2020-03-30 06:28:32 +00:00
|
|
|
customs = ["custom.py"]
|
2014-02-10 01:10:30 +00:00
|
|
|
|
|
|
|
profile = ARGUMENTS.get("profile", False)
|
|
|
|
if profile:
|
2016-10-30 17:44:57 +00:00
|
|
|
if os.path.isfile(profile):
|
|
|
|
customs.append(profile)
|
2016-10-30 17:57:40 +00:00
|
|
|
elif os.path.isfile(profile + ".py"):
|
|
|
|
customs.append(profile + ".py")
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2016-10-30 17:57:40 +00:00
|
|
|
opts = Variables(customs, ARGUMENTS)
|
2016-11-02 23:23:55 +00:00
|
|
|
|
|
|
|
# Target build options
|
2020-03-30 06:28:32 +00:00
|
|
|
opts.Add("p", "Platform (alias for 'platform')", "")
|
|
|
|
opts.Add("platform", "Target platform (%s)" % ("|".join(platform_list),), "")
|
2021-02-03 09:47:06 +00:00
|
|
|
opts.Add(BoolVariable("tools", "Build the tools (a.k.a. the Godot editor)", True))
|
2020-03-30 06:28:32 +00:00
|
|
|
opts.Add(EnumVariable("target", "Compilation target", "debug", ("debug", "release_debug", "release")))
|
2021-02-03 09:47:06 +00:00
|
|
|
opts.Add("arch", "Platform-dependent architecture (arm/arm64/x86/x64/mips/...)", "")
|
|
|
|
opts.Add(EnumVariable("bits", "Target platform bits", "default", ("default", "32", "64")))
|
2020-03-30 06:28:32 +00:00
|
|
|
opts.Add(EnumVariable("optimize", "Optimization type", "speed", ("speed", "size")))
|
2021-02-03 09:47:06 +00:00
|
|
|
opts.Add(BoolVariable("production", "Set defaults to build Godot for use in production", False))
|
2020-03-30 06:28:32 +00:00
|
|
|
opts.Add(BoolVariable("use_lto", "Use link-time optimization", False))
|
2016-11-02 23:23:55 +00:00
|
|
|
|
|
|
|
# Components
|
2020-03-30 06:28:32 +00:00
|
|
|
opts.Add(BoolVariable("deprecated", "Enable deprecated features", True))
|
|
|
|
opts.Add(BoolVariable("gdscript", "Enable GDScript support", True))
|
|
|
|
opts.Add(BoolVariable("minizip", "Enable ZIP archive support using minizip", True))
|
|
|
|
opts.Add(BoolVariable("xaudio2", "Enable the XAudio2 audio driver", False))
|
2020-04-04 11:46:15 +00:00
|
|
|
opts.Add("custom_modules", "A list of comma-separated directory paths containing custom modules to build.", "")
|
2016-11-02 23:23:55 +00:00
|
|
|
|
|
|
|
# Advanced options
|
2021-02-03 09:47:06 +00:00
|
|
|
opts.Add(BoolVariable("dev", "If yes, alias for verbose=yes warnings=extra werror=yes", False))
|
2020-03-30 06:28:32 +00:00
|
|
|
opts.Add(BoolVariable("progress", "Show a progress indicator during compilation", True))
|
2021-02-03 09:47:06 +00:00
|
|
|
opts.Add(BoolVariable("verbose", "Enable verbose output for the compilation", False))
|
2020-03-30 06:28:32 +00:00
|
|
|
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("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(
|
|
|
|
BoolVariable(
|
|
|
|
"split_libmodules",
|
|
|
|
"Split intermediate libmodules.a in smaller chunks to prevent exceeding linker command line size (forced to True when using MinGW)",
|
|
|
|
False,
|
|
|
|
)
|
|
|
|
)
|
|
|
|
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)", "")
|
2020-12-16 15:29:32 +00:00
|
|
|
opts.Add(BoolVariable("use_precise_math_checks", "Math checks use very precise epsilon (debug option)", False))
|
2016-11-02 23:23:55 +00:00
|
|
|
|
|
|
|
# Thirdparty libraries
|
2020-03-30 06:28:32 +00:00
|
|
|
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_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_squish", "Use the built-in squish library", 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))
|
2016-11-02 23:23:55 +00:00
|
|
|
|
2018-01-05 19:37:18 +00:00
|
|
|
# Compilation environment setup
|
2016-11-02 23:23:55 +00:00
|
|
|
opts.Add("CXX", "C++ compiler")
|
|
|
|
opts.Add("CC", "C compiler")
|
2018-01-05 19:37:18 +00:00
|
|
|
opts.Add("LINK", "Linker")
|
|
|
|
opts.Add("CCFLAGS", "Custom flags for both the C and C++ compilers")
|
2016-10-31 23:24:30 +00:00
|
|
|
opts.Add("CFLAGS", "Custom flags for the C compiler")
|
2019-04-24 14:49:12 +00:00
|
|
|
opts.Add("CXXFLAGS", "Custom flags for the C++ compiler")
|
2016-10-31 23:24:30 +00:00
|
|
|
opts.Add("LINKFLAGS", "Custom flags for the linker")
|
2016-11-02 23:23:55 +00:00
|
|
|
|
2020-12-17 10:30:19 +00:00
|
|
|
# Update the environment to have all above options defined
|
|
|
|
# in following code (especially platform and custom_modules).
|
2020-05-29 00:02:32 +00:00
|
|
|
opts.Update(env_base)
|
|
|
|
|
2020-12-17 10:30:19 +00:00
|
|
|
# Platform selection: validate input, and add options.
|
|
|
|
|
|
|
|
selected_platform = ""
|
|
|
|
|
|
|
|
if env_base["platform"] != "":
|
|
|
|
selected_platform = env_base["platform"]
|
|
|
|
elif env_base["p"] != "":
|
|
|
|
selected_platform = env_base["p"]
|
|
|
|
else:
|
|
|
|
# Missing `platform` argument, try to detect platform automatically
|
|
|
|
if sys.platform.startswith("linux"):
|
|
|
|
selected_platform = "x11"
|
|
|
|
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)
|
|
|
|
|
|
|
|
if selected_platform in ["linux", "bsd", "linuxbsd"]:
|
|
|
|
if selected_platform == "linuxbsd":
|
|
|
|
# Alias for forward compatibility.
|
|
|
|
print('Platform "linuxbsd" is still called "x11" in Godot 3.2.x. Building for platform "x11".')
|
|
|
|
# Alias for convenience.
|
|
|
|
selected_platform = "x11"
|
|
|
|
|
|
|
|
# Make sure to update this to the found, valid platform as it's used through the buildsystem as the reference.
|
|
|
|
# It should always be re-set after calling `opts.Update()` otherwise it uses the original input value.
|
|
|
|
env_base["platform"] = selected_platform
|
|
|
|
|
|
|
|
# Add platform-specific options.
|
|
|
|
if selected_platform in platform_opts:
|
|
|
|
for opt in platform_opts[selected_platform]:
|
|
|
|
opts.Add(opt)
|
|
|
|
|
|
|
|
# Update the environment to take platform-specific options into account.
|
|
|
|
opts.Update(env_base)
|
|
|
|
env_base["platform"] = selected_platform # Must always be re-set after calling opts.Update().
|
|
|
|
|
2020-04-04 11:46:15 +00:00
|
|
|
# Detect modules.
|
2020-05-28 13:48:19 +00:00
|
|
|
modules_detected = OrderedDict()
|
2020-04-04 11:46:15 +00:00
|
|
|
module_search_paths = ["modules"] # Built-in path.
|
|
|
|
|
2020-05-29 00:02:32 +00:00
|
|
|
if env_base["custom_modules"]:
|
|
|
|
paths = env_base["custom_modules"].split(",")
|
2020-04-04 11:46:15 +00:00
|
|
|
for p in paths:
|
|
|
|
try:
|
|
|
|
module_search_paths.append(methods.convert_custom_modules_path(p))
|
|
|
|
except ValueError as e:
|
|
|
|
print(e)
|
|
|
|
sys.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)
|
2017-10-02 22:01:15 +00:00
|
|
|
import config
|
2020-04-04 11:46:15 +00:00
|
|
|
|
|
|
|
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)
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2020-05-29 00:02:32 +00:00
|
|
|
# Update the environment again after all the module options are added.
|
|
|
|
opts.Update(env_base)
|
2020-12-17 10:30:19 +00:00
|
|
|
env_base["platform"] = selected_platform # Must always be re-set after calling opts.Update().
|
|
|
|
Help(opts.GenerateHelpText(env_base))
|
2014-02-10 01:10:30 +00:00
|
|
|
|
|
|
|
# add default include paths
|
|
|
|
|
2020-03-30 06:28:32 +00:00
|
|
|
env_base.Prepend(CPPPATH=["#"])
|
2014-12-27 16:42:37 +00:00
|
|
|
|
|
|
|
# configure ENV for platform
|
2016-10-30 17:57:40 +00:00
|
|
|
env_base.platform_exporters = platform_exporters
|
2017-11-16 00:33:48 +00:00
|
|
|
env_base.platform_apis = platform_apis
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2020-03-30 06:28:32 +00:00
|
|
|
if env_base["use_precise_math_checks"]:
|
|
|
|
env_base.Append(CPPDEFINES=["PRECISE_MATH_CHECKS"])
|
2019-02-26 00:46:24 +00:00
|
|
|
|
2020-03-30 06:28:32 +00:00
|
|
|
if env_base["target"] == "debug":
|
|
|
|
env_base.Append(CPPDEFINES=["DEBUG_MEMORY_ALLOC", "DISABLE_FORCED_INLINE"])
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2019-02-10 14:08:16 +00:00
|
|
|
# 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
|
2020-03-30 06:28:32 +00:00
|
|
|
env_base.Decider("MD5-timestamp")
|
2019-02-10 14:08:16 +00:00
|
|
|
# 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
|
2020-03-30 06:28:32 +00:00
|
|
|
env_base.SetOption("implicit_cache", 1)
|
2019-02-10 14:08:16 +00:00
|
|
|
|
2020-03-30 06:28:32 +00:00
|
|
|
if env_base["no_editor_splash"]:
|
|
|
|
env_base.Append(CPPDEFINES=["NO_EDITOR_SPLASH"])
|
2017-12-16 19:11:13 +00:00
|
|
|
|
2020-03-30 06:28:32 +00:00
|
|
|
if not env_base["deprecated"]:
|
|
|
|
env_base.Append(CPPDEFINES=["DISABLE_DEPRECATED"])
|
2016-06-28 16:10:15 +00:00
|
|
|
|
2014-10-07 04:31:49 +00:00
|
|
|
if selected_platform in platform_list:
|
2019-02-10 14:22:31 +00:00
|
|
|
tmppath = "./platform/" + selected_platform
|
|
|
|
sys.path.insert(0, tmppath)
|
2016-10-30 17:44:57 +00:00
|
|
|
import detect
|
2020-03-30 06:28:32 +00:00
|
|
|
|
2016-10-30 17:44:57 +00:00
|
|
|
if "create" in dir(detect):
|
|
|
|
env = detect.create(env_base)
|
|
|
|
else:
|
|
|
|
env = env_base.Clone()
|
2017-10-02 22:01:15 +00:00
|
|
|
|
2021-02-01 16:09:42 +00:00
|
|
|
# Generating the compilation DB (`compile_commands.json`) requires SCons 4.0.0 or later.
|
2020-05-18 11:58:27 +00:00
|
|
|
from SCons import __version__ as scons_raw_version
|
2019-11-02 14:21:21 +00:00
|
|
|
|
2020-05-18 11:58:27 +00:00
|
|
|
scons_ver = env._get_major_minor_revision(scons_raw_version)
|
2020-08-12 14:00:25 +00:00
|
|
|
|
|
|
|
if scons_ver >= (4, 0, 0):
|
|
|
|
env.Tool("compilation_db")
|
|
|
|
env.Alias("compiledb", env.CompilationDatabase())
|
2019-11-02 14:21:21 +00:00
|
|
|
|
2021-02-03 09:47:06 +00:00
|
|
|
# 'dev' and 'production' are aliases to set default options if they haven't been set
|
|
|
|
# manually by the user. We use `ARGUMENTS.get()` to check if they were manually set.
|
2020-03-30 06:28:32 +00:00
|
|
|
if env["dev"]:
|
2021-02-03 09:47:06 +00:00
|
|
|
env["verbose"] = ARGUMENTS.get("verbose", True)
|
|
|
|
env["warnings"] = ARGUMENTS.get("warnings", "extra")
|
|
|
|
env["werror"] = ARGUMENTS.get("werror", True)
|
|
|
|
if env["production"]:
|
|
|
|
env["use_static_cpp"] = ARGUMENTS.get("use_static_cpp", True)
|
|
|
|
env["use_lto"] = ARGUMENTS.get("use_lto", True)
|
|
|
|
env["debug_symbols"] = ARGUMENTS.get("debug_symbols", False)
|
|
|
|
if not env["tools"] and env["target"] == "debug":
|
|
|
|
print(
|
|
|
|
"WARNING: Requested `production` build with `tools=no target=debug`, "
|
|
|
|
"this will give you a full debug template (use `target=release_debug` "
|
|
|
|
"for an optimized template with debug features)."
|
|
|
|
)
|
|
|
|
if env.msvc:
|
|
|
|
print(
|
|
|
|
"WARNING: For `production` Windows builds, you should use MinGW with GCC "
|
|
|
|
"or Clang instead of Visual Studio, as they can better optimize the "
|
|
|
|
"GDScript VM in a very significant way. MSVC LTO also doesn't work "
|
|
|
|
"reliably for our use case."
|
|
|
|
"If you want to use MSVC nevertheless for production builds, set "
|
|
|
|
"`debug_symbols=no use_lto=no` instead of the `production=yes` option."
|
|
|
|
)
|
|
|
|
Exit(255)
|
2016-10-30 17:44:57 +00:00
|
|
|
|
2016-10-30 17:57:40 +00:00
|
|
|
env.extra_suffix = ""
|
2016-10-30 17:44:57 +00:00
|
|
|
|
2020-03-30 06:28:32 +00:00
|
|
|
if env["extra_suffix"] != "":
|
|
|
|
env.extra_suffix += "." + env["extra_suffix"]
|
2016-10-30 17:44:57 +00:00
|
|
|
|
2020-02-20 10:09:20 +00:00
|
|
|
# Environment flags
|
2020-03-30 06:28:32 +00:00
|
|
|
CCFLAGS = env.get("CCFLAGS", "")
|
|
|
|
env["CCFLAGS"] = ""
|
2017-08-26 16:53:49 +00:00
|
|
|
env.Append(CCFLAGS=str(CCFLAGS).split())
|
2016-10-30 17:44:57 +00:00
|
|
|
|
2020-03-30 06:28:32 +00:00
|
|
|
CFLAGS = env.get("CFLAGS", "")
|
|
|
|
env["CFLAGS"] = ""
|
2017-08-26 16:53:49 +00:00
|
|
|
env.Append(CFLAGS=str(CFLAGS).split())
|
2014-02-22 12:34:40 +00:00
|
|
|
|
2020-03-30 06:28:32 +00:00
|
|
|
CXXFLAGS = env.get("CXXFLAGS", "")
|
|
|
|
env["CXXFLAGS"] = ""
|
2019-04-24 14:49:12 +00:00
|
|
|
env.Append(CXXFLAGS=str(CXXFLAGS).split())
|
|
|
|
|
2020-03-30 06:28:32 +00:00
|
|
|
LINKFLAGS = env.get("LINKFLAGS", "")
|
|
|
|
env["LINKFLAGS"] = ""
|
2017-08-26 16:53:49 +00:00
|
|
|
env.Append(LINKFLAGS=str(LINKFLAGS).split())
|
2016-10-30 17:44:57 +00:00
|
|
|
|
2020-02-20 10:09:20 +00:00
|
|
|
# Platform specific flags
|
2016-10-30 17:44:57 +00:00
|
|
|
flag_list = platform_flags[selected_platform]
|
|
|
|
for f in flag_list:
|
2016-10-30 17:57:40 +00:00
|
|
|
if not (f[0] in ARGUMENTS): # allow command line to override platform flags
|
2016-10-30 17:44:57 +00:00
|
|
|
env[f[0]] = f[1]
|
|
|
|
|
2020-02-20 10:09:20 +00:00
|
|
|
# Must happen after the flags definition, so that they can be used by platform detect
|
2016-10-30 17:44:57 +00:00
|
|
|
detect.configure(env)
|
2015-08-23 23:54:13 +00:00
|
|
|
|
2020-02-20 10:09:20 +00:00
|
|
|
# Set our C and C++ standard requirements.
|
|
|
|
# Prepending to make it possible to override
|
|
|
|
# This needs to come after `configure`, otherwise we don't have env.msvc.
|
2019-07-22 14:57:24 +00:00
|
|
|
if not env.msvc:
|
2020-02-20 10:09:20 +00:00
|
|
|
# Specifying GNU extensions support explicitly, which are supported by
|
|
|
|
# both GCC and Clang. This mirrors GCC and Clang's current default
|
|
|
|
# compile flags if no -std is specified.
|
2020-03-30 06:28:32 +00:00
|
|
|
env.Prepend(CFLAGS=["-std=gnu11"])
|
|
|
|
env.Prepend(CXXFLAGS=["-std=gnu++14"])
|
2020-02-20 10:09:20 +00:00
|
|
|
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.
|
2020-03-30 06:28:32 +00:00
|
|
|
env.Prepend(CCFLAGS=["/std:c++14"])
|
2019-07-22 14:57:24 +00:00
|
|
|
|
2018-10-03 11:38:09 +00:00
|
|
|
# Configure compiler warnings
|
2020-10-08 08:49:33 +00:00
|
|
|
if env.msvc: # MSVC
|
2018-10-03 15:27:22 +00:00
|
|
|
# Truncations, narrowing conversions, signed/unsigned comparisons...
|
2020-03-30 06:28:32 +00:00
|
|
|
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"])
|
2017-11-21 18:06:43 +00:00
|
|
|
# Set exception handling model to avoid warnings caused by Windows system headers.
|
2020-03-30 06:28:32 +00:00
|
|
|
env.Append(CCFLAGS=["/EHsc"])
|
2020-10-08 08:49:33 +00:00
|
|
|
|
2020-03-30 06:28:32 +00:00
|
|
|
if env["werror"]:
|
|
|
|
env.Append(CCFLAGS=["/WX"])
|
2020-10-08 08:49:33 +00:00
|
|
|
else: # GCC, Clang
|
2020-02-26 12:23:37 +00:00
|
|
|
version = methods.get_compiler_version(env) or [-1, -1]
|
|
|
|
|
2020-10-08 08:49:33 +00:00
|
|
|
gcc_common_warnings = []
|
2019-02-12 20:10:08 +00:00
|
|
|
|
2019-04-05 10:51:15 +00:00
|
|
|
if methods.using_gcc(env):
|
2020-10-08 08:49:33 +00:00
|
|
|
gcc_common_warnings += ["-Wno-misleading-indentation"]
|
2020-02-26 12:23:37 +00:00
|
|
|
if version[0] >= 7:
|
2020-10-08 08:49:33 +00:00
|
|
|
gcc_common_warnings += ["-Wshadow-local"]
|
2019-04-05 12:06:16 +00:00
|
|
|
|
2020-03-30 06:28:32 +00:00
|
|
|
if env["warnings"] == "extra":
|
2019-04-05 12:06:16 +00:00
|
|
|
# Note: enable -Wimplicit-fallthrough for Clang (already part of -Wextra for GCC)
|
|
|
|
# once we switch to C++11 or later (necessary for our FALLTHROUGH macro).
|
2020-10-08 08:49:33 +00:00
|
|
|
env.Append(CCFLAGS=["-Wall", "-Wextra", "-Wwrite-strings", "-Wno-unused-parameter"] + gcc_common_warnings)
|
2020-03-30 06:28:32 +00:00
|
|
|
env.Append(CXXFLAGS=["-Wctor-dtor-privacy", "-Wnon-virtual-dtor"])
|
2019-04-05 10:51:15 +00:00
|
|
|
if methods.using_gcc(env):
|
2020-03-30 06:28:32 +00:00
|
|
|
env.Append(
|
|
|
|
CCFLAGS=[
|
|
|
|
"-Walloc-zero",
|
|
|
|
"-Wduplicated-branches",
|
|
|
|
"-Wduplicated-cond",
|
|
|
|
"-Wstringop-overflow=4",
|
|
|
|
"-Wlogical-op",
|
|
|
|
]
|
|
|
|
)
|
|
|
|
env.Append(CXXFLAGS=["-Wnoexcept", "-Wplacement-new=1"])
|
2020-02-26 12:23:37 +00:00
|
|
|
if version[0] >= 9:
|
2020-03-30 06:28:32 +00:00
|
|
|
env.Append(CCFLAGS=["-Wattribute-alias=2"])
|
|
|
|
elif env["warnings"] == "all":
|
2020-10-08 08:49:33 +00:00
|
|
|
env.Append(CCFLAGS=["-Wall"] + gcc_common_warnings)
|
2020-03-30 06:28:32 +00:00
|
|
|
elif env["warnings"] == "moderate":
|
2020-10-08 08:49:33 +00:00
|
|
|
env.Append(CCFLAGS=["-Wall", "-Wno-unused"] + gcc_common_warnings)
|
2020-03-30 06:28:32 +00:00
|
|
|
else: # 'no'
|
|
|
|
env.Append(CCFLAGS=["-w"])
|
2020-10-08 08:49:33 +00:00
|
|
|
|
2020-03-30 06:28:32 +00:00
|
|
|
if env["werror"]:
|
|
|
|
env.Append(CCFLAGS=["-Werror"])
|
|
|
|
else: # always enable those errors
|
|
|
|
env.Append(CCFLAGS=["-Werror=return-type"])
|
|
|
|
|
|
|
|
if hasattr(detect, "get_program_suffix"):
|
2018-10-25 13:59:26 +00:00
|
|
|
suffix = "." + detect.get_program_suffix()
|
|
|
|
else:
|
|
|
|
suffix = "." + selected_platform
|
2014-10-07 04:31:49 +00:00
|
|
|
|
2020-03-30 06:28:32 +00:00
|
|
|
if env["target"] == "release":
|
2017-09-25 04:04:49 +00:00
|
|
|
if env["tools"]:
|
2016-10-30 17:44:57 +00:00
|
|
|
print("Tools can only be built with targets 'debug' and 'release_debug'.")
|
|
|
|
sys.exit(255)
|
2016-10-30 17:57:40 +00:00
|
|
|
suffix += ".opt"
|
2020-03-30 06:28:32 +00:00
|
|
|
env.Append(CPPDEFINES=["NDEBUG"])
|
2016-10-30 17:44:57 +00:00
|
|
|
|
2020-03-30 06:28:32 +00:00
|
|
|
elif env["target"] == "release_debug":
|
2017-09-25 04:04:49 +00:00
|
|
|
if env["tools"]:
|
2016-10-30 17:57:40 +00:00
|
|
|
suffix += ".opt.tools"
|
2016-10-30 17:44:57 +00:00
|
|
|
else:
|
2016-10-30 17:57:40 +00:00
|
|
|
suffix += ".opt.debug"
|
2016-10-30 17:44:57 +00:00
|
|
|
else:
|
2017-09-25 04:04:49 +00:00
|
|
|
if env["tools"]:
|
2016-10-30 17:57:40 +00:00
|
|
|
suffix += ".tools"
|
2016-10-30 17:44:57 +00:00
|
|
|
else:
|
2016-10-30 17:57:40 +00:00
|
|
|
suffix += ".debug"
|
2016-10-30 17:44:57 +00:00
|
|
|
|
|
|
|
if env["arch"] != "":
|
2016-10-30 17:57:40 +00:00
|
|
|
suffix += "." + env["arch"]
|
2020-03-30 06:28:32 +00:00
|
|
|
elif env["bits"] == "32":
|
2016-10-30 17:57:40 +00:00
|
|
|
suffix += ".32"
|
2020-03-30 06:28:32 +00:00
|
|
|
elif env["bits"] == "64":
|
2016-10-30 17:57:40 +00:00
|
|
|
suffix += ".64"
|
|
|
|
|
|
|
|
suffix += env.extra_suffix
|
|
|
|
|
2019-02-10 14:22:31 +00:00
|
|
|
sys.path.remove(tmppath)
|
2020-03-30 06:28:32 +00:00
|
|
|
sys.modules.pop("detect")
|
2016-10-30 17:44:57 +00:00
|
|
|
|
2020-05-28 13:48:19 +00:00
|
|
|
modules_enabled = OrderedDict()
|
2019-06-28 20:42:26 +00:00
|
|
|
env.module_icons_paths = []
|
2017-11-15 19:16:51 +00:00
|
|
|
env.doc_class_path = {}
|
2016-10-30 17:44:57 +00:00
|
|
|
|
2020-05-28 13:48:19 +00:00
|
|
|
for name, path in modules_detected.items():
|
2020-04-04 11:46:15 +00:00
|
|
|
if not env["module_" + name + "_enabled"]:
|
2016-10-30 17:44:57 +00:00
|
|
|
continue
|
2020-04-04 11:46:15 +00:00
|
|
|
sys.path.insert(0, path)
|
|
|
|
env.current_module = name
|
2016-10-30 17:44:57 +00:00
|
|
|
import config
|
2020-03-30 06:28:32 +00:00
|
|
|
|
2018-05-30 17:11:33 +00:00
|
|
|
# can_build changed number of arguments between 3.0 (1) and 3.1 (2),
|
|
|
|
# so try both to preserve compatibility for 3.0 modules
|
|
|
|
can_build = False
|
|
|
|
try:
|
|
|
|
can_build = config.can_build(env, selected_platform)
|
|
|
|
except TypeError:
|
2020-03-30 06:28:32 +00:00
|
|
|
print(
|
|
|
|
"Warning: module '%s' uses a deprecated `can_build` "
|
|
|
|
"signature in its config.py file, it should be "
|
|
|
|
"`can_build(env, platform)`." % x
|
|
|
|
)
|
2018-05-30 17:11:33 +00:00
|
|
|
can_build = config.can_build(selected_platform)
|
2020-03-30 06:28:32 +00:00
|
|
|
if can_build:
|
2016-10-30 17:44:57 +00:00
|
|
|
config.configure(env)
|
2019-06-28 20:42:26 +00:00
|
|
|
# Get doc classes paths (if present)
|
2017-09-14 12:34:53 +00:00
|
|
|
try:
|
2019-06-28 20:42:26 +00:00
|
|
|
doc_classes = config.get_doc_classes()
|
|
|
|
doc_path = config.get_doc_path()
|
|
|
|
for c in doc_classes:
|
2020-04-04 11:46:15 +00:00
|
|
|
env.doc_class_path[c] = path + "/" + doc_path
|
2020-12-12 10:10:23 +00:00
|
|
|
except Exception:
|
2017-09-14 12:34:53 +00:00
|
|
|
pass
|
2019-06-28 20:42:26 +00:00
|
|
|
# Get icon paths (if present)
|
|
|
|
try:
|
|
|
|
icons_path = config.get_icons_path()
|
2020-04-04 11:46:15 +00:00
|
|
|
env.module_icons_paths.append(path + "/" + icons_path)
|
2020-12-12 10:10:23 +00:00
|
|
|
except Exception:
|
2019-06-28 20:42:26 +00:00
|
|
|
# Default path for module icons
|
2020-04-04 11:46:15 +00:00
|
|
|
env.module_icons_paths.append(path + "/" + "icons")
|
|
|
|
modules_enabled[name] = path
|
|
|
|
|
|
|
|
sys.path.remove(path)
|
|
|
|
sys.modules.pop("config")
|
2017-09-12 20:42:36 +00:00
|
|
|
|
2020-04-04 11:46:15 +00:00
|
|
|
env.module_list = modules_enabled
|
2016-10-30 17:44:57 +00:00
|
|
|
|
2017-11-02 02:12:28 +00:00
|
|
|
methods.update_version(env.module_version_string)
|
|
|
|
|
2017-12-21 17:51:57 +00:00
|
|
|
env["PROGSUFFIX"] = suffix + env.module_version_string + env["PROGSUFFIX"]
|
2017-11-02 02:12:28 +00:00
|
|
|
env["OBJSUFFIX"] = suffix + env["OBJSUFFIX"]
|
2018-07-23 12:38:30 +00:00
|
|
|
# (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
|
2018-11-17 17:04:08 +00:00
|
|
|
# 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"]]
|
2017-11-02 02:12:28 +00:00
|
|
|
env["LIBSUFFIX"] = suffix + env["LIBSUFFIX"]
|
|
|
|
env["SHLIBSUFFIX"] = suffix + env["SHLIBSUFFIX"]
|
|
|
|
|
2020-03-30 06:28:32 +00:00
|
|
|
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)."
|
|
|
|
)
|
2018-07-21 21:17:03 +00:00
|
|
|
sys.exit(255)
|
|
|
|
else:
|
2020-03-30 06:28:32 +00:00
|
|
|
env.Append(CPPDEFINES=["_3D_DISABLED"])
|
|
|
|
if env["gdscript"]:
|
|
|
|
env.Append(CPPDEFINES=["GDSCRIPT_ENABLED"])
|
|
|
|
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)."
|
|
|
|
)
|
2018-07-21 21:17:03 +00:00
|
|
|
sys.exit(255)
|
|
|
|
else:
|
2020-03-30 06:28:32 +00:00
|
|
|
env.Append(CPPDEFINES=["ADVANCED_GUI_DISABLED"])
|
|
|
|
if env["minizip"]:
|
|
|
|
env.Append(CPPDEFINES=["MINIZIP_ENABLED"])
|
2016-10-30 17:44:57 +00:00
|
|
|
|
2020-03-30 06:28:32 +00:00
|
|
|
editor_module_list = ["regex"]
|
2019-08-11 17:07:59 +00:00
|
|
|
for x in editor_module_list:
|
2020-03-30 06:28:32 +00:00
|
|
|
if not env["module_" + x + "_enabled"]:
|
|
|
|
if env["tools"]:
|
|
|
|
print(
|
|
|
|
"Build option 'module_" + x + "_enabled=no' cannot be used with 'tools=yes' (editor), "
|
|
|
|
"only with 'tools=no' (export template)."
|
|
|
|
)
|
2019-08-11 17:07:59 +00:00
|
|
|
sys.exit(255)
|
|
|
|
|
2020-03-30 06:28:32 +00:00
|
|
|
if not env["verbose"]:
|
2016-10-30 17:57:40 +00:00
|
|
|
methods.no_verbose(sys, env)
|
2017-01-08 13:08:18 +00:00
|
|
|
|
2020-03-30 06:28:32 +00:00
|
|
|
if not env["platform"] == "server": # FIXME: detect GLES3
|
|
|
|
env.Append(
|
|
|
|
BUILDERS={
|
|
|
|
"GLES3_GLSL": env.Builder(
|
|
|
|
action=run_in_subprocess(gles_builders.build_gles3_headers), suffix="glsl.gen.h", src_suffix=".glsl"
|
|
|
|
)
|
|
|
|
}
|
|
|
|
)
|
|
|
|
env.Append(
|
|
|
|
BUILDERS={
|
|
|
|
"GLES2_GLSL": env.Builder(
|
|
|
|
action=run_in_subprocess(gles_builders.build_gles2_headers), suffix="glsl.gen.h", src_suffix=".glsl"
|
|
|
|
)
|
|
|
|
}
|
|
|
|
)
|
2016-10-30 17:44:57 +00:00
|
|
|
|
2017-11-26 01:47:54 +00:00
|
|
|
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 + "')")
|
|
|
|
|
2020-09-19 14:39:11 +00:00
|
|
|
if env["vsproj"]:
|
|
|
|
env.vs_incs = []
|
|
|
|
env.vs_srcs = []
|
|
|
|
|
2020-03-30 06:28:32 +00:00
|
|
|
Export("env")
|
2016-10-30 17:44:57 +00:00
|
|
|
|
2016-10-30 17:57:40 +00:00
|
|
|
# build subdirs, the build order is dependent on link order.
|
2016-10-30 17:44:57 +00:00
|
|
|
|
|
|
|
SConscript("core/SCsub")
|
|
|
|
SConscript("servers/SCsub")
|
|
|
|
SConscript("scene/SCsub")
|
2017-03-05 13:21:25 +00:00
|
|
|
SConscript("editor/SCsub")
|
2016-10-30 17:44:57 +00:00
|
|
|
SConscript("drivers/SCsub")
|
|
|
|
|
2017-11-16 00:33:48 +00:00
|
|
|
SConscript("platform/SCsub")
|
2016-10-30 17:44:57 +00:00
|
|
|
SConscript("modules/SCsub")
|
|
|
|
SConscript("main/SCsub")
|
|
|
|
|
2016-10-31 23:24:30 +00:00
|
|
|
SConscript("platform/" + selected_platform + "/SCsub") # build selected platform
|
2016-10-30 17:44:57 +00:00
|
|
|
|
|
|
|
# Microsoft Visual Studio Project Generation
|
2020-03-30 06:28:32 +00:00
|
|
|
if env["vsproj"]:
|
|
|
|
env["CPPPATH"] = [Dir(path) for path in env["CPPPATH"]]
|
2017-08-28 15:17:26 +00:00
|
|
|
methods.generate_vs_project(env, GetOption("num_jobs"))
|
2017-11-18 17:09:18 +00:00
|
|
|
methods.generate_cpp_hint_file("cpp.hint")
|
2014-10-07 04:31:49 +00:00
|
|
|
|
2017-09-12 15:00:14 +00:00
|
|
|
# Check for the existence of headers
|
|
|
|
conf = Configure(env)
|
2020-03-30 06:28:32 +00:00
|
|
|
if "check_c_headers" in env:
|
2017-09-12 15:00:14 +00:00
|
|
|
for header in env["check_c_headers"]:
|
2020-03-30 06:28:32 +00:00
|
|
|
if conf.CheckCHeader(header[0]):
|
2018-03-02 19:51:29 +00:00
|
|
|
env.AppendUnique(CPPDEFINES=[header[1]])
|
2017-09-12 15:00:14 +00:00
|
|
|
|
2019-05-26 17:05:31 +00:00
|
|
|
elif selected_platform != "":
|
2019-07-17 09:25:57 +00:00
|
|
|
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")
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2016-10-30 17:44:57 +00:00
|
|
|
for x in platform_list:
|
2016-10-30 17:57:40 +00:00
|
|
|
print("\t" + x)
|
2019-07-17 09:25:57 +00:00
|
|
|
|
2019-05-26 17:05:31 +00:00
|
|
|
print("\nPlease run SCons again and select a valid platform: platform=<string>")
|
2017-07-08 09:39:07 +00:00
|
|
|
|
2019-07-17 09:25:57 +00:00
|
|
|
if selected_platform == "list":
|
|
|
|
# Exit early to suppress the rest of the built-in SCons messages
|
|
|
|
sys.exit(0)
|
|
|
|
else:
|
|
|
|
sys.exit(255)
|
|
|
|
|
2020-03-20 20:49:38 +00:00
|
|
|
# The following only makes sense when the 'env' is defined, and assumes it is.
|
2020-03-30 06:28:32 +00:00
|
|
|
if "env" in locals():
|
2020-03-30 14:35:13 +00:00
|
|
|
methods.show_progress(env)
|
2020-03-20 20:49:38 +00:00
|
|
|
# TODO: replace this with `env.Dump(format="json")`
|
|
|
|
# once we start requiring SCons 4.0 as min version.
|
|
|
|
methods.dump(env)
|