mirror/godot
2
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2024-12-27 11:24:59 +08:00
Code Issues Packages Projects Releases Wiki Activity
e270d1cce3
godot/modules/mono/build_scripts/mono_configure.py

575 lines
22 KiB
Python
Raw Normal View History

Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
import os
Android build and export for the mono module
2019-05-21 00:34:35 +08:00
import os.path
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
import subprocess
Android build and export for the mono module
2019-05-21 00:34:35 +08:00
from SCons.Script import Dir, Environment
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
if os.name == "nt":
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
from . import mono_reg_utils as monoreg
Android build and export for the mono module
2019-05-21 00:34:35 +08:00
android_arch_dirs = {
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
"armv7": "armeabi-v7a",
"arm64v8": "arm64-v8a",
"x86": "x86",
"x86_64": "x86_64",
Android build and export for the mono module
2019-05-21 00:34:35 +08:00
}
def get_android_out_dir(env):
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
return os.path.join(
Dir("#platform/android/java/lib/libs").abspath,
"release" if env["target"] == "release" else "debug",
android_arch_dirs[env["android_arch"]],
)
Android build and export for the mono module
2019-05-21 00:34:35 +08:00
Mono/C#: Fix MinGW build not supporting `.lib` libraries MinGW should support both its own format `.a` and MSVC's format `.lib`, but Mono's module was only using the former. With this change it's now possible to build with MinGW and link the official Mono for Windows which is built with MSVC.
2020-03-19 00:38:53 +08:00
def find_name_in_dir_files(directory, names, prefixes=[""], extensions=[""]):
for extension in extensions:
if extension and not extension.startswith("."):
extension = "." + extension
for prefix in prefixes:
for curname in names:
if os.path.isfile(os.path.join(directory, prefix + curname + extension)):
return curname
return ""
def find_file_in_dir(directory, names, prefixes=[""], extensions=[""]):
for extension in extensions:
if extension and not extension.startswith("."):
extension = "." + extension
for prefix in prefixes:
for curname in names:
filename = prefix + curname + extension
if os.path.isfile(os.path.join(directory, filename)):
return filename
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
return ""
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
Mono/C#: Add iOS support Right now, games only work on devices when exported with FullAOT+Interpreter. There are some issues left that need to addressed for FullAOT alone. Right now, it's giving issues with the Godot.NativeCalls static constructor.
2020-03-19 00:40:04 +08:00
def copy_file(src_dir, dst_dir, src_name, dst_name=""):
Android build and export for the mono module
2019-05-21 00:34:35 +08:00
from shutil import copy
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
Mono/C#: Add iOS support Right now, games only work on devices when exported with FullAOT+Interpreter. There are some issues left that need to addressed for FullAOT alone. Right now, it's giving issues with the Godot.NativeCalls static constructor.
2020-03-19 00:40:04 +08:00
src_path = os.path.join(Dir(src_dir).abspath, src_name)
Android build and export for the mono module
2019-05-21 00:34:35 +08:00
dst_dir = Dir(dst_dir).abspath
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
if not os.path.isdir(dst_dir):
Mono: Android build and shared libraries fixes Fix location of Mono's shared libraries. Fix build failing if the directory 'platform/android/java/libs/{target}/{abi}' doesn't exist.
2019-07-03 23:41:07 +08:00
os.makedirs(dst_dir)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
Mono/C#: Add iOS support Right now, games only work on devices when exported with FullAOT+Interpreter. There are some issues left that need to addressed for FullAOT alone. Right now, it's giving issues with the Godot.NativeCalls static constructor.
2020-03-19 00:40:04 +08:00
if dst_name:
copy(src_path, os.path.join(dst_dir, dst_name))
else:
copy(src_path, dst_dir)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
Mono/C#: WebAssembly support
2019-11-11 00:10:38 +08:00
def is_desktop(platform):
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
return platform in ["windows", "osx", "linuxbsd", "server", "uwp", "haiku"]
Mono/C#: WebAssembly support
2019-11-11 00:10:38 +08:00
def is_unix_like(platform):
Mono/C#: Add iOS support Right now, games only work on devices when exported with FullAOT+Interpreter. There are some issues left that need to addressed for FullAOT alone. Right now, it's giving issues with the Godot.NativeCalls static constructor.
2020-03-19 00:40:04 +08:00
return platform in ["osx", "linuxbsd", "server", "android", "haiku", "iphone"]
Mono/C#: WebAssembly support
2019-11-11 00:10:38 +08:00
def module_supports_tools_on(platform):
Mono/C#: Add iOS support Right now, games only work on devices when exported with FullAOT+Interpreter. There are some issues left that need to addressed for FullAOT alone. Right now, it's giving issues with the Godot.NativeCalls static constructor.
2020-03-19 00:40:04 +08:00
return platform not in ["android", "javascript", "iphone"]
Mono/C#: WebAssembly support
2019-11-11 00:10:38 +08:00
def find_wasm_src_dir(mono_root):
hint_dirs = [
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
os.path.join(mono_root, "src"),
os.path.join(mono_root, "../src"),
Mono/C#: WebAssembly support
2019-11-11 00:10:38 +08:00
]
for hint_dir in hint_dirs:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
if os.path.isfile(os.path.join(hint_dir, "driver.c")):
Mono/C#: WebAssembly support
2019-11-11 00:10:38 +08:00
return hint_dir
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
return ""
Mono/C#: WebAssembly support
2019-11-11 00:10:38 +08:00
Mono: Add compiler flags to env_mono instead of env This way we avoid possible conflicts with other modules. Specially with include paths.
2019-03-02 05:00:39 +08:00
def configure(env, env_mono):
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
bits = env["bits"]
is_android = env["platform"] == "android"
is_javascript = env["platform"] == "javascript"
Mono/C#: Add iOS support Right now, games only work on devices when exported with FullAOT+Interpreter. There are some issues left that need to addressed for FullAOT alone. Right now, it's giving issues with the Godot.NativeCalls static constructor.
2020-03-19 00:40:04 +08:00
is_ios = env["platform"] == "iphone"
is_ios_sim = is_ios and env["arch"] in ["x86", "x86_64"]
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
tools_enabled = env["tools"]
mono_static = env["mono_static"]
copy_mono_root = env["copy_mono_root"]
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
mono_prefix = env["mono_prefix"]
Mono: Add mono_bcl SCons option for a custom BCL location Makes it let's bothersome to work with builds from our godotengine/godot-mono-builds scripts, as they write the BCL into an output directory separate from the runtime (which is good as two runtimes may share the same BCL).
2020-12-06 08:15:17 +08:00
mono_bcl = env["mono_bcl"]
Android build and export for the mono module
2019-05-21 00:34:35 +08:00
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
mono_lib_names = ["mono-2.0-sgen", "monosgen-2.0"]
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
if is_android and not env["android_arch"] in android_arch_dirs:
raise RuntimeError("This module does not support the specified 'android_arch': " + env["android_arch"])
Android build and export for the mono module
2019-05-21 00:34:35 +08:00
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
if tools_enabled and not module_supports_tools_on(env["platform"]):
Mono/C#: WebAssembly support
2019-11-11 00:10:38 +08:00
# TODO:
# Android: We have to add the data directory to the apk, concretely the Api and Tools folders.
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
raise RuntimeError("This module does not currently support building for this platform with tools enabled")
Android build and export for the mono module
2019-05-21 00:34:35 +08:00
Mono: Android build and shared libraries fixes Fix location of Mono's shared libraries. Fix build failing if the directory 'platform/android/java/libs/{target}/{abi}' doesn't exist.
2019-07-03 23:41:07 +08:00
if is_android and mono_static:
Mono/C#: Add iOS support Right now, games only work on devices when exported with FullAOT+Interpreter. There are some issues left that need to addressed for FullAOT alone. Right now, it's giving issues with the Godot.NativeCalls static constructor.
2020-03-19 00:40:04 +08:00
# FIXME: When static linking and doing something that requires libmono-native, we get a dlopen error as 'libmono-native'
# seems to depend on 'libmonosgen-2.0'. Could be fixed by re-directing to '__Internal' with a dllmap or in the dlopen hook.
raise RuntimeError("Statically linking Mono is not currently supported for this platform")
Mono: Android build and shared libraries fixes Fix location of Mono's shared libraries. Fix build failing if the directory 'platform/android/java/libs/{target}/{abi}' doesn't exist.
2019-07-03 23:41:07 +08:00
Mono/C#: Add iOS support Right now, games only work on devices when exported with FullAOT+Interpreter. There are some issues left that need to addressed for FullAOT alone. Right now, it's giving issues with the Godot.NativeCalls static constructor.
2020-03-19 00:40:04 +08:00
if not mono_static and (is_javascript or is_ios):
raise RuntimeError("Dynamically linking Mono is not currently supported for this platform")
Mono/C#: WebAssembly support
2019-11-11 00:10:38 +08:00
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
if not mono_prefix and (os.getenv("MONO32_PREFIX") or os.getenv("MONO64_PREFIX")):
print(
CI: Install master version of psf/black Until https://github.com/psf/black/pull/1328 makes it in a stable release, we have to use the latest from Git. Apply new style fixes done by latest black.
2020-07-27 01:38:10 +08:00
"WARNING: The environment variables 'MONO32_PREFIX' and 'MONO64_PREFIX' are deprecated; use the"
" 'mono_prefix' SCons parameter instead"
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
)
Android build and export for the mono module
2019-05-21 00:34:35 +08:00
Mono/C#: Add iOS support Right now, games only work on devices when exported with FullAOT+Interpreter. There are some issues left that need to addressed for FullAOT alone. Right now, it's giving issues with the Godot.NativeCalls static constructor.
2020-03-19 00:40:04 +08:00
# Although we don't support building with tools for any platform where we currently use static AOT,
# if these are supported in the future, we won't be using static AOT for them as that would be
# too restrictive for the editor. These builds would probably be made to only use the interpreter.
mono_aot_static = (is_ios and not is_ios_sim) and not env["tools"]
# Static AOT is only supported on the root domain
mono_single_appdomain = mono_aot_static
if mono_single_appdomain:
env_mono.Append(CPPDEFINES=["GD_MONO_SINGLE_APPDOMAIN"])
if (env["tools"] or env["target"] != "release") and not mono_single_appdomain:
env_mono.Append(CPPDEFINES=["GD_MONO_HOT_RELOAD"])
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
if env["platform"] == "windows":
Android build and export for the mono module
2019-05-21 00:34:35 +08:00
mono_root = mono_prefix
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
if not mono_root and os.name == "nt":
Android build and export for the mono module
2019-05-21 00:34:35 +08:00
mono_root = monoreg.find_mono_root_dir(bits)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
if not mono_root:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
raise RuntimeError(
"Mono installation directory not found; specify one manually with the 'mono_prefix' SCons parameter"
)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
print("Found Mono root directory: " + mono_root)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
mono_lib_path = os.path.join(mono_root, "lib")
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
env.Append(LIBPATH=mono_lib_path)
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
env_mono.Prepend(CPPPATH=os.path.join(mono_root, "include", "mono-2.0"))
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
Mono/C#: Fix MinGW build not supporting `.lib` libraries MinGW should support both its own format `.a` and MSVC's format `.lib`, but Mono's module was only using the former. With this change it's now possible to build with MinGW and link the official Mono for Windows which is built with MSVC.
2020-03-19 00:38:53 +08:00
lib_suffixes = [".lib"]
if not env.msvc:
# MingW supports both '.a' and '.lib'
lib_suffixes.insert(0, ".a")
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
Mono/C#: Add option to export assemblies outside of PCK When using this options, assemblies will be saved in the Assemblies folder of the data directory: 'data_AppName/Assemblies/'.
2019-11-29 06:42:37 +08:00
if mono_static:
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
if env.msvc:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
mono_static_lib_name = "libmono-static-sgen"
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
else:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
mono_static_lib_name = "libmonosgen-2.0"
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
Mono/C#: Fix MinGW build not supporting `.lib` libraries MinGW should support both its own format `.a` and MSVC's format `.lib`, but Mono's module was only using the former. With this change it's now possible to build with MinGW and link the official Mono for Windows which is built with MSVC.
2020-03-19 00:38:53 +08:00
mono_static_lib_file = find_file_in_dir(mono_lib_path, [mono_static_lib_name], extensions=lib_suffixes)
if not mono_static_lib_file:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
raise RuntimeError("Could not find static mono library in: " + mono_lib_path)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
if env.msvc:
Mono/C#: Fix MinGW build not supporting `.lib` libraries MinGW should support both its own format `.a` and MSVC's format `.lib`, but Mono's module was only using the former. With this change it's now possible to build with MinGW and link the official Mono for Windows which is built with MSVC.
2020-03-19 00:38:53 +08:00
env.Append(LINKFLAGS=mono_static_lib_file)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
Mono/C#: Fix MinGW build not supporting `.lib` libraries MinGW should support both its own format `.a` and MSVC's format `.lib`, but Mono's module was only using the former. With this change it's now possible to build with MinGW and link the official Mono for Windows which is built with MSVC.
2020-03-19 00:38:53 +08:00
env.Append(LINKFLAGS="Mincore.lib")
env.Append(LINKFLAGS="msvcrt.lib")
env.Append(LINKFLAGS="LIBCMT.lib")
env.Append(LINKFLAGS="Psapi.lib")
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
else:
Mono/C#: Fix MinGW build not supporting `.lib` libraries MinGW should support both its own format `.a` and MSVC's format `.lib`, but Mono's module was only using the former. With this change it's now possible to build with MinGW and link the official Mono for Windows which is built with MSVC.
2020-03-19 00:38:53 +08:00
mono_static_lib_file_path = os.path.join(mono_lib_path, mono_static_lib_file)
env.Append(LINKFLAGS=["-Wl,-whole-archive", mono_static_lib_file_path, "-Wl,-no-whole-archive"])
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
env.Append(LIBS=["psapi"])
env.Append(LIBS=["version"])
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
else:
Fix dynamic linking of MSVC Mono with MinGW Godot
2020-06-16 03:29:50 +08:00
mono_lib_file = find_file_in_dir(mono_lib_path, mono_lib_names, extensions=lib_suffixes)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
Fix dynamic linking of MSVC Mono with MinGW Godot
2020-06-16 03:29:50 +08:00
if not mono_lib_file:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
raise RuntimeError("Could not find mono library in: " + mono_lib_path)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
if env.msvc:
Fix dynamic linking of MSVC Mono with MinGW Godot
2020-06-16 03:29:50 +08:00
env.Append(LINKFLAGS=mono_lib_file)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
else:
Fix dynamic linking of MSVC Mono with MinGW Godot
2020-06-16 03:29:50 +08:00
mono_lib_file_path = os.path.join(mono_lib_path, mono_lib_file)
env.Append(LINKFLAGS=mono_lib_file_path)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
mono_bin_path = os.path.join(mono_root, "bin")
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
Mono/C#: Fix MinGW build not supporting `.lib` libraries MinGW should support both its own format `.a` and MSVC's format `.lib`, but Mono's module was only using the former. With this change it's now possible to build with MinGW and link the official Mono for Windows which is built with MSVC.
2020-03-19 00:38:53 +08:00
mono_dll_file = find_file_in_dir(mono_bin_path, mono_lib_names, prefixes=["", "lib"], extensions=[".dll"])
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
Mono/C#: Fix MinGW build not supporting `.lib` libraries MinGW should support both its own format `.a` and MSVC's format `.lib`, but Mono's module was only using the former. With this change it's now possible to build with MinGW and link the official Mono for Windows which is built with MSVC.
2020-03-19 00:38:53 +08:00
if not mono_dll_file:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
raise RuntimeError("Could not find mono shared library in: " + mono_bin_path)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
Mono/C#: Fix MinGW build not supporting `.lib` libraries MinGW should support both its own format `.a` and MSVC's format `.lib`, but Mono's module was only using the former. With this change it's now possible to build with MinGW and link the official Mono for Windows which is built with MSVC.
2020-03-19 00:38:53 +08:00
copy_file(mono_bin_path, "#bin", mono_dll_file)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
else:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
is_apple = env["platform"] in ["osx", "iphone"]
Mono/C#: Add iOS support Right now, games only work on devices when exported with FullAOT+Interpreter. There are some issues left that need to addressed for FullAOT alone. Right now, it's giving issues with the Godot.NativeCalls static constructor.
2020-03-19 00:40:04 +08:00
is_macos = is_apple and not is_ios
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
sharedlib_ext = ".dylib" if is_apple else ".so"
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
Android build and export for the mono module
2019-05-21 00:34:35 +08:00
mono_root = mono_prefix
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
mono_lib_path = ""
Mono/C#: Fix MinGW build not supporting `.lib` libraries MinGW should support both its own format `.a` and MSVC's format `.lib`, but Mono's module was only using the former. With this change it's now possible to build with MinGW and link the official Mono for Windows which is built with MSVC.
2020-03-19 00:38:53 +08:00
mono_so_file = ""
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
Mono/C#: Add iOS support Right now, games only work on devices when exported with FullAOT+Interpreter. There are some issues left that need to addressed for FullAOT alone. Right now, it's giving issues with the Godot.NativeCalls static constructor.
2020-03-19 00:40:04 +08:00
if not mono_root and (is_android or is_javascript or is_ios):
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
raise RuntimeError(
"Mono installation directory not found; specify one manually with the 'mono_prefix' SCons parameter"
)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
Mono/C#: Add iOS support Right now, games only work on devices when exported with FullAOT+Interpreter. There are some issues left that need to addressed for FullAOT alone. Right now, it's giving issues with the Godot.NativeCalls static constructor.
2020-03-19 00:40:04 +08:00
if not mono_root and is_macos:
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
# Try with some known directories under OSX
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
hint_dirs = ["/Library/Frameworks/Mono.framework/Versions/Current", "/usr/local/var/homebrew/linked/mono"]
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
for hint_dir in hint_dirs:
if os.path.isdir(hint_dir):
mono_root = hint_dir
break
# We can't use pkg-config to link mono statically,
# but we can still use it to find the mono root directory
if not mono_root and mono_static:
mono_root = pkgconfig_try_find_mono_root(mono_lib_names, sharedlib_ext)
if not mono_root:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
raise RuntimeError(
"Building with mono_static=yes, but failed to find the mono prefix with pkg-config; "
+ "specify one manually with the 'mono_prefix' SCons parameter"
)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
Mono/C#: Add iOS support Right now, games only work on devices when exported with FullAOT+Interpreter. There are some issues left that need to addressed for FullAOT alone. Right now, it's giving issues with the Godot.NativeCalls static constructor.
2020-03-19 00:40:04 +08:00
if is_ios and not is_ios_sim:
env_mono.Append(CPPDEFINES=["IOS_DEVICE"])
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
if mono_root:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
print("Found Mono root directory: " + mono_root)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
mono_lib_path = os.path.join(mono_root, "lib")
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
Mono/C#: WebAssembly support
2019-11-11 00:10:38 +08:00
env.Append(LIBPATH=[mono_lib_path])
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
env_mono.Prepend(CPPPATH=os.path.join(mono_root, "include", "mono-2.0"))
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
Mono/C#: Fix MinGW build not supporting `.lib` libraries MinGW should support both its own format `.a` and MSVC's format `.lib`, but Mono's module was only using the former. With this change it's now possible to build with MinGW and link the official Mono for Windows which is built with MSVC.
2020-03-19 00:38:53 +08:00
mono_lib = find_name_in_dir_files(mono_lib_path, mono_lib_names, prefixes=["lib"], extensions=[".a"])
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
if not mono_lib:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
raise RuntimeError("Could not find mono library in: " + mono_lib_path)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
env_mono.Append(CPPDEFINES=["_REENTRANT"])
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
if mono_static:
Mono: Don't use -rdynamic when compiling for WASM `-rdynamic` was causing the emsdk linker to silently fail to generate the output `.wasm` file (even though exit code was 0).
2020-12-05 06:47:12 +08:00
if not is_javascript:
env.Append(LINKFLAGS=["-rdynamic"])
Mono/C#: Several android fixes - Added correct config file for android dllmaps. - Fix __Internal DllImports with a dlopen fallback. - Add missing P/Invoke functions and internal calls expected by the monodroid BCL and our custom version of the 'Android.Runtime.AndroidEnvironment' class (this last one can be found in the godot-mono-builds repo). - Make sure to set 'btls' instead of 'legacy' as the default TLS provider on Android.
2019-12-04 22:07:00 +08:00
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
mono_lib_file = os.path.join(mono_lib_path, "lib" + mono_lib + ".a")
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
if is_apple:
Mono/C#: Add iOS support Right now, games only work on devices when exported with FullAOT+Interpreter. There are some issues left that need to addressed for FullAOT alone. Right now, it's giving issues with the Godot.NativeCalls static constructor.
2020-03-19 00:40:04 +08:00
if is_macos:
env.Append(LINKFLAGS=["-Wl,-force_load," + mono_lib_file])
else:
arch = env["arch"]
def copy_mono_lib(libname_wo_ext):
copy_file(
mono_lib_path, "#bin", libname_wo_ext + ".a", "%s.iphone.%s.a" % (libname_wo_ext, arch)
)
# Copy Mono libraries to the output folder. These are meant to be bundled with
# the export templates and added to the Xcode project when exporting a game.
copy_mono_lib("lib" + mono_lib)
copy_mono_lib("libmono-native")
copy_mono_lib("libmono-profiler-log")
if not is_ios_sim:
copy_mono_lib("libmono-ee-interp")
copy_mono_lib("libmono-icall-table")
copy_mono_lib("libmono-ilgen")
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
else:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
assert is_desktop(env["platform"]) or is_android or is_javascript
env.Append(LINKFLAGS=["-Wl,-whole-archive", mono_lib_file, "-Wl,-no-whole-archive"])
Mono/C#: WebAssembly support
2019-11-11 00:10:38 +08:00
if is_javascript:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
env.Append(LIBS=["mono-icall-table", "mono-native", "mono-ilgen", "mono-ee-interp"])
Mono/C#: WebAssembly support
2019-11-11 00:10:38 +08:00
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
wasm_src_dir = os.path.join(mono_root, "src")
Mono/C#: WebAssembly support
2019-11-11 00:10:38 +08:00
if not os.path.isdir(wasm_src_dir):
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
raise RuntimeError("Could not find mono wasm src directory")
Mono/C#: WebAssembly support
2019-11-11 00:10:38 +08:00
# Ideally this should be defined only for 'driver.c', but I can't fight scons for another 2 hours
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
env_mono.Append(CPPDEFINES=["CORE_BINDINGS"])
env_mono.add_source_files(
env.modules_sources,
[
os.path.join(wasm_src_dir, "driver.c"),
os.path.join(wasm_src_dir, "zlib-helper.c"),
os.path.join(wasm_src_dir, "corebindings.c"),
],
)
env.Append(
LINKFLAGS=[
"--js-library",
os.path.join(wasm_src_dir, "library_mono.js"),
"--js-library",
os.path.join(wasm_src_dir, "binding_support.js"),
"--js-library",
os.path.join(wasm_src_dir, "dotnet_support.js"),
]
)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
else:
env.Append(LIBS=[mono_lib])
Mono/C#: Add iOS support Right now, games only work on devices when exported with FullAOT+Interpreter. There are some issues left that need to addressed for FullAOT alone. Right now, it's giving issues with the Godot.NativeCalls static constructor.
2020-03-19 00:40:04 +08:00
if is_macos:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
env.Append(LIBS=["iconv", "pthread"])
Android build and export for the mono module
2019-05-21 00:34:35 +08:00
elif is_android:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
pass # Nothing
Mono/C#: Add iOS support Right now, games only work on devices when exported with FullAOT+Interpreter. There are some issues left that need to addressed for FullAOT alone. Right now, it's giving issues with the Godot.NativeCalls static constructor.
2020-03-19 00:40:04 +08:00
elif is_ios:
pass # Nothing, linking is delegated to the exported Xcode project
Mono/C#: WebAssembly support
2019-11-11 00:10:38 +08:00
elif is_javascript:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
env.Append(LIBS=["m", "rt", "dl", "pthread"])
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
else:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
env.Append(LIBS=["m", "rt", "dl", "pthread"])
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
if not mono_static:
Mono/C#: Fix MinGW build not supporting `.lib` libraries MinGW should support both its own format `.a` and MSVC's format `.lib`, but Mono's module was only using the former. With this change it's now possible to build with MinGW and link the official Mono for Windows which is built with MSVC.
2020-03-19 00:38:53 +08:00
mono_so_file = find_file_in_dir(
mono_lib_path, mono_lib_names, prefixes=["lib"], extensions=[sharedlib_ext]
)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
Mono/C#: Fix MinGW build not supporting `.lib` libraries MinGW should support both its own format `.a` and MSVC's format `.lib`, but Mono's module was only using the former. With this change it's now possible to build with MinGW and link the official Mono for Windows which is built with MSVC.
2020-03-19 00:38:53 +08:00
if not mono_so_file:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
raise RuntimeError("Could not find mono shared library in: " + mono_lib_path)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
else:
assert not mono_static
# TODO: Add option to force using pkg-config
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
print("Mono root directory not found. Using pkg-config instead")
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
env.ParseConfig("pkg-config monosgen-2 --libs")
env_mono.ParseConfig("pkg-config monosgen-2 --cflags")
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
tmpenv = Environment()
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
tmpenv.AppendENVPath("PKG_CONFIG_PATH", os.getenv("PKG_CONFIG_PATH"))
tmpenv.ParseConfig("pkg-config monosgen-2 --libs-only-L")
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
for hint_dir in tmpenv["LIBPATH"]:
Mono/C#: Fix MinGW build not supporting `.lib` libraries MinGW should support both its own format `.a` and MSVC's format `.lib`, but Mono's module was only using the former. With this change it's now possible to build with MinGW and link the official Mono for Windows which is built with MSVC.
2020-03-19 00:38:53 +08:00
file_found = find_file_in_dir(hint_dir, mono_lib_names, prefixes=["lib"], extensions=[sharedlib_ext])
if file_found:
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
mono_lib_path = hint_dir
Mono/C#: Fix MinGW build not supporting `.lib` libraries MinGW should support both its own format `.a` and MSVC's format `.lib`, but Mono's module was only using the former. With this change it's now possible to build with MinGW and link the official Mono for Windows which is built with MSVC.
2020-03-19 00:38:53 +08:00
mono_so_file = file_found
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
break
Mono/C#: Fix MinGW build not supporting `.lib` libraries MinGW should support both its own format `.a` and MSVC's format `.lib`, but Mono's module was only using the former. With this change it's now possible to build with MinGW and link the official Mono for Windows which is built with MSVC.
2020-03-19 00:38:53 +08:00
if not mono_so_file:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
raise RuntimeError("Could not find mono shared library in: " + str(tmpenv["LIBPATH"]))
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
Android build and export for the mono module
2019-05-21 00:34:35 +08:00
if not mono_static:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
libs_output_dir = get_android_out_dir(env) if is_android else "#bin"
Mono/C#: Fix MinGW build not supporting `.lib` libraries MinGW should support both its own format `.a` and MSVC's format `.lib`, but Mono's module was only using the former. With this change it's now possible to build with MinGW and link the official Mono for Windows which is built with MSVC.
2020-03-19 00:38:53 +08:00
copy_file(mono_lib_path, libs_output_dir, mono_so_file)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
Mono/C#: WebAssembly support
2019-11-11 00:10:38 +08:00
if not tools_enabled:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
if is_desktop(env["platform"]):
Mono/C#: WebAssembly support
2019-11-11 00:10:38 +08:00
if not mono_root:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
mono_root = (
subprocess.check_output(["pkg-config", "mono-2", "--variable=prefix"]).decode("utf8").strip()
)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
Mono/C#: WebAssembly support
2019-11-11 00:10:38 +08:00
make_template_dir(env, mono_root)
elif is_android:
# Compress Android Mono Config
from . import make_android_mono_config
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
Mono/C#: Several android fixes - Added correct config file for android dllmaps. - Fix __Internal DllImports with a dlopen fallback. - Add missing P/Invoke functions and internal calls expected by the monodroid BCL and our custom version of the 'Android.Runtime.AndroidEnvironment' class (this last one can be found in the godot-mono-builds repo). - Make sure to set 'btls' instead of 'legacy' as the default TLS provider on Android.
2019-12-04 22:07:00 +08:00
module_dir = os.getcwd()
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
config_file_path = os.path.join(module_dir, "build_scripts", "mono_android_config.xml")
make_android_mono_config.generate_compressed_config(config_file_path, "mono_gd/")
Mono: Android build and shared libraries fixes Fix location of Mono's shared libraries. Fix build failing if the directory 'platform/android/java/libs/{target}/{abi}' doesn't exist.
2019-07-03 23:41:07 +08:00
Mono/C#: WebAssembly support
2019-11-11 00:10:38 +08:00
# Copy the required shared libraries
copy_mono_shared_libs(env, mono_root, None)
elif is_javascript:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
pass # No data directory for this platform
Mono/C#: Add iOS support Right now, games only work on devices when exported with FullAOT+Interpreter. There are some issues left that need to addressed for FullAOT alone. Right now, it's giving issues with the Godot.NativeCalls static constructor.
2020-03-19 00:40:04 +08:00
elif is_ios:
pass # No data directory for this platform
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
if copy_mono_root:
if not mono_root:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
mono_root = subprocess.check_output(["pkg-config", "mono-2", "--variable=prefix"]).decode("utf8").strip()
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
if tools_enabled:
Enable the `copy_mono_root` SCons option by default This closes #41652.
2020-09-25 17:05:28 +08:00
# Only supported for editor builds.
Mono: Add mono_bcl SCons option for a custom BCL location Makes it let's bothersome to work with builds from our godotengine/godot-mono-builds scripts, as they write the BCL into an output directory separate from the runtime (which is good as two runtimes may share the same BCL).
2020-12-06 08:15:17 +08:00
copy_mono_root_files(env, mono_root, mono_bcl)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
def make_template_dir(env, mono_root):
from shutil import rmtree
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
platform = env["platform"]
target = env["target"]
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
template_dir_name = ""
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
Mono/C#: WebAssembly support
2019-11-11 00:10:38 +08:00
assert is_desktop(platform)
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
template_dir_name = "data.mono.%s.%s.%s" % (platform, env["bits"], target)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
output_dir = Dir("#bin").abspath
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
template_dir = os.path.join(output_dir, template_dir_name)
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
template_mono_root_dir = os.path.join(template_dir, "Mono")
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
if os.path.isdir(template_mono_root_dir):
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
rmtree(template_mono_root_dir) # Clean first
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
# Copy etc/mono/
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
template_mono_config_dir = os.path.join(template_mono_root_dir, "etc", "mono")
Mono/C#: WebAssembly support
2019-11-11 00:10:38 +08:00
copy_mono_etc_dir(mono_root, template_mono_config_dir, platform)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
# Copy the required shared libraries
Android build and export for the mono module
2019-05-21 00:34:35 +08:00
copy_mono_shared_libs(env, mono_root, template_mono_root_dir)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
Mono: Add mono_bcl SCons option for a custom BCL location Makes it let's bothersome to work with builds from our godotengine/godot-mono-builds scripts, as they write the BCL into an output directory separate from the runtime (which is good as two runtimes may share the same BCL).
2020-12-06 08:15:17 +08:00
def copy_mono_root_files(env, mono_root, mono_bcl):
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
from glob import glob
from shutil import copy
from shutil import rmtree
if not mono_root:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
raise RuntimeError("Mono installation directory not found")
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
output_dir = Dir("#bin").abspath
editor_mono_root_dir = os.path.join(output_dir, "GodotSharp", "Mono")
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
if os.path.isdir(editor_mono_root_dir):
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
rmtree(editor_mono_root_dir) # Clean first
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
# Copy etc/mono/
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
editor_mono_config_dir = os.path.join(editor_mono_root_dir, "etc", "mono")
copy_mono_etc_dir(mono_root, editor_mono_config_dir, env["platform"])
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
# Copy the required shared libraries
Android build and export for the mono module
2019-05-21 00:34:35 +08:00
copy_mono_shared_libs(env, mono_root, editor_mono_root_dir)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
# Copy framework assemblies
Mono: Add mono_bcl SCons option for a custom BCL location Makes it let's bothersome to work with builds from our godotengine/godot-mono-builds scripts, as they write the BCL into an output directory separate from the runtime (which is good as two runtimes may share the same BCL).
2020-12-06 08:15:17 +08:00
mono_framework_dir = mono_bcl or os.path.join(mono_root, "lib", "mono", "4.5")
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
mono_framework_facades_dir = os.path.join(mono_framework_dir, "Facades")
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
editor_mono_framework_dir = os.path.join(editor_mono_root_dir, "lib", "mono", "4.5")
editor_mono_framework_facades_dir = os.path.join(editor_mono_framework_dir, "Facades")
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
if not os.path.isdir(editor_mono_framework_dir):
os.makedirs(editor_mono_framework_dir)
if not os.path.isdir(editor_mono_framework_facades_dir):
os.makedirs(editor_mono_framework_facades_dir)
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
for assembly in glob(os.path.join(mono_framework_dir, "*.dll")):
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
copy(assembly, editor_mono_framework_dir)
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
for assembly in glob(os.path.join(mono_framework_facades_dir, "*.dll")):
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
copy(assembly, editor_mono_framework_facades_dir)
def copy_mono_etc_dir(mono_root, target_mono_config_dir, platform):
from distutils.dir_util import copy_tree
from glob import glob
from shutil import copy
if not os.path.isdir(target_mono_config_dir):
os.makedirs(target_mono_config_dir)
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
mono_etc_dir = os.path.join(mono_root, "etc", "mono")
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
if not os.path.isdir(mono_etc_dir):
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
mono_etc_dir = ""
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
etc_hint_dirs = []
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
if platform != "windows":
etc_hint_dirs += ["/etc/mono", "/usr/local/etc/mono"]
if "MONO_CFG_DIR" in os.environ:
etc_hint_dirs += [os.path.join(os.environ["MONO_CFG_DIR"], "mono")]
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
for etc_hint_dir in etc_hint_dirs:
if os.path.isdir(etc_hint_dir):
mono_etc_dir = etc_hint_dir
break
if not mono_etc_dir:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
raise RuntimeError("Mono installation etc directory not found")
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
copy_tree(os.path.join(mono_etc_dir, "2.0"), os.path.join(target_mono_config_dir, "2.0"))
copy_tree(os.path.join(mono_etc_dir, "4.0"), os.path.join(target_mono_config_dir, "4.0"))
copy_tree(os.path.join(mono_etc_dir, "4.5"), os.path.join(target_mono_config_dir, "4.5"))
if os.path.isdir(os.path.join(mono_etc_dir, "mconfig")):
copy_tree(os.path.join(mono_etc_dir, "mconfig"), os.path.join(target_mono_config_dir, "mconfig"))
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
for file in glob(os.path.join(mono_etc_dir, "*")):
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
if os.path.isfile(file):
copy(file, target_mono_config_dir)
Android build and export for the mono module
2019-05-21 00:34:35 +08:00
def copy_mono_shared_libs(env, mono_root, target_mono_root_dir):
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
from shutil import copy
Android build and export for the mono module
2019-05-21 00:34:35 +08:00
def copy_if_exists(src, dst):
if os.path.isfile(src):
copy(src, dst)
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
platform = env["platform"]
Android build and export for the mono module
2019-05-21 00:34:35 +08:00
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
if platform == "windows":
src_mono_bin_dir = os.path.join(mono_root, "bin")
target_mono_bin_dir = os.path.join(target_mono_root_dir, "bin")
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
if not os.path.isdir(target_mono_bin_dir):
os.makedirs(target_mono_bin_dir)
Mono/C#: Fix MinGW build not supporting `.lib` libraries MinGW should support both its own format `.a` and MSVC's format `.lib`, but Mono's module was only using the former. With this change it's now possible to build with MinGW and link the official Mono for Windows which is built with MSVC.
2020-03-19 00:38:53 +08:00
mono_posix_helper_file = find_file_in_dir(
src_mono_bin_dir, ["MonoPosixHelper"], prefixes=["", "lib"], extensions=[".dll"]
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
)
copy(
Mono/C#: Fix MinGW build not supporting `.lib` libraries MinGW should support both its own format `.a` and MSVC's format `.lib`, but Mono's module was only using the former. With this change it's now possible to build with MinGW and link the official Mono for Windows which is built with MSVC.
2020-03-19 00:38:53 +08:00
os.path.join(src_mono_bin_dir, mono_posix_helper_file),
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
os.path.join(target_mono_bin_dir, "MonoPosixHelper.dll"),
)
Mono/C#: Bundle libmono-btls-shared.dll on Windows if it exists
2019-11-20 00:22:06 +08:00
# For newer versions
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
btls_dll_path = os.path.join(src_mono_bin_dir, "libmono-btls-shared.dll")
Mono/C#: Bundle libmono-btls-shared.dll on Windows if it exists
2019-11-20 00:22:06 +08:00
if os.path.isfile(btls_dll_path):
copy(btls_dll_path, target_mono_bin_dir)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
else:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
target_mono_lib_dir = (
get_android_out_dir(env) if platform == "android" else os.path.join(target_mono_root_dir, "lib")
)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
if not os.path.isdir(target_mono_lib_dir):
os.makedirs(target_mono_lib_dir)
Mono: Copy native and btls libs on macOS
2019-12-18 15:39:37 +08:00
lib_file_names = []
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
if platform == "osx":
lib_file_names = [
lib_name + ".dylib"
for lib_name in ["libmono-btls-shared", "libmono-native-compat", "libMonoPosixHelper"]
]
Mono/C#: WebAssembly support
2019-11-11 00:10:38 +08:00
elif is_unix_like(platform):
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
lib_file_names = [
lib_name + ".so"
for lib_name in [
"libmono-btls-shared",
"libmono-ee-interp",
"libmono-native",
"libMonoPosixHelper",
"libmono-profiler-aot",
"libmono-profiler-coverage",
"libmono-profiler-log",
"libMonoSupportW",
]
]
Android build and export for the mono module
2019-05-21 00:34:35 +08:00
Mono: Copy native and btls libs on macOS
2019-12-18 15:39:37 +08:00
for lib_file_name in lib_file_names:
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
copy_if_exists(os.path.join(mono_root, "lib", lib_file_name), target_mono_lib_dir)
Mono: Reorganize build scripts All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.
2019-03-02 04:51:20 +08:00
def pkgconfig_try_find_mono_root(mono_lib_names, sharedlib_ext):
tmpenv = Environment()
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
tmpenv.AppendENVPath("PKG_CONFIG_PATH", os.getenv("PKG_CONFIG_PATH"))
tmpenv.ParseConfig("pkg-config monosgen-2 --libs-only-L")
for hint_dir in tmpenv["LIBPATH"]:
Mono/C#: Fix MinGW build not supporting `.lib` libraries MinGW should support both its own format `.a` and MSVC's format `.lib`, but Mono's module was only using the former. With this change it's now possible to build with MinGW and link the official Mono for Windows which is built with MSVC.
2020-03-19 00:38:53 +08:00
name_found = find_name_in_dir_files(hint_dir, mono_lib_names, prefixes=["lib"], extensions=[sharedlib_ext])
SCons: Format buildsystem files with psf/black Configured for a max line length of 120 characters. psf/black is very opinionated and purposely doesn't leave much room for configuration. The output is mostly OK so that should be fine for us, but some things worth noting: - Manually wrapped strings will be reflowed, so by using a line length of 120 for the sake of preserving readability for our long command calls, it also means that some manually wrapped strings are back on the same line and should be manually merged again. - Code generators using string concatenation extensively look awful, since black puts each operand on a single line. We need to refactor these generators to use more pythonic string formatting, for which many options are available (`%`, `format` or f-strings). - CI checks and a pre-commit hook will be added to ensure that future buildsystem changes are well-formatted.
2020-03-30 14:28:32 +08:00
if name_found and os.path.isdir(os.path.join(hint_dir, "..", "include", "mono-2.0")):
return os.path.join(hint_dir, "..")
return ""
Reference in New Issue Copy Permalink