methods.py 32 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855
  1. import os
  2. import re
  3. import glob
  4. import subprocess
  5. from collections import OrderedDict
  6. from compat import iteritems, isbasestring, open_utf8, decode_utf8, qualname
  7. def add_source_files(self, sources, files, warn_duplicates=True):
  8. # Convert string to list of absolute paths (including expanding wildcard)
  9. if isbasestring(files):
  10. # Keep SCons project-absolute path as they are (no wildcard support)
  11. if files.startswith("#"):
  12. if "*" in files:
  13. print("ERROR: Wildcards can't be expanded in SCons project-absolute path: '{}'".format(files))
  14. return
  15. files = [files]
  16. else:
  17. dir_path = self.Dir(".").abspath
  18. files = sorted(glob.glob(dir_path + "/" + files))
  19. # Add each path as compiled Object following environment (self) configuration
  20. for path in files:
  21. obj = self.Object(path)
  22. if obj in sources:
  23. if warn_duplicates:
  24. print('WARNING: Object "{}" already included in environment sources.'.format(obj))
  25. else:
  26. continue
  27. sources.append(obj)
  28. def disable_warnings(self):
  29. # 'self' is the environment
  30. if self.msvc:
  31. # We have to remove existing warning level defines before appending /w,
  32. # otherwise we get: "warning D9025 : overriding '/W3' with '/w'"
  33. warn_flags = ["/Wall", "/W4", "/W3", "/W2", "/W1", "/WX"]
  34. self.Append(CCFLAGS=["/w"])
  35. self.Append(CFLAGS=["/w"])
  36. self.Append(CXXFLAGS=["/w"])
  37. self["CCFLAGS"] = [x for x in self["CCFLAGS"] if not x in warn_flags]
  38. self["CFLAGS"] = [x for x in self["CFLAGS"] if not x in warn_flags]
  39. self["CXXFLAGS"] = [x for x in self["CXXFLAGS"] if not x in warn_flags]
  40. else:
  41. self.Append(CCFLAGS=["-w"])
  42. self.Append(CFLAGS=["-w"])
  43. self.Append(CXXFLAGS=["-w"])
  44. def add_module_version_string(self, s):
  45. self.module_version_string += "." + s
  46. def update_version(module_version_string=""):
  47. build_name = "custom_build"
  48. if os.getenv("BUILD_NAME") != None:
  49. build_name = os.getenv("BUILD_NAME")
  50. print("Using custom build name: " + build_name)
  51. import version
  52. # NOTE: It is safe to generate this file here, since this is still executed serially
  53. f = open("core/version_generated.gen.h", "w")
  54. f.write('#define VERSION_SHORT_NAME "' + str(version.short_name) + '"\n')
  55. f.write('#define VERSION_NAME "' + str(version.name) + '"\n')
  56. f.write("#define VERSION_MAJOR " + str(version.major) + "\n")
  57. f.write("#define VERSION_MINOR " + str(version.minor) + "\n")
  58. f.write("#define VERSION_PATCH " + str(version.patch) + "\n")
  59. f.write('#define VERSION_STATUS "' + str(version.status) + '"\n')
  60. f.write('#define VERSION_BUILD "' + str(build_name) + '"\n')
  61. f.write('#define VERSION_MODULE_CONFIG "' + str(version.module_config) + module_version_string + '"\n')
  62. f.write("#define VERSION_YEAR " + str(version.year) + "\n")
  63. f.write('#define VERSION_WEBSITE "' + str(version.website) + '"\n')
  64. f.close()
  65. # NOTE: It is safe to generate this file here, since this is still executed serially
  66. fhash = open("core/version_hash.gen.h", "w")
  67. githash = ""
  68. gitfolder = ".git"
  69. if os.path.isfile(".git"):
  70. module_folder = open(".git", "r").readline().strip()
  71. if module_folder.startswith("gitdir: "):
  72. gitfolder = module_folder[8:]
  73. if os.path.isfile(os.path.join(gitfolder, "HEAD")):
  74. head = open_utf8(os.path.join(gitfolder, "HEAD"), "r").readline().strip()
  75. if head.startswith("ref: "):
  76. head = os.path.join(gitfolder, head[5:])
  77. if os.path.isfile(head):
  78. githash = open(head, "r").readline().strip()
  79. else:
  80. githash = head
  81. fhash.write('#define VERSION_HASH "' + githash + '"')
  82. fhash.close()
  83. def parse_cg_file(fname, uniforms, sizes, conditionals):
  84. fs = open(fname, "r")
  85. line = fs.readline()
  86. while line:
  87. if re.match(r"^\s*uniform", line):
  88. res = re.match(r"uniform ([\d\w]*) ([\d\w]*)")
  89. type = res.groups(1)
  90. name = res.groups(2)
  91. uniforms.append(name)
  92. if type.find("texobj") != -1:
  93. sizes.append(1)
  94. else:
  95. t = re.match(r"float(\d)x(\d)", type)
  96. if t:
  97. sizes.append(int(t.groups(1)) * int(t.groups(2)))
  98. else:
  99. t = re.match(r"float(\d)", type)
  100. sizes.append(int(t.groups(1)))
  101. if line.find("[branch]") != -1:
  102. conditionals.append(name)
  103. line = fs.readline()
  104. fs.close()
  105. def detect_modules(at_path):
  106. module_list = OrderedDict() # name : path
  107. modules_glob = os.path.join(at_path, "*")
  108. files = glob.glob(modules_glob)
  109. files.sort() # so register_module_types does not change that often, and also plugins are registered in alphabetic order
  110. for x in files:
  111. if not is_module(x):
  112. continue
  113. name = os.path.basename(x)
  114. path = x.replace("\\", "/") # win32
  115. module_list[name] = path
  116. return module_list
  117. def is_module(path):
  118. return os.path.isdir(path) and os.path.exists(os.path.join(path, "SCsub"))
  119. def write_modules(module_list):
  120. includes_cpp = ""
  121. register_cpp = ""
  122. unregister_cpp = ""
  123. for name, path in module_list.items():
  124. try:
  125. with open(os.path.join(path, "register_types.h")):
  126. includes_cpp += '#include "' + path + '/register_types.h"\n'
  127. register_cpp += "#ifdef MODULE_" + name.upper() + "_ENABLED\n"
  128. register_cpp += "\tregister_" + name + "_types();\n"
  129. register_cpp += "#endif\n"
  130. unregister_cpp += "#ifdef MODULE_" + name.upper() + "_ENABLED\n"
  131. unregister_cpp += "\tunregister_" + name + "_types();\n"
  132. unregister_cpp += "#endif\n"
  133. except IOError:
  134. pass
  135. modules_cpp = (
  136. """
  137. // modules.cpp - THIS FILE IS GENERATED, DO NOT EDIT!!!!!!!
  138. #include "register_module_types.h"
  139. """
  140. + includes_cpp
  141. + """
  142. void register_module_types() {
  143. """
  144. + register_cpp
  145. + """
  146. }
  147. void unregister_module_types() {
  148. """
  149. + unregister_cpp
  150. + """
  151. }
  152. """
  153. )
  154. # NOTE: It is safe to generate this file here, since this is still executed serially
  155. with open("modules/register_module_types.gen.cpp", "w") as f:
  156. f.write(modules_cpp)
  157. def convert_custom_modules_path(path):
  158. if not path:
  159. return path
  160. path = os.path.realpath(os.path.expanduser(os.path.expandvars(path)))
  161. err_msg = "Build option 'custom_modules' must %s"
  162. if not os.path.isdir(path):
  163. raise ValueError(err_msg % "point to an existing directory.")
  164. if path == os.path.realpath("modules"):
  165. raise ValueError(err_msg % "be a directory other than built-in `modules` directory.")
  166. if is_module(path):
  167. raise ValueError(err_msg % "point to a directory with modules, not a single module.")
  168. return path
  169. def disable_module(self):
  170. self.disabled_modules.append(self.current_module)
  171. def use_windows_spawn_fix(self, platform=None):
  172. if os.name != "nt":
  173. return # not needed, only for windows
  174. # On Windows, due to the limited command line length, when creating a static library
  175. # from a very high number of objects SCons will invoke "ar" once per object file;
  176. # that makes object files with same names to be overwritten so the last wins and
  177. # the library looses symbols defined by overwritten objects.
  178. # By enabling quick append instead of the default mode (replacing), libraries will
  179. # got built correctly regardless the invocation strategy.
  180. # Furthermore, since SCons will rebuild the library from scratch when an object file
  181. # changes, no multiple versions of the same object file will be present.
  182. self.Replace(ARFLAGS="q")
  183. def mySubProcess(cmdline, env):
  184. startupinfo = subprocess.STARTUPINFO()
  185. startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
  186. proc = subprocess.Popen(
  187. cmdline,
  188. stdin=subprocess.PIPE,
  189. stdout=subprocess.PIPE,
  190. stderr=subprocess.PIPE,
  191. startupinfo=startupinfo,
  192. shell=False,
  193. env=env,
  194. )
  195. _, err = proc.communicate()
  196. rv = proc.wait()
  197. if rv:
  198. print("=====")
  199. print(err)
  200. print("=====")
  201. return rv
  202. def mySpawn(sh, escape, cmd, args, env):
  203. newargs = " ".join(args[1:])
  204. cmdline = cmd + " " + newargs
  205. rv = 0
  206. env = {str(key): str(value) for key, value in iteritems(env)}
  207. if len(cmdline) > 32000 and cmd.endswith("ar"):
  208. cmdline = cmd + " " + args[1] + " " + args[2] + " "
  209. for i in range(3, len(args)):
  210. rv = mySubProcess(cmdline + args[i], env)
  211. if rv:
  212. break
  213. else:
  214. rv = mySubProcess(cmdline, env)
  215. return rv
  216. self["SPAWN"] = mySpawn
  217. def split_lib(self, libname, src_list=None, env_lib=None):
  218. env = self
  219. num = 0
  220. cur_base = ""
  221. max_src = 64
  222. list = []
  223. lib_list = []
  224. if src_list is None:
  225. src_list = getattr(env, libname + "_sources")
  226. if type(env_lib) == type(None):
  227. env_lib = env
  228. for f in src_list:
  229. fname = ""
  230. if type(f) == type(""):
  231. fname = env.File(f).path
  232. else:
  233. fname = env.File(f)[0].path
  234. fname = fname.replace("\\", "/")
  235. base = "/".join(fname.split("/")[:2])
  236. if base != cur_base and len(list) > max_src:
  237. if num > 0:
  238. lib = env_lib.add_library(libname + str(num), list)
  239. lib_list.append(lib)
  240. list = []
  241. num = num + 1
  242. cur_base = base
  243. list.append(f)
  244. lib = env_lib.add_library(libname + str(num), list)
  245. lib_list.append(lib)
  246. lib_base = []
  247. env_lib.add_source_files(lib_base, "*.cpp")
  248. lib = env_lib.add_library(libname, lib_base)
  249. lib_list.insert(0, lib)
  250. env.Prepend(LIBS=lib_list)
  251. # When we split modules into arbitrary chunks, we end up with linking issues
  252. # due to symbol dependencies split over several libs, which may not be linked
  253. # in the required order. We use --start-group and --end-group to tell the
  254. # linker that those archives should be searched repeatedly to resolve all
  255. # undefined references.
  256. # As SCons doesn't give us much control over how inserting libs in LIBS
  257. # impacts the linker call, we need to hack our way into the linking commands
  258. # LINKCOM and SHLINKCOM to set those flags.
  259. if "-Wl,--start-group" in env["LINKCOM"] and "-Wl,--start-group" in env["SHLINKCOM"]:
  260. # Already added by a previous call, skip.
  261. return
  262. env["LINKCOM"] = str(env["LINKCOM"]).replace("$_LIBFLAGS", "-Wl,--start-group $_LIBFLAGS -Wl,--end-group")
  263. env["SHLINKCOM"] = str(env["LINKCOM"]).replace("$_LIBFLAGS", "-Wl,--start-group $_LIBFLAGS -Wl,--end-group")
  264. def save_active_platforms(apnames, ap):
  265. for x in ap:
  266. names = ["logo"]
  267. if os.path.isfile(x + "/run_icon.png"):
  268. names.append("run_icon")
  269. for name in names:
  270. pngf = open(x + "/" + name + ".png", "rb")
  271. b = pngf.read(1)
  272. str = " /* AUTOGENERATED FILE, DO NOT EDIT */ \n"
  273. str += " static const unsigned char _" + x[9:] + "_" + name + "[]={"
  274. while len(b) == 1:
  275. str += hex(ord(b))
  276. b = pngf.read(1)
  277. if len(b) == 1:
  278. str += ","
  279. str += "};\n"
  280. pngf.close()
  281. # NOTE: It is safe to generate this file here, since this is still executed serially
  282. wf = x + "/" + name + ".gen.h"
  283. with open(wf, "w") as pngw:
  284. pngw.write(str)
  285. def no_verbose(sys, env):
  286. colors = {}
  287. # Colors are disabled in non-TTY environments such as pipes. This means
  288. # that if output is redirected to a file, it will not contain color codes
  289. if sys.stdout.isatty():
  290. colors["cyan"] = "\033[96m"
  291. colors["purple"] = "\033[95m"
  292. colors["blue"] = "\033[94m"
  293. colors["green"] = "\033[92m"
  294. colors["yellow"] = "\033[93m"
  295. colors["red"] = "\033[91m"
  296. colors["end"] = "\033[0m"
  297. else:
  298. colors["cyan"] = ""
  299. colors["purple"] = ""
  300. colors["blue"] = ""
  301. colors["green"] = ""
  302. colors["yellow"] = ""
  303. colors["red"] = ""
  304. colors["end"] = ""
  305. compile_source_message = "%sCompiling %s==> %s$SOURCE%s" % (
  306. colors["blue"],
  307. colors["purple"],
  308. colors["yellow"],
  309. colors["end"],
  310. )
  311. java_compile_source_message = "%sCompiling %s==> %s$SOURCE%s" % (
  312. colors["blue"],
  313. colors["purple"],
  314. colors["yellow"],
  315. colors["end"],
  316. )
  317. compile_shared_source_message = "%sCompiling shared %s==> %s$SOURCE%s" % (
  318. colors["blue"],
  319. colors["purple"],
  320. colors["yellow"],
  321. colors["end"],
  322. )
  323. link_program_message = "%sLinking Program %s==> %s$TARGET%s" % (
  324. colors["red"],
  325. colors["purple"],
  326. colors["yellow"],
  327. colors["end"],
  328. )
  329. link_library_message = "%sLinking Static Library %s==> %s$TARGET%s" % (
  330. colors["red"],
  331. colors["purple"],
  332. colors["yellow"],
  333. colors["end"],
  334. )
  335. ranlib_library_message = "%sRanlib Library %s==> %s$TARGET%s" % (
  336. colors["red"],
  337. colors["purple"],
  338. colors["yellow"],
  339. colors["end"],
  340. )
  341. link_shared_library_message = "%sLinking Shared Library %s==> %s$TARGET%s" % (
  342. colors["red"],
  343. colors["purple"],
  344. colors["yellow"],
  345. colors["end"],
  346. )
  347. java_library_message = "%sCreating Java Archive %s==> %s$TARGET%s" % (
  348. colors["red"],
  349. colors["purple"],
  350. colors["yellow"],
  351. colors["end"],
  352. )
  353. env.Append(CXXCOMSTR=[compile_source_message])
  354. env.Append(CCCOMSTR=[compile_source_message])
  355. env.Append(SHCCCOMSTR=[compile_shared_source_message])
  356. env.Append(SHCXXCOMSTR=[compile_shared_source_message])
  357. env.Append(ARCOMSTR=[link_library_message])
  358. env.Append(RANLIBCOMSTR=[ranlib_library_message])
  359. env.Append(SHLINKCOMSTR=[link_shared_library_message])
  360. env.Append(LINKCOMSTR=[link_program_message])
  361. env.Append(JARCOMSTR=[java_library_message])
  362. env.Append(JAVACCOMSTR=[java_compile_source_message])
  363. def detect_visual_c_compiler_version(tools_env):
  364. # tools_env is the variable scons uses to call tools that execute tasks, SCons's env['ENV'] that executes tasks...
  365. # (see the SCons documentation for more information on what it does)...
  366. # in order for this function to be well encapsulated i choose to force it to receive SCons's TOOLS env (env['ENV']
  367. # and not scons setup environment (env)... so make sure you call the right environment on it or it will fail to detect
  368. # the proper vc version that will be called
  369. # There is no flag to give to visual c compilers to set the architecture, ie scons bits argument (32,64,ARM etc)
  370. # There are many different cl.exe files that are run, and each one compiles & links to a different architecture
  371. # As far as I know, the only way to figure out what compiler will be run when Scons calls cl.exe via Program()
  372. # is to check the PATH variable and figure out which one will be called first. Code below does that and returns:
  373. # the following string values:
  374. # "" Compiler not detected
  375. # "amd64" Native 64 bit compiler
  376. # "amd64_x86" 64 bit Cross Compiler for 32 bit
  377. # "x86" Native 32 bit compiler
  378. # "x86_amd64" 32 bit Cross Compiler for 64 bit
  379. # There are other architectures, but Godot does not support them currently, so this function does not detect arm/amd64_arm
  380. # and similar architectures/compilers
  381. # Set chosen compiler to "not detected"
  382. vc_chosen_compiler_index = -1
  383. vc_chosen_compiler_str = ""
  384. # Start with Pre VS 2017 checks which uses VCINSTALLDIR:
  385. if "VCINSTALLDIR" in tools_env:
  386. # print("Checking VCINSTALLDIR")
  387. # find() works with -1 so big ifs below are needed... the simplest solution, in fact
  388. # First test if amd64 and amd64_x86 compilers are present in the path
  389. vc_amd64_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN\\amd64;")
  390. if vc_amd64_compiler_detection_index > -1:
  391. vc_chosen_compiler_index = vc_amd64_compiler_detection_index
  392. vc_chosen_compiler_str = "amd64"
  393. vc_amd64_x86_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN\\amd64_x86;")
  394. if vc_amd64_x86_compiler_detection_index > -1 and (
  395. vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_amd64_x86_compiler_detection_index
  396. ):
  397. vc_chosen_compiler_index = vc_amd64_x86_compiler_detection_index
  398. vc_chosen_compiler_str = "amd64_x86"
  399. # Now check the 32 bit compilers
  400. vc_x86_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN;")
  401. if vc_x86_compiler_detection_index > -1 and (
  402. vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_x86_compiler_detection_index
  403. ):
  404. vc_chosen_compiler_index = vc_x86_compiler_detection_index
  405. vc_chosen_compiler_str = "x86"
  406. vc_x86_amd64_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN\\x86_amd64;")
  407. if vc_x86_amd64_compiler_detection_index > -1 and (
  408. vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_x86_amd64_compiler_detection_index
  409. ):
  410. vc_chosen_compiler_index = vc_x86_amd64_compiler_detection_index
  411. vc_chosen_compiler_str = "x86_amd64"
  412. # and for VS 2017 and newer we check VCTOOLSINSTALLDIR:
  413. if "VCTOOLSINSTALLDIR" in tools_env:
  414. # Newer versions have a different path available
  415. vc_amd64_compiler_detection_index = (
  416. tools_env["PATH"].upper().find(tools_env["VCTOOLSINSTALLDIR"].upper() + "BIN\\HOSTX64\\X64;")
  417. )
  418. if vc_amd64_compiler_detection_index > -1:
  419. vc_chosen_compiler_index = vc_amd64_compiler_detection_index
  420. vc_chosen_compiler_str = "amd64"
  421. vc_amd64_x86_compiler_detection_index = (
  422. tools_env["PATH"].upper().find(tools_env["VCTOOLSINSTALLDIR"].upper() + "BIN\\HOSTX64\\X86;")
  423. )
  424. if vc_amd64_x86_compiler_detection_index > -1 and (
  425. vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_amd64_x86_compiler_detection_index
  426. ):
  427. vc_chosen_compiler_index = vc_amd64_x86_compiler_detection_index
  428. vc_chosen_compiler_str = "amd64_x86"
  429. vc_x86_compiler_detection_index = (
  430. tools_env["PATH"].upper().find(tools_env["VCTOOLSINSTALLDIR"].upper() + "BIN\\HOSTX86\\X86;")
  431. )
  432. if vc_x86_compiler_detection_index > -1 and (
  433. vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_x86_compiler_detection_index
  434. ):
  435. vc_chosen_compiler_index = vc_x86_compiler_detection_index
  436. vc_chosen_compiler_str = "x86"
  437. vc_x86_amd64_compiler_detection_index = (
  438. tools_env["PATH"].upper().find(tools_env["VCTOOLSINSTALLDIR"].upper() + "BIN\\HOSTX86\\X64;")
  439. )
  440. if vc_x86_amd64_compiler_detection_index > -1 and (
  441. vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_x86_amd64_compiler_detection_index
  442. ):
  443. vc_chosen_compiler_index = vc_x86_amd64_compiler_detection_index
  444. vc_chosen_compiler_str = "x86_amd64"
  445. return vc_chosen_compiler_str
  446. def find_visual_c_batch_file(env):
  447. from SCons.Tool.MSCommon.vc import get_default_version, get_host_target, find_batch_file
  448. version = get_default_version(env)
  449. (host_platform, target_platform, _) = get_host_target(env)
  450. return find_batch_file(env, version, host_platform, target_platform)[0]
  451. def generate_cpp_hint_file(filename):
  452. if os.path.isfile(filename):
  453. # Don't overwrite an existing hint file since the user may have customized it.
  454. pass
  455. else:
  456. try:
  457. with open(filename, "w") as fd:
  458. fd.write("#define GDCLASS(m_class, m_inherits)\n")
  459. except IOError:
  460. print("Could not write cpp.hint file.")
  461. def generate_vs_project(env, num_jobs):
  462. batch_file = find_visual_c_batch_file(env)
  463. if batch_file:
  464. def build_commandline(commands):
  465. common_build_prefix = [
  466. 'cmd /V /C set "plat=$(PlatformTarget)"',
  467. '(if "$(PlatformTarget)"=="x64" (set "plat=x86_amd64"))',
  468. 'set "tools=yes"',
  469. '(if "$(Configuration)"=="release" (set "tools=no"))',
  470. 'set "custom_modules=%s"' % env["custom_modules"],
  471. 'call "' + batch_file + '" !plat!',
  472. ]
  473. result = " ^& ".join(common_build_prefix + [commands])
  474. return result
  475. env.AddToVSProject(env.core_sources)
  476. env.AddToVSProject(env.main_sources)
  477. env.AddToVSProject(env.modules_sources)
  478. env.AddToVSProject(env.scene_sources)
  479. env.AddToVSProject(env.servers_sources)
  480. env.AddToVSProject(env.editor_sources)
  481. # windows allows us to have spaces in paths, so we need
  482. # to double quote off the directory. However, the path ends
  483. # in a backslash, so we need to remove this, lest it escape the
  484. # last double quote off, confusing MSBuild
  485. env["MSVSBUILDCOM"] = build_commandline(
  486. "scons --directory=\"$(ProjectDir.TrimEnd('\\'))\" platform=windows progress=no target=$(Configuration) tools=!tools! custom_modules=!custom_modules! -j"
  487. + str(num_jobs)
  488. )
  489. env["MSVSREBUILDCOM"] = build_commandline(
  490. "scons --directory=\"$(ProjectDir.TrimEnd('\\'))\" platform=windows progress=no target=$(Configuration) tools=!tools! vsproj=yes custom_modules=!custom_modules! -j"
  491. + str(num_jobs)
  492. )
  493. env["MSVSCLEANCOM"] = build_commandline(
  494. "scons --directory=\"$(ProjectDir.TrimEnd('\\'))\" --clean platform=windows progress=no target=$(Configuration) tools=!tools! custom_modules=!custom_modules! -j"
  495. + str(num_jobs)
  496. )
  497. # This version information (Win32, x64, Debug, Release, Release_Debug seems to be
  498. # required for Visual Studio to understand that it needs to generate an NMAKE
  499. # project. Do not modify without knowing what you are doing.
  500. debug_variants = ["debug|Win32"] + ["debug|x64"]
  501. release_variants = ["release|Win32"] + ["release|x64"]
  502. release_debug_variants = ["release_debug|Win32"] + ["release_debug|x64"]
  503. variants = debug_variants + release_variants + release_debug_variants
  504. debug_targets = ["bin\\godot.windows.tools.32.exe"] + ["bin\\godot.windows.tools.64.exe"]
  505. release_targets = ["bin\\godot.windows.opt.32.exe"] + ["bin\\godot.windows.opt.64.exe"]
  506. release_debug_targets = ["bin\\godot.windows.opt.tools.32.exe"] + ["bin\\godot.windows.opt.tools.64.exe"]
  507. targets = debug_targets + release_targets + release_debug_targets
  508. if not env.get("MSVS"):
  509. env["MSVS"]["PROJECTSUFFIX"] = ".vcxproj"
  510. env["MSVS"]["SOLUTIONSUFFIX"] = ".sln"
  511. env.MSVSProject(
  512. target=["#godot" + env["MSVSPROJECTSUFFIX"]],
  513. incs=env.vs_incs,
  514. srcs=env.vs_srcs,
  515. runfile=targets,
  516. buildtarget=targets,
  517. auto_build_solution=1,
  518. variant=variants,
  519. )
  520. else:
  521. print(
  522. "Could not locate Visual Studio batch file for setting up the build environment. Not generating VS project."
  523. )
  524. def precious_program(env, program, sources, **args):
  525. program = env.ProgramOriginal(program, sources, **args)
  526. env.Precious(program)
  527. return program
  528. def add_shared_library(env, name, sources, **args):
  529. library = env.SharedLibrary(name, sources, **args)
  530. env.NoCache(library)
  531. return library
  532. def add_library(env, name, sources, **args):
  533. library = env.Library(name, sources, **args)
  534. env.NoCache(library)
  535. return library
  536. def add_program(env, name, sources, **args):
  537. program = env.Program(name, sources, **args)
  538. env.NoCache(program)
  539. return program
  540. def CommandNoCache(env, target, sources, command, **args):
  541. result = env.Command(target, sources, command, **args)
  542. env.NoCache(result)
  543. return result
  544. def detect_darwin_sdk_path(platform, env):
  545. sdk_name = ""
  546. if platform == "osx":
  547. sdk_name = "macosx"
  548. var_name = "MACOS_SDK_PATH"
  549. elif platform == "iphone":
  550. sdk_name = "iphoneos"
  551. var_name = "IPHONESDK"
  552. elif platform == "iphonesimulator":
  553. sdk_name = "iphonesimulator"
  554. var_name = "IPHONESDK"
  555. else:
  556. raise Exception("Invalid platform argument passed to detect_darwin_sdk_path")
  557. if not env[var_name]:
  558. try:
  559. sdk_path = decode_utf8(subprocess.check_output(["xcrun", "--sdk", sdk_name, "--show-sdk-path"]).strip())
  560. if sdk_path:
  561. env[var_name] = sdk_path
  562. except (subprocess.CalledProcessError, OSError):
  563. print("Failed to find SDK path while running xcrun --sdk {} --show-sdk-path.".format(sdk_name))
  564. raise
  565. def get_compiler_version(env):
  566. """
  567. Returns an array of version numbers as ints: [major, minor, patch].
  568. The return array should have at least two values (major, minor).
  569. """
  570. if not env.msvc:
  571. # Not using -dumpversion as some GCC distros only return major, and
  572. # Clang used to return hardcoded 4.2.1: # https://reviews.llvm.org/D56803
  573. try:
  574. version = decode_utf8(subprocess.check_output([env.subst(env["CXX"]), "--version"]).strip())
  575. except (subprocess.CalledProcessError, OSError):
  576. print("Couldn't parse CXX environment variable to infer compiler version.")
  577. return None
  578. else: # TODO: Implement for MSVC
  579. return None
  580. match = re.search(r"[0-9]+\.[0-9.]+", version)
  581. if match is not None:
  582. return list(map(int, match.group().split(".")))
  583. else:
  584. return None
  585. def using_gcc(env):
  586. return "gcc" in os.path.basename(env["CC"])
  587. def using_clang(env):
  588. return "clang" in os.path.basename(env["CC"])
  589. def show_progress(env):
  590. import sys
  591. from SCons.Script import Progress, Command, AlwaysBuild
  592. screen = sys.stdout
  593. # Progress reporting is not available in non-TTY environments since it
  594. # messes with the output (for example, when writing to a file)
  595. show_progress = env["progress"] and sys.stdout.isatty()
  596. node_count_data = {
  597. "count": 0,
  598. "max": 0,
  599. "interval": 1,
  600. "fname": str(env.Dir("#")) + "/.scons_node_count",
  601. }
  602. import time, math
  603. class cache_progress:
  604. # The default is 1 GB cache and 12 hours half life
  605. def __init__(self, path=None, limit=1073741824, half_life=43200):
  606. self.path = path
  607. self.limit = limit
  608. self.exponent_scale = math.log(2) / half_life
  609. if env["verbose"] and path != None:
  610. screen.write(
  611. "Current cache limit is {} (used: {})\n".format(
  612. self.convert_size(limit), self.convert_size(self.get_size(path))
  613. )
  614. )
  615. self.delete(self.file_list())
  616. def __call__(self, node, *args, **kw):
  617. if show_progress:
  618. # Print the progress percentage
  619. node_count_data["count"] += node_count_data["interval"]
  620. node_count = node_count_data["count"]
  621. node_count_max = node_count_data["max"]
  622. if node_count_max > 0 and node_count <= node_count_max:
  623. screen.write("\r[%3d%%] " % (node_count * 100 / node_count_max))
  624. screen.flush()
  625. elif node_count_max > 0 and node_count > node_count_max:
  626. screen.write("\r[100%] ")
  627. screen.flush()
  628. else:
  629. screen.write("\r[Initial build] ")
  630. screen.flush()
  631. def delete(self, files):
  632. if len(files) == 0:
  633. return
  634. if env["verbose"]:
  635. # Utter something
  636. screen.write("\rPurging %d %s from cache...\n" % (len(files), len(files) > 1 and "files" or "file"))
  637. [os.remove(f) for f in files]
  638. def file_list(self):
  639. if self.path is None:
  640. # Nothing to do
  641. return []
  642. # Gather a list of (filename, (size, atime)) within the
  643. # cache directory
  644. file_stat = [(x, os.stat(x)[6:8]) for x in glob.glob(os.path.join(self.path, "*", "*"))]
  645. if file_stat == []:
  646. # Nothing to do
  647. return []
  648. # Weight the cache files by size (assumed to be roughly
  649. # proportional to the recompilation time) times an exponential
  650. # decay since the ctime, and return a list with the entries
  651. # (filename, size, weight).
  652. current_time = time.time()
  653. file_stat = [(x[0], x[1][0], (current_time - x[1][1])) for x in file_stat]
  654. # Sort by the most recently accessed files (most sensible to keep) first
  655. file_stat.sort(key=lambda x: x[2])
  656. # Search for the first entry where the storage limit is
  657. # reached
  658. sum, mark = 0, None
  659. for i, x in enumerate(file_stat):
  660. sum += x[1]
  661. if sum > self.limit:
  662. mark = i
  663. break
  664. if mark is None:
  665. return []
  666. else:
  667. return [x[0] for x in file_stat[mark:]]
  668. def convert_size(self, size_bytes):
  669. if size_bytes == 0:
  670. return "0 bytes"
  671. size_name = ("bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB")
  672. i = int(math.floor(math.log(size_bytes, 1024)))
  673. p = math.pow(1024, i)
  674. s = round(size_bytes / p, 2)
  675. return "%s %s" % (int(s) if i == 0 else s, size_name[i])
  676. def get_size(self, start_path="."):
  677. total_size = 0
  678. for dirpath, dirnames, filenames in os.walk(start_path):
  679. for f in filenames:
  680. fp = os.path.join(dirpath, f)
  681. total_size += os.path.getsize(fp)
  682. return total_size
  683. def progress_finish(target, source, env):
  684. with open(node_count_data["fname"], "w") as f:
  685. f.write("%d\n" % node_count_data["count"])
  686. progressor.delete(progressor.file_list())
  687. try:
  688. with open(node_count_data["fname"]) as f:
  689. node_count_data["max"] = int(f.readline())
  690. except:
  691. pass
  692. cache_directory = os.environ.get("SCONS_CACHE")
  693. # Simple cache pruning, attached to SCons' progress callback. Trim the
  694. # cache directory to a size not larger than cache_limit.
  695. cache_limit = float(os.getenv("SCONS_CACHE_LIMIT", 1024)) * 1024 * 1024
  696. progressor = cache_progress(cache_directory, cache_limit)
  697. Progress(progressor, interval=node_count_data["interval"])
  698. progress_finish_command = Command("progress_finish", [], progress_finish)
  699. AlwaysBuild(progress_finish_command)
  700. def dump(env):
  701. # Dumps latest build information for debugging purposes and external tools.
  702. from json import dump
  703. def non_serializable(obj):
  704. return "<<non-serializable: %s>>" % (qualname(type(obj)))
  705. with open(".scons_env.json", "w") as f:
  706. dump(env.Dictionary(), f, indent=4, default=non_serializable)