# Convert string to list of absolute paths (including expanding wildcard)

if isinstance(files, (str, bytes)):

# Keep SCons project-absolute path as they are (no wildcard support)

if files.startswith("#"):

if "*" in files:

print("ERROR: Wildcards can't be expanded in SCons project-absolute path: '{}'".format(files))

return

files = [files]

else:

# Exclude .gen.cpp files from globbing, to avoid including obsolete ones.

# They should instead be added manually.

skip_gen_cpp = "*" in files

dir_path = self.Dir(".").abspath

files = sorted(glob.glob(dir_path + "/" + files))

if skip_gen_cpp and not allow_gen:

files = [f for f in files if not f.endswith(".gen.cpp")]

# Add each path as compiled Object following environment (self) configuration

for path in files:

obj = self.Object(path)

if obj in sources:

print('WARNING: Object "{}" already included in environment sources.'.format(obj))

continue

section_path = os.path.abspath(subdir) + "/"

folders = []

folder = ""

for i in range(8):

folder = os.path.dirname(section_path)

folder = os.path.basename(folder)

if folder == base_folder_only:

break

folders += [folder]

section_path += "../"

section_path = os.path.abspath(section_path) + "/"

section_name = ""

for n in range(len(folders)):

# section_name += folders[len(folders) - n - 1] + " "

section_name += folders[len(folders) - n - 1]

if n != (len(folders) - 1):

section_name += "/"

if self["scu_build"] and isinstance(files, str):

if "*." not in files:

return False

# If the files are in a subdirectory, we want to create the scu gen

# files inside this subdirectory.

subdir = os.path.dirname(files)

if subdir != "":

subdir += "/"

section_name = _find_scu_section_name(subdir)

# if the section name is in the hash table?

# i.e. is it part of the SCU build?

global _scu_folders

if section_name not in (_scu_folders):

return False

# Add all the gen.cpp files in the SCU directory

add_source_files_orig(self, sources, subdir + "scu/scu_*.gen.cpp", True)

return True

if not add_source_files_scu(self, sources, files, allow_gen):

# Wraps the original function when scu build is not active.

add_source_files_orig(self, sources, files, allow_gen)

return False

# 'self' is the environment

if self.msvc:

# We have to remove existing warning level defines before appending /w,

# otherwise we get: "warning D9025 : overriding '/W3' with '/w'"

self["CCFLAGS"] = [x for x in self["CCFLAGS"] if not (x.startswith("/W") or x.startswith("/w"))]

self["CFLAGS"] = [x for x in self["CFLAGS"] if not (x.startswith("/W") or x.startswith("/w"))]

self["CXXFLAGS"] = [x for x in self["CXXFLAGS"] if not (x.startswith("/W") or x.startswith("/w"))]

self.AppendUnique(CCFLAGS=["/w"])

else:

# 'self' is the environment

if self["target"] == "template_release":

return

if self.msvc:

# We have to remove existing optimization level defines before appending /O2,

# otherwise we get: "warning D9025 : overriding '/0d' with '/02'"

self["CCFLAGS"] = [x for x in self["CCFLAGS"] if not x.startswith("/O")]

self["CFLAGS"] = [x for x in self["CFLAGS"] if not x.startswith("/O")]

self["CXXFLAGS"] = [x for x in self["CXXFLAGS"] if not x.startswith("/O")]

self.AppendUnique(CCFLAGS=["/O2"])

else:

build_name = "custom_build"

if os.getenv("BUILD_NAME") != None:

build_name = str(os.getenv("BUILD_NAME"))

if not silent:

print(f"Using custom build name: '{build_name}'.")

import version

version_info = {

"short_name": str(version.short_name),

"name": str(version.name),

"major": int(version.major),

"minor": int(version.minor),

"patch": int(version.patch),

"status": str(version.status),

"build": str(build_name),

"module_config": str(version.module_config) + module_version_string,

"website": str(version.website),

"docs_branch": str(version.docs),

}

# For dev snapshots (alpha, beta, RC, etc.) we do not commit status change to Git,

# so this define provides a way to override it without having to modify the source.

if os.getenv("GODOT_VERSION_STATUS") != None:

version_info["status"] = str(os.getenv("GODOT_VERSION_STATUS"))

if not silent:

print(f"Using version status '{version_info['status']}', overriding the original '{version.status}'.")

# Parse Git hash if we're in a Git repo.

githash = ""

gitfolder = ".git"

if os.path.isfile(".git"):

module_folder = open(".git", "r").readline().strip()

if module_folder.startswith("gitdir: "):

gitfolder = module_folder[8:]

if os.path.isfile(os.path.join(gitfolder, "HEAD")):

head = open(os.path.join(gitfolder, "HEAD"), "r", encoding="utf8").readline().strip()

if head.startswith("ref: "):

ref = head[5:]

# If this directory is a Git worktree instead of a root clone.

parts = gitfolder.split("/")

if len(parts) > 2 and parts[-2] == "worktrees":

gitfolder = "/".join(parts[0:-2])

head = os.path.join(gitfolder, ref)

packedrefs = os.path.join(gitfolder, "packed-refs")

if os.path.isfile(head):

githash = open(head, "r").readline().strip()

elif os.path.isfile(packedrefs):

# Git may pack refs into a single file. This code searches .git/packed-refs file for the current ref's hash.

# https://mirrors.edge.kernel.org/pub/software/scm/git/docs/git-pack-refs.html

for line in open(packedrefs, "r").read().splitlines():

if line.startswith("#"):

continue

(line_hash, line_ref) = line.split(" ")

if ref == line_ref:

githash = line_hash

break

else:

githash = head

version_info["git_hash"] = githash

version_info = get_version_info(module_version_string)

# NOTE: It is safe to generate these files here, since this is still executed serially.

f = open("core/version_generated.gen.h", "w")

f.write(

"""/* THIS FILE IS GENERATED DO NOT EDIT */

#ifndef VERSION_GENERATED_GEN_H

#define VERSION_GENERATED_GEN_H

#define VERSION_SHORT_NAME "{short_name}"

#define VERSION_NAME "{name}"

#define VERSION_MAJOR {major}

#define VERSION_MINOR {minor}

#define VERSION_PATCH {patch}

#define VERSION_STATUS "{status}"

#define VERSION_BUILD "{build}"

#define VERSION_MODULE_CONFIG "{module_config}"

#define VERSION_WEBSITE "{website}"

#define VERSION_DOCS_BRANCH "{docs_branch}"

#define VERSION_DOCS_URL "https://docs.godotengine.org/en/" VERSION_DOCS_BRANCH

#endif // VERSION_GENERATED_GEN_H

""".format(

**version_info

)

)

f.close()

fhash = open("core/version_hash.gen.cpp", "w")

fhash.write(

"""/* THIS FILE IS GENERATED DO NOT EDIT */

#include "core/version.h"

const char *const VERSION_HASH = "{git_hash}";

""".format(

**version_info

)

)

fs = open(fname, "r")

line = fs.readline()

while line:

if re.match(r"^\s*uniform", line):

res = re.match(r"uniform ([\d\w]*) ([\d\w]*)")

type = res.groups(1)

name = res.groups(2)

uniforms.append(name)

if type.find("texobj") != -1:

sizes.append(1)

else:

t = re.match(r"float(\d)x(\d)", type)

if t:

sizes.append(int(t.groups(1)) * int(t.groups(2)))

else:

t = re.match(r"float(\d)", type)

sizes.append(int(t.groups(1)))

if line.find("[branch]") != -1:

conditionals.append(name)

line = fs.readline()

"""We use `ARGUMENTS.get()` to check if options were manually overridden on the command line,

and SCons' _text2bool helper to convert them to booleans, otherwise they're handled as strings.

"""

from SCons.Script import ARGUMENTS

from SCons.Variables.BoolVariable import _text2bool

cmdline_val = ARGUMENTS.get(option)

if cmdline_val is not None:

return _text2bool(cmdline_val)

else:

"""Detects and collects a list of C++ modules at specified path

`search_path` - a directory path containing modules. The path may point to

a single module, which may have other nested modules. A module must have

"register_types.h", "SCsub", "config.py" files created to be detected.

`recursive` - if `True`, then all subdirectories are searched for modules as

specified by the `search_path`, otherwise collects all modules under the

`search_path` directory. If the `search_path` is a module, it is collected

in all cases.

Returns an `OrderedDict` with module names as keys, and directory paths as

values. If a path is relative, then it is a built-in module. If a path is

absolute, then it is a custom module collected outside of the engine source.

"""

modules = OrderedDict()

def add_module(path):

module_name = os.path.basename(path)

module_path = path.replace("\\", "/") # win32

modules[module_name] = module_path

def is_engine(path):

# Prevent recursively detecting modules in self and other

# Godot sources when using `custom_modules` build option.

version_path = os.path.join(path, "version.py")

if os.path.exists(version_path):

with open(version_path) as f:

if 'short_name = "godot"' in f.read():

return True

return False

def get_files(path):

files = glob.glob(os.path.join(path, "*"))

# Sort so that `register_module_types` does not change that often,

# and plugins are registered in alphabetic order as well.

files.sort()

return files

if not recursive:

if is_module(search_path):

add_module(search_path)

for path in get_files(search_path):

if is_engine(path):

continue

if is_module(path):

add_module(path)

else:

to_search = [search_path]

while to_search:

path = to_search.pop()

if is_module(path):

add_module(path)

for child in get_files(path):

if not os.path.isdir(child):

continue

if is_engine(child):

continue

to_search.insert(0, child)

if not os.path.isdir(path):

return False

must_exist = ["register_types.h", "SCsub", "config.py"]

for f in must_exist:

if not os.path.exists(os.path.join(path, f)):

return False

f = open("core/disabled_classes.gen.h", "w")

f.write("/* THIS FILE IS GENERATED DO NOT EDIT */\n")

f.write("#ifndef DISABLED_CLASSES_GEN_H\n")

f.write("#define DISABLED_CLASSES_GEN_H\n\n")

for c in class_list:

cs = c.strip()

if cs != "":

f.write("#define ClassDB_Disable_" + cs + " 1\n")

includes_cpp = ""

initialize_cpp = ""

uninitialize_cpp = ""

for name, path in modules.items():

try:

with open(os.path.join(path, "register_types.h")):

includes_cpp += '#include "' + path + '/register_types.h"\n'

initialize_cpp += "#ifdef MODULE_" + name.upper() + "_ENABLED\n"

initialize_cpp += "\tinitialize_" + name + "_module(p_level);\n"

initialize_cpp += "#endif\n"

uninitialize_cpp += "#ifdef MODULE_" + name.upper() + "_ENABLED\n"

uninitialize_cpp += "\tuninitialize_" + name + "_module(p_level);\n"

uninitialize_cpp += "#endif\n"

except OSError:

pass

modules_cpp = """// register_module_types.gen.cpp

/* THIS FILE IS GENERATED DO NOT EDIT */

#include "register_module_types.h"

#include "modules/modules_enabled.gen.h"

%s

void initialize_modules(ModuleInitializationLevel p_level) {

%s

}

void uninitialize_modules(ModuleInitializationLevel p_level) {

%s

}

""" % (

includes_cpp,

initialize_cpp,

uninitialize_cpp,

)

# NOTE: It is safe to generate this file here, since this is still executed serially

with open("modules/register_module_types.gen.cpp", "w") as f:

if not path:

return path

path = os.path.realpath(os.path.expanduser(os.path.expandvars(path)))

err_msg = "Build option 'custom_modules' must %s"

if not os.path.isdir(path):

raise ValueError(err_msg % "point to an existing directory.")

if path == os.path.realpath("modules"):

raise ValueError(err_msg % "be a directory other than built-in `modules` directory.")

"""

Adds dependencies for a given module.

Meant to be used in module `can_build` methods.

"""

if module not in self.module_dependencies:

self.module_dependencies[module] = [[], []]

if optional:

self.module_dependencies[module][1].extend(dependencies)

else:

"""

Checks if module dependencies are enabled for a given module,

and prints a warning if they aren't.

Meant to be used in module `can_build` methods.

Returns a boolean (True if dependencies are satisfied).

"""

missing_deps = []

required_deps = self.module_dependencies[module][0] if module in self.module_dependencies else []

for dep in required_deps:

opt = "module_{}_enabled".format(dep)

if not opt in self or not self[opt]:

missing_deps.append(dep)

if missing_deps != []:

print(

"Disabling '{}' module as the following dependencies are not satisfied: {}".format(

module, ", ".join(missing_deps)

)

)

return False

else:

out = OrderedDict()

deps = {k: v[0] + list(filter(lambda x: x in env.module_list, v[1])) for k, v in env.module_dependencies.items()}

frontier = list(env.module_list.keys())

explored = []

while len(frontier):

cur = frontier.pop()

deps_list = deps[cur] if cur in deps else []

if len(deps_list) and any([d not in explored for d in deps_list]):

# Will explore later, after its dependencies

frontier.insert(0, cur)

continue

explored.append(cur)

for k in explored:

if os.name != "nt":

return # not needed, only for windows

# On Windows, due to the limited command line length, when creating a static library

# from a very high number of objects SCons will invoke "ar" once per object file;

# that makes object files with same names to be overwritten so the last wins and

# the library loses symbols defined by overwritten objects.

# By enabling quick append instead of the default mode (replacing), libraries will

# got built correctly regardless the invocation strategy.

# Furthermore, since SCons will rebuild the library from scratch when an object file

# changes, no multiple versions of the same object file will be present.

self.Replace(ARFLAGS="q")

def mySubProcess(cmdline, env):

startupinfo = subprocess.STARTUPINFO()

startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW

popen_args = {

"stdin": subprocess.PIPE,

"stdout": subprocess.PIPE,

"stderr": subprocess.PIPE,

"startupinfo": startupinfo,

"shell": False,

"env": env,

}

if sys.version_info >= (3, 7, 0):

popen_args["text"] = True

proc = subprocess.Popen(cmdline, **popen_args)

_, err = proc.communicate()

rv = proc.wait()

if rv:

print("=====")

print(err)

print("=====")

return rv

def mySpawn(sh, escape, cmd, args, env):

newargs = " ".join(args[1:])

cmdline = cmd + " " + newargs

rv = 0

env = {str(key): str(value) for key, value in iter(env.items())}

if len(cmdline) > 32000 and cmd.endswith("ar"):

cmdline = cmd + " " + args[1] + " " + args[2] + " "

for i in range(3, len(args)):

rv = mySubProcess(cmdline + args[i], env)

if rv:

break

else:

rv = mySubProcess(cmdline, env)

return rv

colors = {}

# Colors are disabled in non-TTY environments such as pipes. This means

# that if output is redirected to a file, it will not contain color codes

if sys.stdout.isatty():

colors["blue"] = "\033[0;94m"

colors["bold_blue"] = "\033[1;94m"

colors["reset"] = "\033[0m"

else:

colors["blue"] = ""

colors["bold_blue"] = ""

colors["reset"] = ""

# There is a space before "..." to ensure that source file names can be

# Ctrl + clicked in the VS Code terminal.

compile_source_message = "{}Compiling {}$SOURCE{} ...{}".format(

colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]

)

java_compile_source_message = "{}Compiling {}$SOURCE{} ...{}".format(

colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]

)

compile_shared_source_message = "{}Compiling shared {}$SOURCE{} ...{}".format(

colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]

)

link_program_message = "{}Linking Program {}$TARGET{} ...{}".format(

colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]

)

link_library_message = "{}Linking Static Library {}$TARGET{} ...{}".format(

colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]

)

ranlib_library_message = "{}Ranlib Library {}$TARGET{} ...{}".format(

colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]

)

link_shared_library_message = "{}Linking Shared Library {}$TARGET{} ...{}".format(

colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]

)

java_library_message = "{}Creating Java Archive {}$TARGET{} ...{}".format(

colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]

)

env.Append(CXXCOMSTR=[compile_source_message])

env.Append(CCCOMSTR=[compile_source_message])

env.Append(SHCCCOMSTR=[compile_shared_source_message])

env.Append(SHCXXCOMSTR=[compile_shared_source_message])

env.Append(ARCOMSTR=[link_library_message])

env.Append(RANLIBCOMSTR=[ranlib_library_message])

env.Append(SHLINKCOMSTR=[link_shared_library_message])

env.Append(LINKCOMSTR=[link_program_message])

env.Append(JARCOMSTR=[java_library_message])

# tools_env is the variable scons uses to call tools that execute tasks, SCons's env['ENV'] that executes tasks...

# (see the SCons documentation for more information on what it does)...

# in order for this function to be well encapsulated i choose to force it to receive SCons's TOOLS env (env['ENV']

# and not scons setup environment (env)... so make sure you call the right environment on it or it will fail to detect

# the proper vc version that will be called

# There is no flag to give to visual c compilers to set the architecture, i.e. scons arch argument (x86_32, x86_64, arm64, etc.).

# There are many different cl.exe files that are run, and each one compiles & links to a different architecture

# As far as I know, the only way to figure out what compiler will be run when Scons calls cl.exe via Program()

# is to check the PATH variable and figure out which one will be called first. Code below does that and returns:

# the following string values:

# "" Compiler not detected

# "amd64" Native 64 bit compiler

# "amd64_x86" 64 bit Cross Compiler for 32 bit

# "x86" Native 32 bit compiler

# "x86_amd64" 32 bit Cross Compiler for 64 bit

# There are other architectures, but Godot does not support them currently, so this function does not detect arm/amd64_arm

# and similar architectures/compilers

# Set chosen compiler to "not detected"

vc_chosen_compiler_index = -1

vc_chosen_compiler_str = ""

# Start with Pre VS 2017 checks which uses VCINSTALLDIR:

if "VCINSTALLDIR" in tools_env:

# print("Checking VCINSTALLDIR")

# find() works with -1 so big ifs below are needed... the simplest solution, in fact

# First test if amd64 and amd64_x86 compilers are present in the path

vc_amd64_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN\\amd64;")

if vc_amd64_compiler_detection_index > -1:

vc_chosen_compiler_index = vc_amd64_compiler_detection_index

vc_chosen_compiler_str = "amd64"

vc_amd64_x86_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN\\amd64_x86;")

if vc_amd64_x86_compiler_detection_index > -1 and (

vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_amd64_x86_compiler_detection_index

):

vc_chosen_compiler_index = vc_amd64_x86_compiler_detection_index

vc_chosen_compiler_str = "amd64_x86"

# Now check the 32 bit compilers

vc_x86_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN;")

if vc_x86_compiler_detection_index > -1 and (

vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_x86_compiler_detection_index

):

vc_chosen_compiler_index = vc_x86_compiler_detection_index

vc_chosen_compiler_str = "x86"

vc_x86_amd64_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN\\x86_amd64;")

if vc_x86_amd64_compiler_detection_index > -1 and (

vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_x86_amd64_compiler_detection_index

):

vc_chosen_compiler_index = vc_x86_amd64_compiler_detection_index

vc_chosen_compiler_str = "x86_amd64"

# and for VS 2017 and newer we check VCTOOLSINSTALLDIR:

if "VCTOOLSINSTALLDIR" in tools_env:

# Newer versions have a different path available

vc_amd64_compiler_detection_index = (

tools_env["PATH"].upper().find(tools_env["VCTOOLSINSTALLDIR"].upper() + "BIN\\HOSTX64\\X64;")

)

if vc_amd64_compiler_detection_index > -1:

vc_chosen_compiler_index = vc_amd64_compiler_detection_index

vc_chosen_compiler_str = "amd64"

vc_amd64_x86_compiler_detection_index = (

tools_env["PATH"].upper().find(tools_env["VCTOOLSINSTALLDIR"].upper() + "BIN\\HOSTX64\\X86;")

)

if vc_amd64_x86_compiler_detection_index > -1 and (

vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_amd64_x86_compiler_detection_index

):

vc_chosen_compiler_index = vc_amd64_x86_compiler_detection_index

vc_chosen_compiler_str = "amd64_x86"

vc_x86_compiler_detection_index = (

tools_env["PATH"].upper().find(tools_env["VCTOOLSINSTALLDIR"].upper() + "BIN\\HOSTX86\\X86;")

)

if vc_x86_compiler_detection_index > -1 and (

vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_x86_compiler_detection_index

):

vc_chosen_compiler_index = vc_x86_compiler_detection_index

vc_chosen_compiler_str = "x86"

vc_x86_amd64_compiler_detection_index = (

tools_env["PATH"].upper().find(tools_env["VCTOOLSINSTALLDIR"].upper() + "BIN\\HOSTX86\\X64;")

)

if vc_x86_amd64_compiler_detection_index > -1 and (

vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_x86_amd64_compiler_detection_index

):

vc_chosen_compiler_str = "x86_amd64"

from SCons.Tool.MSCommon.vc import get_default_version, get_host_target, find_batch_file, find_vc_pdir

# Syntax changed in SCons 4.4.0.

from SCons import __version__ as scons_raw_version

scons_ver = env._get_major_minor_revision(scons_raw_version)

msvc_version = get_default_version(env)

if scons_ver >= (4, 4, 0):

(host_platform, target_platform, _) = get_host_target(env, msvc_version)

else:

(host_platform, target_platform, _) = get_host_target(env)

if scons_ver < (4, 6, 0):

return find_batch_file(env, msvc_version, host_platform, target_platform)[0]

# Scons 4.6.0+ removed passing env, so we need to get the product_dir ourselves first,

# then pass that as the last param instead of env as the first param as before.

# We should investigate if we can avoid relying on SCons internals here.

product_dir = find_vc_pdir(env, msvc_version)

if os.path.isfile(filename):

# Don't overwrite an existing hint file since the user may have customized it.

pass

else:

try:

with open(filename, "w") as fd:

fd.write("#define GDCLASS(m_class, m_inherits)\n")

except OSError:

from SCons import Node

from SCons.Script import Glob

results = []

for f in Glob(str(node) + "/*", source=True):

if type(f) is Node.FS.Dir:

results += glob_recursive(pattern, f)

results += Glob(str(node) + "/" + pattern, source=True)

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 += [basename + ".h"]

elif os.path.isfile(basename + ".hpp"):

env.vs_incs += [basename + ".hpp"]

if os.path.isfile(basename + ".c"):

env.vs_srcs += [basename + ".c"]

elif os.path.isfile(basename + ".cpp"):

from SCons.Script import Action

from platform_methods import run_in_subprocess

output_print = short_message if not env["verbose"] else ""

if not subprocess:

return Action(function, output_print)

else:

sdk_name = ""

if platform == "macos":

sdk_name = "macosx"

var_name = "MACOS_SDK_PATH"

elif platform == "ios":

sdk_name = "iphoneos"

var_name = "IOS_SDK_PATH"

elif platform == "iossimulator":

sdk_name = "iphonesimulator"

var_name = "IOS_SDK_PATH"

else:

raise Exception("Invalid platform argument passed to detect_darwin_sdk_path")

if not env[var_name]:

try:

sdk_path = subprocess.check_output(["xcrun", "--sdk", sdk_name, "--show-sdk-path"]).strip().decode("utf-8")

if sdk_path:

env[var_name] = sdk_path

except (subprocess.CalledProcessError, OSError):

print("Failed to find SDK path while running xcrun --sdk {} --show-sdk-path.".format(sdk_name))

if not using_clang(env):

return False

try:

version = subprocess.check_output([env.subst(env["CXX"]), "--version"]).strip().decode("utf-8")

except (subprocess.CalledProcessError, OSError):

print("Couldn't parse CXX environment variable to infer compiler version.")

return False

"""

Returns a dictionary with various version information:

- major, minor, patch: Version following semantic versioning system

- metadata1, metadata2: Extra information

- date: Date of the build

"""

ret = {

"major": -1,

"minor": -1,

"patch": -1,

"metadata1": None,

"metadata2": None,

"date": None,

"apple_major": -1,

"apple_minor": -1,

"apple_patch1": -1,

"apple_patch2": -1,

"apple_patch3": -1,

}

if not env.msvc:

# Not using -dumpversion as some GCC distros only return major, and

# Clang used to return hardcoded 4.2.1: # https://reviews.llvm.org/D56803

try:

version = subprocess.check_output([env.subst(env["CXX"]), "--version"]).strip().decode("utf-8")

except (subprocess.CalledProcessError, OSError):

print("Couldn't parse CXX environment variable to infer compiler version.")

return ret

else:

# TODO: Implement for MSVC

return ret

match = re.search(

r"(?:(?<=version )|(?<=\) )|(?<=^))"

r"(?P<major>\d+)"

r"(?:\.(?P<minor>\d*))?"

r"(?:\.(?P<patch>\d*))?"

r"(?:-(?P<metadata1>[0-9a-zA-Z-]*))?"

r"(?:\+(?P<metadata2>[0-9a-zA-Z-]*))?"

r"(?: (?P<date>[0-9]{8}|[0-9]{6})(?![0-9a-zA-Z]))?",

version,

)

if match is not None:

for key, value in match.groupdict().items():

if value is not None:

ret[key] = value

match_apple = re.search(

r"(?:(?<=clang-)|(?<=\) )|(?<=^))"

r"(?P<apple_major>\d+)"

r"(?:\.(?P<apple_minor>\d*))?"

r"(?:\.(?P<apple_patch1>\d*))?"

r"(?:\.(?P<apple_patch2>\d*))?"

r"(?:\.(?P<apple_patch3>\d*))?",

version,

)

if match_apple is not None:

for key, value in match_apple.groupdict().items():

if value is not None:

ret[key] = value

# Transform semantic versioning to integers

for key in [

"major",

"minor",

"patch",

"apple_major",

"apple_minor",

"apple_patch1",

"apple_patch2",

"apple_patch3",

]:

ret[key] = int(ret[key] or -1)

import sys

from SCons.Script import Progress, Command, AlwaysBuild

screen = sys.stdout

# Progress reporting is not available in non-TTY environments since it

# messes with the output (for example, when writing to a file)

show_progress = env["progress"] and sys.stdout.isatty()

node_count = 0

node_count_max = 0

node_count_interval = 1

node_count_fname = str(env.Dir("#")) + "/.scons_node_count"

import time, math

class cache_progress:

# The default is 1 GB cache and 12 hours half life

def __init__(self, path=None, limit=1073741824, half_life=43200):

self.path = path

self.limit = limit

self.exponent_scale = math.log(2) / half_life

if env["verbose"] and path != None:

screen.write(

"Current cache limit is {} (used: {})\n".format(

self.convert_size(limit), self.convert_size(self.get_size(path))

)

)

self.delete(self.file_list())

def __call__(self, node, *args, **kw):

nonlocal node_count, node_count_max, node_count_interval, node_count_fname, show_progress

if show_progress:

# Print the progress percentage

node_count += node_count_interval

if node_count_max > 0 and node_count <= node_count_max:

screen.write("\r[%3d%%] " % (node_count * 100 / node_count_max))

screen.flush()

elif node_count_max > 0 and node_count > node_count_max:

screen.write("\r[100%] ")

screen.flush()

else:

screen.write("\r[Initial build] ")

screen.flush()

def delete(self, files):

if len(files) == 0:

return

if env["verbose"]:

# Utter something

screen.write("\rPurging %d %s from cache...\n" % (len(files), len(files) > 1 and "files" or "file"))

[os.remove(f) for f in files]

def file_list(self):

if self.path is None:

# Nothing to do

return []

# Gather a list of (filename, (size, atime)) within the

# cache directory

file_stat = [(x, os.stat(x)[6:8]) for x in glob.glob(os.path.join(self.path, "*", "*"))]