Mono: Reorganize build scripts

All build scripts, other than config.py and SCSub, are now located in the build_scripts subdirectory.

8 files changed, 762 insertions, 741 deletions

diff --git a/modules/mono/SCsub b/modules/mono/SCsub
index b6ba9b1c23..ddead44219 100644
--- a/modules/mono/SCsub
+++ b/modules/mono/SCsub
@@ -5,70 +5,6 @@ Import('env_modules')
 
 env_mono = env_modules.Clone()
 
-# TODO move functions to their own modules
-
-def make_cs_files_header(src, dst, version_dst):
-    from compat import byte_to_str
-
-    with open(dst, 'w') as header:
-        header.write('/* THIS FILE IS GENERATED DO NOT EDIT */\n')
-        header.write('#ifndef CS_COMPRESSED_H\n')
-        header.write('#define CS_COMPRESSED_H\n\n')
-        header.write('#ifdef TOOLS_ENABLED\n\n')
-        header.write('#include "core/map.h"\n')
-        header.write('#include "core/ustring.h"\n')
-        inserted_files = ''
-        import os
-        latest_mtime = 0
-        cs_file_count = 0
-        for root, _, files in os.walk(src):
-            files = [f for f in files if f.endswith('.cs')]
-            for file in files:
-                cs_file_count += 1
-                filepath = os.path.join(root, file)
-                filepath_src_rel = os.path.relpath(filepath, src)
-                mtime = os.path.getmtime(filepath)
-                latest_mtime = mtime if mtime > latest_mtime else latest_mtime
-                with open(filepath, 'rb') as f:
-                    buf = f.read()
-                    decomp_size = len(buf)
-                    import zlib
-                    buf = zlib.compress(buf)
-                    name = str(cs_file_count)
-                    header.write('\n')
-                    header.write('// ' + filepath_src_rel + '\n')
-                    header.write('static const int _cs_' + name + '_compressed_size = ' + str(len(buf)) + ';\n')
-                    header.write('static const int _cs_' + name + '_uncompressed_size = ' + str(decomp_size) + ';\n')
-                    header.write('static const unsigned char _cs_' + name + '_compressed[] = { ')
-                    for i, buf_idx in enumerate(range(len(buf))):
-                        if i > 0:
-                            header.write(', ')
-                        header.write(byte_to_str(buf[buf_idx]))
-                    inserted_files += '\tr_files.insert("' + filepath_src_rel.replace('\\', '\\\\') + '", ' \
-                                        'CompressedFile(_cs_' + name + '_compressed_size, ' \
-                                        '_cs_' + name + '_uncompressed_size, ' \
-                                        '_cs_' + name + '_compressed));\n'
-                    header.write(' };\n')
-        header.write('\nstruct CompressedFile\n' '{\n'
-            '\tint compressed_size;\n' '\tint uncompressed_size;\n' '\tconst unsigned char* data;\n'
-            '\n\tCompressedFile(int p_comp_size, int p_uncomp_size, const unsigned char* p_data)\n'
-            '\t{\n' '\t\tcompressed_size = p_comp_size;\n' '\t\tuncompressed_size = p_uncomp_size;\n'
-            '\t\tdata = p_data;\n' '\t}\n' '\n\tCompressedFile() {}\n' '};\n'
-            '\nvoid get_compressed_files(Map<String, CompressedFile>& r_files)\n' '{\n' + inserted_files + '}\n'
-            )
-        header.write('\n#endif // TOOLS_ENABLED\n')
-        header.write('\n#endif // CS_COMPRESSED_H\n')
-
-        glue_version = int(latest_mtime) # The latest modified time will do for now
-
-        with open(version_dst, 'w') as version_header:
-            version_header.write('/* THIS FILE IS GENERATED DO NOT EDIT */\n')
-            version_header.write('#ifndef CS_GLUE_VERSION_H\n')
-            version_header.write('#define CS_GLUE_VERSION_H\n\n')
-            version_header.write('#define CS_GLUE_VERSION UINT32_C(' + str(glue_version) + ')\n')
-            version_header.write('\n#endif // CS_GLUE_VERSION_H\n')
-
-
 env_mono.add_source_files(env.modules_sources, '*.cpp')
 env_mono.add_source_files(env.modules_sources, 'glue/*.cpp')
 env_mono.add_source_files(env.modules_sources, 'mono_gd/*.cpp')
@@ -77,7 +13,12 @@ env_mono.add_source_files(env.modules_sources, 'utils/*.cpp')
 if env['tools']:
     env_mono.add_source_files(env.modules_sources, 'editor/*.cpp')
     # NOTE: It is safe to generate this file here, since this is still executed serially
-    make_cs_files_header('glue/Managed/Files', 'glue/cs_compressed.gen.h', 'glue/cs_glue_version.gen.h')
+    import build_scripts.make_cs_compressed_header as make_cs_compressed_header
+    make_cs_compressed_header.generate_header(
+        'glue/Managed/Files',
+        'glue/cs_compressed.gen.h',
+        'glue/cs_glue_version.gen.h'
+    )
 
 vars = Variables()
 vars.Add(BoolVariable('mono_glue', 'Build with the mono glue sources', True))
@@ -88,272 +29,29 @@ vars.Update(env_mono)
 if env_mono['mono_glue']:
     env_mono.Append(CPPDEFINES=['MONO_GLUE_ENABLED'])
 
+    import os.path
+    if not os.path.isfile('glue/mono_glue.gen.cpp'):
+        raise RuntimeError('Missing mono glue sources. Did you forget to generate them?')
+
 if env_mono['tools'] or env_mono['target'] != 'release':
     env_mono.Append(CPPDEFINES=['GD_MONO_HOT_RELOAD'])
 
-# Configure TLS checks
+# Configure Thread Local Storage
+
+import build_scripts.tls_configure as tls_configure
 
-import tls_configure
 conf = Configure(env_mono)
 tls_configure.configure(conf)
 env_mono = conf.Finish()
 
+# Configure Mono
 
-# Build GodotSharpTools solution
-
-
-import os
-
-
-def find_nuget_unix():
-    import os
-
-    if 'NUGET_PATH' in os.environ:
-        hint_path = os.environ['NUGET_PATH']
-        if os.path.isfile(hint_path) and os.access(hint_path, os.X_OK):
-            return hint_path
-        hint_path = os.path.join(hint_path, 'nuget')
-        if os.path.isfile(hint_path) and os.access(hint_path, os.X_OK):
-            return hint_path
-
-    import os.path
-    import sys
-
-    hint_dirs = ['/opt/novell/mono/bin']
-    if sys.platform == 'darwin':
-        hint_dirs = ['/Library/Frameworks/Mono.framework/Versions/Current/bin', '/usr/local/var/homebrew/linked/mono/bin'] + hint_dirs
-
-    for hint_dir in hint_dirs:
-        hint_path = os.path.join(hint_dir, 'nuget')
-        if os.path.isfile(hint_path):
-            return hint_path
-        elif os.path.isfile(hint_path + '.exe'):
-            return hint_path + '.exe'
-
-    for hint_dir in os.environ['PATH'].split(os.pathsep):
-        hint_dir = hint_dir.strip('"')
-        hint_path = os.path.join(hint_dir, 'nuget')
-        if os.path.isfile(hint_path) and os.access(hint_path, os.X_OK):
-            return hint_path
-        if os.path.isfile(hint_path + '.exe') and os.access(hint_path + '.exe', os.X_OK):
-            return hint_path + '.exe'
-
-    return None
-
-
-def find_nuget_windows():
-    import os
-
-    if 'NUGET_PATH' in os.environ:
-        hint_path = os.environ['NUGET_PATH']
-        if os.path.isfile(hint_path) and os.access(hint_path, os.X_OK):
-            return hint_path
-        hint_path = os.path.join(hint_path, 'nuget.exe')
-        if os.path.isfile(hint_path) and os.access(hint_path, os.X_OK):
-            return hint_path
-
-    import mono_reg_utils as monoreg
-
-    mono_root = ''
-    bits = env['bits']
-
-    if bits == '32':
-        if os.getenv('MONO32_PREFIX'):
-            mono_root = os.getenv('MONO32_PREFIX')
-        else:
-            mono_root = monoreg.find_mono_root_dir(bits)
-    else:
-        if os.getenv('MONO64_PREFIX'):
-            mono_root = os.getenv('MONO64_PREFIX')
-        else:
-            mono_root = monoreg.find_mono_root_dir(bits)
-
-    if mono_root:
-        mono_bin_dir = os.path.join(mono_root, 'bin')
-        nuget_mono = os.path.join(mono_bin_dir, 'nuget.bat')
-
-        if os.path.isfile(nuget_mono):
-            return nuget_mono
-
-    # Standalone NuGet
-
-    for hint_dir in os.environ['PATH'].split(os.pathsep):
-        hint_dir = hint_dir.strip('"')
-        hint_path = os.path.join(hint_dir, 'nuget.exe')
-        if os.path.isfile(hint_path) and os.access(hint_path, os.X_OK):
-            return hint_path
-
-    return None
-
-
-def find_msbuild_unix(filename):
-    import os.path
-    import sys
-
-    hint_dirs = ['/opt/novell/mono/bin']
-    if sys.platform == 'darwin':
-        hint_dirs = ['/Library/Frameworks/Mono.framework/Versions/Current/bin', '/usr/local/var/homebrew/linked/mono/bin'] + hint_dirs
-
-    for hint_dir in hint_dirs:
-        hint_path = os.path.join(hint_dir, filename)
-        if os.path.isfile(hint_path):
-            return hint_path
-        elif os.path.isfile(hint_path + '.exe'):
-            return hint_path + '.exe'
+import build_scripts.mono_configure as mono_configure
 
-    for hint_dir in os.environ['PATH'].split(os.pathsep):
-        hint_dir = hint_dir.strip('"')
-        hint_path = os.path.join(hint_dir, filename)
-        if os.path.isfile(hint_path) and os.access(hint_path, os.X_OK):
-            return hint_path
-        if os.path.isfile(hint_path + '.exe') and os.access(hint_path + '.exe', os.X_OK):
-            return hint_path + '.exe'
+mono_configure.configure(env)
 
-    return None
+# Build GodotSharpTools
 
+import build_scripts.godotsharptools_build as godotsharptools_build
 
-def find_msbuild_windows():
-    import mono_reg_utils as monoreg
-
-    mono_root = ''
-    bits = env['bits']
-
-    if bits == '32':
-        if os.getenv('MONO32_PREFIX'):
-            mono_root = os.getenv('MONO32_PREFIX')
-        else:
-            mono_root = monoreg.find_mono_root_dir(bits)
-    else:
-        if os.getenv('MONO64_PREFIX'):
-            mono_root = os.getenv('MONO64_PREFIX')
-        else:
-            mono_root = monoreg.find_mono_root_dir(bits)
-
-    if not mono_root:
-        raise RuntimeError('Cannot find mono root directory')
-
-    framework_path = os.path.join(mono_root, 'lib', 'mono', '4.5')
-    mono_bin_dir = os.path.join(mono_root, 'bin')
-    msbuild_mono = os.path.join(mono_bin_dir, 'msbuild.bat')
-
-    if os.path.isfile(msbuild_mono):
-        # The (Csc/Vbc/Fsc)ToolExe environment variables are required when
-        # building with Mono's MSBuild. They must point to the batch files
-        # in Mono's bin directory to make sure they are executed with Mono.
-        mono_msbuild_env = {
-            'CscToolExe': os.path.join(mono_bin_dir, 'csc.bat'),
-            'VbcToolExe': os.path.join(mono_bin_dir, 'vbc.bat'),
-            'FscToolExe': os.path.join(mono_bin_dir, 'fsharpc.bat')
-        }
-        return (msbuild_mono, framework_path, mono_msbuild_env)
-
-    msbuild_tools_path = monoreg.find_msbuild_tools_path_reg()
-
-    if msbuild_tools_path:
-        return (os.path.join(msbuild_tools_path, 'MSBuild.exe'), framework_path, {})
-
-    return None
-
-
-def mono_build_solution(source, target, env):
-    import subprocess
-    from shutil import copyfile
-
-    sln_path = os.path.abspath(str(source[0]))
-    target_path = os.path.abspath(str(target[0]))
-
-    framework_path = ''
-    msbuild_env = os.environ.copy()
-
-    # Needed when running from Developer Command Prompt for VS
-    if 'PLATFORM' in msbuild_env:
-        del msbuild_env['PLATFORM']
-
-    # Find MSBuild
-    if os.name == 'nt':
-        msbuild_info = find_msbuild_windows()
-        if msbuild_info is None:
-            raise RuntimeError('Cannot find MSBuild executable')
-        msbuild_path = msbuild_info[0]
-        framework_path = msbuild_info[1]
-        msbuild_env.update(msbuild_info[2])
-    else:
-        msbuild_path = find_msbuild_unix('msbuild')
-        if msbuild_path is None:
-            xbuild_fallback = env['xbuild_fallback']
-
-            if xbuild_fallback and os.name == 'nt':
-                print('Option \'xbuild_fallback\' not supported on Windows')
-                xbuild_fallback = False
-
-            if xbuild_fallback:
-                print('Cannot find MSBuild executable, trying with xbuild')
-                print('Warning: xbuild is deprecated')
-
-                msbuild_path = find_msbuild_unix('xbuild')
-
-                if msbuild_path is None:
-                    raise RuntimeError('Cannot find xbuild executable')
-            else:
-                raise RuntimeError('Cannot find MSBuild executable')
-
-    print('MSBuild path: ' + msbuild_path)
-
-    # Find NuGet
-    nuget_path = find_nuget_windows() if os.name == 'nt' else find_nuget_unix()
-    if nuget_path is None:
-        raise RuntimeError('Cannot find NuGet executable')
-
-    print('NuGet path: ' + nuget_path)
-
-    # Do NuGet restore
-
-    try:
-        subprocess.check_call([nuget_path, 'restore', sln_path])
-    except subprocess.CalledProcessError:
-        raise RuntimeError('GodotSharpTools: NuGet restore failed')
-
-    # Build solution
-
-    build_config = 'Release'
-
-    msbuild_args = [
-        msbuild_path,
-        sln_path,
-        '/p:Configuration=' + build_config,
-    ]
-
-    if framework_path:
-        msbuild_args += ['/p:FrameworkPathOverride=' + framework_path]
-
-    try:
-        subprocess.check_call(msbuild_args, env=msbuild_env)
-    except subprocess.CalledProcessError:
-        raise RuntimeError('GodotSharpTools: Build failed')
-
-    # Copy files
-
-    src_dir = os.path.abspath(os.path.join(sln_path, os.pardir, 'bin', build_config))
-    dst_dir = os.path.abspath(os.path.join(target_path, os.pardir))
-    asm_file = 'GodotSharpTools.dll'
-
-    if not os.path.isdir(dst_dir):
-        if os.path.exists(dst_dir):
-            raise RuntimeError('Target directory is a file')
-        os.makedirs(dst_dir)
-
-    copyfile(os.path.join(src_dir, asm_file), os.path.join(dst_dir, asm_file))
-
-    # Dependencies
-    copyfile(os.path.join(src_dir, "DotNet.Glob.dll"), os.path.join(dst_dir, "DotNet.Glob.dll"))
-
-if env['tools']:
-    output_dir = Dir('#bin').abspath
-    editor_tools_dir = os.path.join(output_dir, 'GodotSharp', 'Tools')
-
-    mono_sln_builder = Builder(action=mono_build_solution)
-    env_mono.Append(BUILDERS={'MonoBuildSolution': mono_sln_builder})
-    env_mono.MonoBuildSolution(
-        os.path.join(editor_tools_dir, 'GodotSharpTools.dll'),
-        'editor/GodotSharpTools/GodotSharpTools.sln'
-    )
+godotsharptools_build.build(env_mono)
diff --git a/modules/mono/build_scripts/__init__.py b/modules/mono/build_scripts/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/modules/mono/build_scripts/__init__.py
diff --git a/modules/mono/build_scripts/godotsharptools_build.py b/modules/mono/build_scripts/godotsharptools_build.py
new file mode 100644
index 0000000000..af3a5cb5c6
--- /dev/null
+++ b/modules/mono/build_scripts/godotsharptools_build.py
@@ -0,0 +1,263 @@
+# Build GodotSharpTools solution
+
+
+import os
+
+from SCons.Script import Builder, Dir
+
+
+def find_nuget_unix():
+    import os
+
+    if 'NUGET_PATH' in os.environ:
+        hint_path = os.environ['NUGET_PATH']
+        if os.path.isfile(hint_path) and os.access(hint_path, os.X_OK):
+            return hint_path
+        hint_path = os.path.join(hint_path, 'nuget')
+        if os.path.isfile(hint_path) and os.access(hint_path, os.X_OK):
+            return hint_path
+
+    import os.path
+    import sys
+
+    hint_dirs = ['/opt/novell/mono/bin']
+    if sys.platform == 'darwin':
+        hint_dirs = ['/Library/Frameworks/Mono.framework/Versions/Current/bin', '/usr/local/var/homebrew/linked/mono/bin'] + hint_dirs
+
+    for hint_dir in hint_dirs:
+        hint_path = os.path.join(hint_dir, 'nuget')
+        if os.path.isfile(hint_path):
+            return hint_path
+        elif os.path.isfile(hint_path + '.exe'):
+            return hint_path + '.exe'
+
+    for hint_dir in os.environ['PATH'].split(os.pathsep):
+        hint_dir = hint_dir.strip('"')
+        hint_path = os.path.join(hint_dir, 'nuget')
+        if os.path.isfile(hint_path) and os.access(hint_path, os.X_OK):
+            return hint_path
+        if os.path.isfile(hint_path + '.exe') and os.access(hint_path + '.exe', os.X_OK):
+            return hint_path + '.exe'
+
+    return None
+
+
+def find_nuget_windows(env):
+    import os
+
+    if 'NUGET_PATH' in os.environ:
+        hint_path = os.environ['NUGET_PATH']
+        if os.path.isfile(hint_path) and os.access(hint_path, os.X_OK):
+            return hint_path
+        hint_path = os.path.join(hint_path, 'nuget.exe')
+        if os.path.isfile(hint_path) and os.access(hint_path, os.X_OK):
+            return hint_path
+
+    from . import mono_reg_utils as monoreg
+
+    mono_root = ''
+    bits = env['bits']
+
+    if bits == '32':
+        if os.getenv('MONO32_PREFIX'):
+            mono_root = os.getenv('MONO32_PREFIX')
+        else:
+            mono_root = monoreg.find_mono_root_dir(bits)
+    else:
+        if os.getenv('MONO64_PREFIX'):
+            mono_root = os.getenv('MONO64_PREFIX')
+        else:
+            mono_root = monoreg.find_mono_root_dir(bits)
+
+    if mono_root:
+        mono_bin_dir = os.path.join(mono_root, 'bin')
+        nuget_mono = os.path.join(mono_bin_dir, 'nuget.bat')
+
+        if os.path.isfile(nuget_mono):
+            return nuget_mono
+
+    # Standalone NuGet
+
+    for hint_dir in os.environ['PATH'].split(os.pathsep):
+        hint_dir = hint_dir.strip('"')
+        hint_path = os.path.join(hint_dir, 'nuget.exe')
+        if os.path.isfile(hint_path) and os.access(hint_path, os.X_OK):
+            return hint_path
+
+    return None
+
+
+def find_msbuild_unix(filename):
+    import os.path
+    import sys
+
+    hint_dirs = ['/opt/novell/mono/bin']
+    if sys.platform == 'darwin':
+        hint_dirs = ['/Library/Frameworks/Mono.framework/Versions/Current/bin', '/usr/local/var/homebrew/linked/mono/bin'] + hint_dirs
+
+    for hint_dir in hint_dirs:
+        hint_path = os.path.join(hint_dir, filename)
+        if os.path.isfile(hint_path):
+            return hint_path
+        elif os.path.isfile(hint_path + '.exe'):
+            return hint_path + '.exe'
+
+    for hint_dir in os.environ['PATH'].split(os.pathsep):
+        hint_dir = hint_dir.strip('"')
+        hint_path = os.path.join(hint_dir, filename)
+        if os.path.isfile(hint_path) and os.access(hint_path, os.X_OK):
+            return hint_path
+        if os.path.isfile(hint_path + '.exe') and os.access(hint_path + '.exe', os.X_OK):
+            return hint_path + '.exe'
+
+    return None
+
+
+def find_msbuild_windows(env):
+    from . import mono_reg_utils as monoreg
+
+    mono_root = ''
+    bits = env['bits']
+
+    if bits == '32':
+        if os.getenv('MONO32_PREFIX'):
+            mono_root = os.getenv('MONO32_PREFIX')
+        else:
+            mono_root = monoreg.find_mono_root_dir(bits)
+    else:
+        if os.getenv('MONO64_PREFIX'):
+            mono_root = os.getenv('MONO64_PREFIX')
+        else:
+            mono_root = monoreg.find_mono_root_dir(bits)
+
+    if not mono_root:
+        raise RuntimeError('Cannot find mono root directory')
+
+    framework_path = os.path.join(mono_root, 'lib', 'mono', '4.5')
+    mono_bin_dir = os.path.join(mono_root, 'bin')
+    msbuild_mono = os.path.join(mono_bin_dir, 'msbuild.bat')
+
+    if os.path.isfile(msbuild_mono):
+        # The (Csc/Vbc/Fsc)ToolExe environment variables are required when
+        # building with Mono's MSBuild. They must point to the batch files
+        # in Mono's bin directory to make sure they are executed with Mono.
+        mono_msbuild_env = {
+            'CscToolExe': os.path.join(mono_bin_dir, 'csc.bat'),
+            'VbcToolExe': os.path.join(mono_bin_dir, 'vbc.bat'),
+            'FscToolExe': os.path.join(mono_bin_dir, 'fsharpc.bat')
+        }
+        return (msbuild_mono, framework_path, mono_msbuild_env)
+
+    msbuild_tools_path = monoreg.find_msbuild_tools_path_reg()
+
+    if msbuild_tools_path:
+        return (os.path.join(msbuild_tools_path, 'MSBuild.exe'), framework_path, {})
+
+    return None
+
+
+def mono_build_solution(source, target, env):
+    import subprocess
+    from shutil import copyfile
+
+    sln_path = os.path.abspath(str(source[0]))
+    target_path = os.path.abspath(str(target[0]))
+
+    framework_path = ''
+    msbuild_env = os.environ.copy()
+
+    # Needed when running from Developer Command Prompt for VS
+    if 'PLATFORM' in msbuild_env:
+        del msbuild_env['PLATFORM']
+
+    # Find MSBuild
+    if os.name == 'nt':
+        msbuild_info = find_msbuild_windows(env)
+        if msbuild_info is None:
+            raise RuntimeError('Cannot find MSBuild executable')
+        msbuild_path = msbuild_info[0]
+        framework_path = msbuild_info[1]
+        msbuild_env.update(msbuild_info[2])
+    else:
+        msbuild_path = find_msbuild_unix('msbuild')
+        if msbuild_path is None:
+            xbuild_fallback = env['xbuild_fallback']
+
+            if xbuild_fallback and os.name == 'nt':
+                print('Option \'xbuild_fallback\' not supported on Windows')
+                xbuild_fallback = False
+
+            if xbuild_fallback:
+                print('Cannot find MSBuild executable, trying with xbuild')
+                print('Warning: xbuild is deprecated')
+
+                msbuild_path = find_msbuild_unix('xbuild')
+
+                if msbuild_path is None:
+                    raise RuntimeError('Cannot find xbuild executable')
+            else:
+                raise RuntimeError('Cannot find MSBuild executable')
+
+    print('MSBuild path: ' + msbuild_path)
+
+    # Find NuGet
+    nuget_path = find_nuget_windows(env) if os.name == 'nt' else find_nuget_unix()
+    if nuget_path is None:
+        raise RuntimeError('Cannot find NuGet executable')
+
+    print('NuGet path: ' + nuget_path)
+
+    # Do NuGet restore
+
+    try:
+        subprocess.check_call([nuget_path, 'restore', sln_path])
+    except subprocess.CalledProcessError:
+        raise RuntimeError('GodotSharpTools: NuGet restore failed')
+
+    # Build solution
+
+    build_config = 'Release'
+
+    msbuild_args = [
+        msbuild_path,
+        sln_path,
+        '/p:Configuration=' + build_config,
+    ]
+
+    if framework_path:
+        msbuild_args += ['/p:FrameworkPathOverride=' + framework_path]
+
+    try:
+        subprocess.check_call(msbuild_args, env=msbuild_env)
+    except subprocess.CalledProcessError:
+        raise RuntimeError('GodotSharpTools: Build failed')
+
+    # Copy files
+
+    src_dir = os.path.abspath(os.path.join(sln_path, os.pardir, 'bin', build_config))
+    dst_dir = os.path.abspath(os.path.join(target_path, os.pardir))
+    asm_file = 'GodotSharpTools.dll'
+
+    if not os.path.isdir(dst_dir):
+        if os.path.exists(dst_dir):
+            raise RuntimeError('Target directory is a file')
+        os.makedirs(dst_dir)
+
+    copyfile(os.path.join(src_dir, asm_file), os.path.join(dst_dir, asm_file))
+
+    # Dependencies
+    copyfile(os.path.join(src_dir, "DotNet.Glob.dll"), os.path.join(dst_dir, "DotNet.Glob.dll"))
+
+def build(env_mono):
+    if not env_mono['tools']:
+        return
+
+    output_dir = Dir('#bin').abspath
+    editor_tools_dir = os.path.join(output_dir, 'GodotSharp', 'Tools')
+
+    mono_sln_builder = Builder(action=mono_build_solution)
+    env_mono.Append(BUILDERS={'MonoBuildSolution': mono_sln_builder})
+    env_mono.MonoBuildSolution(
+        os.path.join(editor_tools_dir, 'GodotSharpTools.dll'),
+        'editor/GodotSharpTools/GodotSharpTools.sln'
+    )
diff --git a/modules/mono/build_scripts/make_cs_compressed_header.py b/modules/mono/build_scripts/make_cs_compressed_header.py
new file mode 100644
index 0000000000..1f9177cef8
--- /dev/null
+++ b/modules/mono/build_scripts/make_cs_compressed_header.py
@@ -0,0 +1,61 @@
+
+def generate_header(src, dst, version_dst):
+    from compat import byte_to_str
+
+    with open(dst, 'w') as header:
+        header.write('/* THIS FILE IS GENERATED DO NOT EDIT */\n')
+        header.write('#ifndef CS_COMPRESSED_H\n')
+        header.write('#define CS_COMPRESSED_H\n\n')
+        header.write('#ifdef TOOLS_ENABLED\n\n')
+        header.write('#include "core/map.h"\n')
+        header.write('#include "core/ustring.h"\n')
+        inserted_files = ''
+        import os
+        latest_mtime = 0
+        cs_file_count = 0
+        for root, _, files in os.walk(src):
+            files = [f for f in files if f.endswith('.cs')]
+            for file in files:
+                cs_file_count += 1
+                filepath = os.path.join(root, file)
+                filepath_src_rel = os.path.relpath(filepath, src)
+                mtime = os.path.getmtime(filepath)
+                latest_mtime = mtime if mtime > latest_mtime else latest_mtime
+                with open(filepath, 'rb') as f:
+                    buf = f.read()
+                    decomp_size = len(buf)
+                    import zlib
+                    buf = zlib.compress(buf)
+                    name = str(cs_file_count)
+                    header.write('\n')
+                    header.write('// ' + filepath_src_rel + '\n')
+                    header.write('static const int _cs_' + name + '_compressed_size = ' + str(len(buf)) + ';\n')
+                    header.write('static const int _cs_' + name + '_uncompressed_size = ' + str(decomp_size) + ';\n')
+                    header.write('static const unsigned char _cs_' + name + '_compressed[] = { ')
+                    for i, buf_idx in enumerate(range(len(buf))):
+                        if i > 0:
+                            header.write(', ')
+                        header.write(byte_to_str(buf[buf_idx]))
+                    inserted_files += '\tr_files.insert("' + filepath_src_rel.replace('\\', '\\\\') + '", ' \
+                                        'CompressedFile(_cs_' + name + '_compressed_size, ' \
+                                        '_cs_' + name + '_uncompressed_size, ' \
+                                        '_cs_' + name + '_compressed));\n'
+                    header.write(' };\n')
+        header.write('\nstruct CompressedFile\n' '{\n'
+            '\tint compressed_size;\n' '\tint uncompressed_size;\n' '\tconst unsigned char* data;\n'
+            '\n\tCompressedFile(int p_comp_size, int p_uncomp_size, const unsigned char* p_data)\n'
+            '\t{\n' '\t\tcompressed_size = p_comp_size;\n' '\t\tuncompressed_size = p_uncomp_size;\n'
+            '\t\tdata = p_data;\n' '\t}\n' '\n\tCompressedFile() {}\n' '};\n'
+            '\nvoid get_compressed_files(Map<String, CompressedFile>& r_files)\n' '{\n' + inserted_files + '}\n'
+            )
+        header.write('\n#endif // TOOLS_ENABLED\n')
+        header.write('\n#endif // CS_COMPRESSED_H\n')
+
+        glue_version = int(latest_mtime) # The latest modified time will do for now
+
+        with open(version_dst, 'w') as version_header:
+            version_header.write('/* THIS FILE IS GENERATED DO NOT EDIT */\n')
+            version_header.write('#ifndef CS_GLUE_VERSION_H\n')
+            version_header.write('#define CS_GLUE_VERSION_H\n\n')
+            version_header.write('#define CS_GLUE_VERSION UINT32_C(' + str(glue_version) + ')\n')
+            version_header.write('\n#endif // CS_GLUE_VERSION_H\n')
diff --git a/modules/mono/build_scripts/mono_configure.py b/modules/mono/build_scripts/mono_configure.py
new file mode 100644
index 0000000000..a9db1d0446
--- /dev/null
+++ b/modules/mono/build_scripts/mono_configure.py
@@ -0,0 +1,413 @@
+import imp
+import os
+import sys
+import subprocess
+
+from distutils.version import LooseVersion
+from SCons.Script import BoolVariable, Dir, Environment, Variables
+
+if os.name == 'nt':
+    from . import mono_reg_utils as monoreg
+
+
+def find_file_in_dir(directory, files, prefix='', extension=''):
+    if not extension.startswith('.'):
+        extension = '.' + extension
+    for curfile in files:
+        if os.path.isfile(os.path.join(directory, prefix + curfile + extension)):
+            return curfile
+    return ''
+
+
+def copy_file(src_dir, dst_dir, name):
+    from shutil import copyfile
+
+    src_path = os.path.join(src_dir, name)
+    dst_path = os.path.join(dst_dir, name)
+
+    if not os.path.isdir(dst_dir):
+        os.mkdir(dst_dir)
+
+    copyfile(src_path, dst_path)
+
+
+def configure(env):
+    envvars = Variables()
+    envvars.Add(BoolVariable('mono_static', 'Statically link mono', False))
+    envvars.Add(BoolVariable('copy_mono_root', 'Make a copy of the mono installation directory to bundle with the editor', False))
+    envvars.Update(env)
+
+    bits = env['bits']
+
+    tools_enabled = env['tools']
+    mono_static = env['mono_static']
+    copy_mono_root = env['copy_mono_root']
+
+    mono_lib_names = ['mono-2.0-sgen', 'monosgen-2.0']
+
+    if env['platform'] == 'windows':
+        mono_root = ''
+
+        if bits == '32':
+            if os.getenv('MONO32_PREFIX'):
+                mono_root = os.getenv('MONO32_PREFIX')
+            elif os.name == 'nt':
+                mono_root = monoreg.find_mono_root_dir(bits)
+        else:
+            if os.getenv('MONO64_PREFIX'):
+                mono_root = os.getenv('MONO64_PREFIX')
+            elif os.name == 'nt':
+                mono_root = monoreg.find_mono_root_dir(bits)
+
+        if not mono_root:
+            raise RuntimeError('Mono installation directory not found')
+
+        print('Found Mono root directory: ' + mono_root)
+
+        mono_version = mono_root_try_find_mono_version(mono_root)
+        configure_for_mono_version(env, mono_version)
+
+        mono_lib_path = os.path.join(mono_root, 'lib')
+
+        env.Append(LIBPATH=mono_lib_path)
+        env.Append(CPPPATH=os.path.join(mono_root, 'include', 'mono-2.0'))
+
+        if mono_static:
+            lib_suffix = Environment()['LIBSUFFIX']
+
+            if env.msvc:
+                mono_static_lib_name = 'libmono-static-sgen'
+            else:
+                mono_static_lib_name = 'libmonosgen-2.0'
+
+            if not os.path.isfile(os.path.join(mono_lib_path, mono_static_lib_name + lib_suffix)):
+                raise RuntimeError('Could not find static mono library in: ' + mono_lib_path)
+
+            if env.msvc:
+                env.Append(LINKFLAGS=mono_static_lib_name + lib_suffix)
+
+                env.Append(LINKFLAGS='Mincore' + lib_suffix)
+                env.Append(LINKFLAGS='msvcrt' + lib_suffix)
+                env.Append(LINKFLAGS='LIBCMT' + lib_suffix)
+                env.Append(LINKFLAGS='Psapi' + lib_suffix)
+            else:
+                env.Append(LINKFLAGS=os.path.join(mono_lib_path, mono_static_lib_name + lib_suffix))
+
+                env.Append(LIBS='psapi')
+                env.Append(LIBS='version')
+        else:
+            mono_lib_name = find_file_in_dir(mono_lib_path, mono_lib_names, extension='.lib')
+
+            if not mono_lib_name:
+                raise RuntimeError('Could not find mono library in: ' + mono_lib_path)
+
+            if env.msvc:
+                env.Append(LINKFLAGS=mono_lib_name + Environment()['LIBSUFFIX'])
+            else:
+                env.Append(LIBS=mono_lib_name)
+
+            mono_bin_path = os.path.join(mono_root, 'bin')
+
+            mono_dll_name = find_file_in_dir(mono_bin_path, mono_lib_names, extension='.dll')
+
+            if not mono_dll_name:
+                raise RuntimeError('Could not find mono shared library in: ' + mono_bin_path)
+
+            copy_file(mono_bin_path, 'bin', mono_dll_name + '.dll')
+    else:
+        is_apple = (sys.platform == 'darwin' or "osxcross" in env)
+
+        sharedlib_ext = '.dylib' if is_apple else '.so'
+
+        mono_root = ''
+        mono_lib_path = ''
+
+        if bits == '32':
+            if os.getenv('MONO32_PREFIX'):
+                mono_root = os.getenv('MONO32_PREFIX')
+        else:
+            if os.getenv('MONO64_PREFIX'):
+                mono_root = os.getenv('MONO64_PREFIX')
+
+        if not mono_root and is_apple:
+            # Try with some known directories under OSX
+            hint_dirs = ['/Library/Frameworks/Mono.framework/Versions/Current', '/usr/local/var/homebrew/linked/mono']
+            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:
+                raise RuntimeError('Building with mono_static=yes, but failed to find the mono prefix with pkg-config. Specify one manually')
+
+        if mono_root:
+            print('Found Mono root directory: ' + mono_root)
+
+            mono_version = mono_root_try_find_mono_version(mono_root)
+            configure_for_mono_version(env, mono_version)
+
+            mono_lib_path = os.path.join(mono_root, 'lib')
+
+            env.Append(LIBPATH=mono_lib_path)
+            env.Append(CPPPATH=os.path.join(mono_root, 'include', 'mono-2.0'))
+
+            mono_lib = find_file_in_dir(mono_lib_path, mono_lib_names, prefix='lib', extension='.a')
+
+            if not mono_lib:
+                raise RuntimeError('Could not find mono library in: ' + mono_lib_path)
+
+            env.Append(CPPFLAGS=['-D_REENTRANT'])
+
+            if mono_static:
+                mono_lib_file = os.path.join(mono_lib_path, 'lib' + mono_lib + '.a')
+
+                if is_apple:
+                    env.Append(LINKFLAGS=['-Wl,-force_load,' + mono_lib_file])
+                else:
+                    env.Append(LINKFLAGS=['-Wl,-whole-archive', mono_lib_file, '-Wl,-no-whole-archive'])
+            else:
+                env.Append(LIBS=[mono_lib])
+
+            if is_apple:
+                env.Append(LIBS=['iconv', 'pthread'])
+            else:
+                env.Append(LIBS=['m', 'rt', 'dl', 'pthread'])
+
+            if not mono_static:
+                mono_so_name = find_file_in_dir(mono_lib_path, mono_lib_names, prefix='lib', extension=sharedlib_ext)
+
+                if not mono_so_name:
+                    raise RuntimeError('Could not find mono shared library in: ' + mono_lib_path)
+
+                copy_file(mono_lib_path, 'bin', 'lib' + mono_so_name + sharedlib_ext)
+        else:
+            assert not mono_static
+
+            # TODO: Add option to force using pkg-config
+            print('Mono root directory not found. Using pkg-config instead')
+
+            mono_version = pkgconfig_try_find_mono_version()
+            configure_for_mono_version(env, mono_version)
+
+            env.ParseConfig('pkg-config monosgen-2 --cflags --libs')
+
+            mono_lib_path = ''
+            mono_so_name = ''
+
+            tmpenv = Environment()
+            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']:
+                name_found = find_file_in_dir(hint_dir, mono_lib_names, prefix='lib', extension=sharedlib_ext)
+                if name_found:
+                    mono_lib_path = hint_dir
+                    mono_so_name = name_found
+                    break
+
+            if not mono_so_name:
+                raise RuntimeError('Could not find mono shared library in: ' + str(tmpenv['LIBPATH']))
+
+            copy_file(mono_lib_path, 'bin', 'lib' + mono_so_name + sharedlib_ext)
+
+        env.Append(LINKFLAGS='-rdynamic')
+
+    if not tools_enabled:
+        if not mono_root:
+            mono_root = subprocess.check_output(['pkg-config', 'mono-2', '--variable=prefix']).decode('utf8').strip()
+
+        make_template_dir(env, mono_root)
+
+    if copy_mono_root:
+        if not mono_root:
+            mono_root = subprocess.check_output(['pkg-config', 'mono-2', '--variable=prefix']).decode('utf8').strip()
+
+        if tools_enabled:
+           copy_mono_root_files(env, mono_root)
+        else:
+            print("Ignoring option: 'copy_mono_root'. Only available for builds with 'tools' enabled.")
+
+
+def make_template_dir(env, mono_root):
+    from shutil import rmtree
+
+    platform = env['platform']
+    target = env['target']
+
+    template_dir_name = ''
+
+    if platform in ['windows', 'osx', 'x11']:
+        template_dir_name = 'data.mono.%s.%s.%s' % (platform, env['bits'], target)
+    else:
+        assert False
+
+    output_dir = Dir('#bin').abspath
+    template_dir = os.path.join(output_dir, template_dir_name)
+
+    template_mono_root_dir = os.path.join(template_dir, 'Mono')
+
+    if os.path.isdir(template_mono_root_dir):
+        rmtree(template_mono_root_dir) # Clean first
+
+    # Copy etc/mono/
+
+    template_mono_config_dir = os.path.join(template_mono_root_dir, 'etc', 'mono')
+    copy_mono_etc_dir(mono_root, template_mono_config_dir, env['platform'])
+
+    # Copy the required shared libraries
+
+    copy_mono_shared_libs(mono_root, template_mono_root_dir, env['platform'])
+
+
+def copy_mono_root_files(env, mono_root):
+    from glob import glob
+    from shutil import copy
+    from shutil import rmtree
+
+    if not mono_root:
+        raise RuntimeError('Mono installation directory not found')
+
+    output_dir = Dir('#bin').abspath
+    editor_mono_root_dir = os.path.join(output_dir, 'GodotSharp', 'Mono')
+
+    if os.path.isdir(editor_mono_root_dir):
+        rmtree(editor_mono_root_dir) # Clean first
+
+    # Copy etc/mono/
+
+    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'])
+
+    # Copy the required shared libraries
+
+    copy_mono_shared_libs(mono_root, editor_mono_root_dir, env['platform'])
+
+    # Copy framework assemblies
+
+    mono_framework_dir = os.path.join(mono_root, 'lib', 'mono', '4.5')
+    mono_framework_facades_dir = os.path.join(mono_framework_dir, 'Facades')
+
+    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')
+
+    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)
+
+    for assembly in glob(os.path.join(mono_framework_dir, '*.dll')):
+        copy(assembly, editor_mono_framework_dir)
+    for assembly in glob(os.path.join(mono_framework_facades_dir, '*.dll')):
+        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)
+
+    mono_etc_dir = os.path.join(mono_root, 'etc', 'mono')
+    if not os.path.isdir(mono_etc_dir):
+        mono_etc_dir = ''
+        etc_hint_dirs = []
+        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')]
+        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:
+            raise RuntimeError('Mono installation etc directory not found')
+
+    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'))
+    copy_tree(os.path.join(mono_etc_dir, 'mconfig'), os.path.join(target_mono_config_dir, 'mconfig'))
+
+    for file in glob(os.path.join(mono_etc_dir, '*')):
+        if os.path.isfile(file):
+            copy(file, target_mono_config_dir)
+
+
+def copy_mono_shared_libs(mono_root, target_mono_root_dir, platform):
+    from shutil import copy
+
+    if platform == 'windows':
+        target_mono_bin_dir = os.path.join(target_mono_root_dir, 'bin')
+
+        if not os.path.isdir(target_mono_bin_dir):
+            os.makedirs(target_mono_bin_dir)
+
+        copy(os.path.join(mono_root, 'bin', 'MonoPosixHelper.dll'), os.path.join(target_mono_bin_dir, 'MonoPosixHelper.dll'))
+    else:
+        target_mono_lib_dir = os.path.join(target_mono_root_dir, 'lib')
+
+        if not os.path.isdir(target_mono_lib_dir):
+            os.makedirs(target_mono_lib_dir)
+
+        if platform == 'osx':
+            copy(os.path.join(mono_root, 'lib', 'libMonoPosixHelper.dylib'), os.path.join(target_mono_lib_dir, 'libMonoPosixHelper.dylib'))
+        elif platform == 'x11':
+            copy(os.path.join(mono_root, 'lib', 'libmono-btls-shared.so'), os.path.join(target_mono_lib_dir, 'libmono-btls-shared.so'))
+            copy(os.path.join(mono_root, 'lib', 'libMonoPosixHelper.so'), os.path.join(target_mono_lib_dir, 'libMonoPosixHelper.so'))
+
+
+def configure_for_mono_version(env, mono_version):
+    if mono_version is None:
+        raise RuntimeError('Mono JIT compiler version not found')
+    print('Found Mono JIT compiler version: ' + str(mono_version))
+    if mono_version >= LooseVersion('5.12.0'):
+        env.Append(CPPFLAGS=['-DHAS_PENDING_EXCEPTIONS'])
+
+
+def pkgconfig_try_find_mono_root(mono_lib_names, sharedlib_ext):
+    tmpenv = Environment()
+    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']:
+        name_found = find_file_in_dir(hint_dir, mono_lib_names, prefix='lib', extension=sharedlib_ext)
+        if name_found and os.path.isdir(os.path.join(hint_dir, '..', 'include', 'mono-2.0')):
+            return os.path.join(hint_dir, '..')
+    return ''
+
+
+def pkgconfig_try_find_mono_version():
+    from compat import decode_utf8
+
+    lines = subprocess.check_output(['pkg-config', 'monosgen-2', '--modversion']).splitlines()
+    greater_version = None
+    for line in lines:
+        try:
+            version = LooseVersion(decode_utf8(line))
+            if greater_version is None or version > greater_version:
+                greater_version = version
+        except ValueError:
+            pass
+    return greater_version
+
+
+def mono_root_try_find_mono_version(mono_root):
+    from compat import decode_utf8
+
+    mono_bin = os.path.join(mono_root, 'bin')
+    if os.path.isfile(os.path.join(mono_bin, 'mono')):
+        mono_binary = os.path.join(mono_bin, 'mono')
+    elif os.path.isfile(os.path.join(mono_bin, 'mono.exe')):
+        mono_binary = os.path.join(mono_bin, 'mono.exe')
+    else:
+        return None
+    output = subprocess.check_output([mono_binary, '--version'])
+    first_line = decode_utf8(output.splitlines()[0])
+    try:
+        return LooseVersion(first_line.split()[len('Mono JIT compiler version'.split())])
+    except (ValueError, IndexError):
+        return None
diff --git a/modules/mono/mono_reg_utils.py b/modules/mono/build_scripts/mono_reg_utils.py
index 583708bf07..583708bf07 100644
--- a/modules/mono/mono_reg_utils.py
+++ b/modules/mono/build_scripts/mono_reg_utils.py
diff --git a/modules/mono/tls_configure.py b/modules/mono/build_scripts/tls_configure.py
index 622280b00b..622280b00b 100644
--- a/modules/mono/tls_configure.py
+++ b/modules/mono/build_scripts/tls_configure.py
diff --git a/modules/mono/config.py b/modules/mono/config.py
index 6b88600c56..3b2e96765e 100644
--- a/modules/mono/config.py
+++ b/modules/mono/config.py
@@ -1,25 +1,12 @@
-
-import imp
-import os
-import sys
-import subprocess
-
-from distutils.version import LooseVersion
-from SCons.Script import BoolVariable, Dir, Environment, Variables
-
-
-monoreg = imp.load_source('mono_reg_utils', 'modules/mono/mono_reg_utils.py')
-
-
 def can_build(env, platform):
     if platform in ['javascript']:
         return False # Not yet supported
     return True
 
 
-def is_enabled():
-    # The module is disabled by default. Use module_mono_enabled=yes to enable it.
-    return False
+def configure(env):
+    env.use_ptrcall = True
+    env.add_module_version_string('mono')
 
 
 def get_doc_classes():
@@ -34,407 +21,6 @@ def get_doc_path():
     return 'doc_classes'
 
 
-def find_file_in_dir(directory, files, prefix='', extension=''):
-    if not extension.startswith('.'):
-        extension = '.' + extension
-    for curfile in files:
-        if os.path.isfile(os.path.join(directory, prefix + curfile + extension)):
-            return curfile
-    return ''
-
-
-def copy_file(src_dir, dst_dir, name):
-    from shutil import copyfile
-
-    src_path = os.path.join(src_dir, name)
-    dst_path = os.path.join(dst_dir, name)
-
-    if not os.path.isdir(dst_dir):
-        os.mkdir(dst_dir)
-
-    copyfile(src_path, dst_path)
-
-
-def configure(env):
-    env.use_ptrcall = True
-    env.add_module_version_string('mono')
-
-    envvars = Variables()
-    envvars.Add(BoolVariable('mono_static', 'Statically link mono', False))
-    envvars.Add(BoolVariable('copy_mono_root', 'Make a copy of the mono installation directory to bundle with the editor', False))
-    envvars.Update(env)
-
-    bits = env['bits']
-
-    tools_enabled = env['tools']
-    mono_static = env['mono_static']
-    copy_mono_root = env['copy_mono_root']
-
-    mono_lib_names = ['mono-2.0-sgen', 'monosgen-2.0']
-
-    if env['platform'] == 'windows':
-        mono_root = ''
-
-        if bits == '32':
-            if os.getenv('MONO32_PREFIX'):
-                mono_root = os.getenv('MONO32_PREFIX')
-            elif os.name == 'nt':
-                mono_root = monoreg.find_mono_root_dir(bits)
-        else:
-            if os.getenv('MONO64_PREFIX'):
-                mono_root = os.getenv('MONO64_PREFIX')
-            elif os.name == 'nt':
-                mono_root = monoreg.find_mono_root_dir(bits)
-
-        if not mono_root:
-            raise RuntimeError('Mono installation directory not found')
-
-        print('Found Mono root directory: ' + mono_root)
-
-        mono_version = mono_root_try_find_mono_version(mono_root)
-        configure_for_mono_version(env, mono_version)
-
-        mono_lib_path = os.path.join(mono_root, 'lib')
-
-        env.Append(LIBPATH=mono_lib_path)
-        env.Append(CPPPATH=os.path.join(mono_root, 'include', 'mono-2.0'))
-
-        if mono_static:
-            lib_suffix = Environment()['LIBSUFFIX']
-
-            if env.msvc:
-                mono_static_lib_name = 'libmono-static-sgen'
-            else:
-                mono_static_lib_name = 'libmonosgen-2.0'
-
-            if not os.path.isfile(os.path.join(mono_lib_path, mono_static_lib_name + lib_suffix)):
-                raise RuntimeError('Could not find static mono library in: ' + mono_lib_path)
-
-            if env.msvc:
-                env.Append(LINKFLAGS=mono_static_lib_name + lib_suffix)
-
-                env.Append(LINKFLAGS='Mincore' + lib_suffix)
-                env.Append(LINKFLAGS='msvcrt' + lib_suffix)
-                env.Append(LINKFLAGS='LIBCMT' + lib_suffix)
-                env.Append(LINKFLAGS='Psapi' + lib_suffix)
-            else:
-                env.Append(LINKFLAGS=os.path.join(mono_lib_path, mono_static_lib_name + lib_suffix))
-
-                env.Append(LIBS='psapi')
-                env.Append(LIBS='version')
-        else:
-            mono_lib_name = find_file_in_dir(mono_lib_path, mono_lib_names, extension='.lib')
-
-            if not mono_lib_name:
-                raise RuntimeError('Could not find mono library in: ' + mono_lib_path)
-
-            if env.msvc:
-                env.Append(LINKFLAGS=mono_lib_name + Environment()['LIBSUFFIX'])
-            else:
-                env.Append(LIBS=mono_lib_name)
-
-            mono_bin_path = os.path.join(mono_root, 'bin')
-
-            mono_dll_name = find_file_in_dir(mono_bin_path, mono_lib_names, extension='.dll')
-
-            if not mono_dll_name:
-                raise RuntimeError('Could not find mono shared library in: ' + mono_bin_path)
-
-            copy_file(mono_bin_path, 'bin', mono_dll_name + '.dll')
-    else:
-        is_apple = (sys.platform == 'darwin' or "osxcross" in env)
-
-        sharedlib_ext = '.dylib' if is_apple else '.so'
-
-        mono_root = ''
-        mono_lib_path = ''
-
-        if bits == '32':
-            if os.getenv('MONO32_PREFIX'):
-                mono_root = os.getenv('MONO32_PREFIX')
-        else:
-            if os.getenv('MONO64_PREFIX'):
-                mono_root = os.getenv('MONO64_PREFIX')
-
-        if not mono_root and is_apple:
-            # Try with some known directories under OSX
-            hint_dirs = ['/Library/Frameworks/Mono.framework/Versions/Current', '/usr/local/var/homebrew/linked/mono']
-            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:
-                raise RuntimeError('Building with mono_static=yes, but failed to find the mono prefix with pkg-config. Specify one manually')
-
-        if mono_root:
-            print('Found Mono root directory: ' + mono_root)
-
-            mono_version = mono_root_try_find_mono_version(mono_root)
-            configure_for_mono_version(env, mono_version)
-
-            mono_lib_path = os.path.join(mono_root, 'lib')
-
-            env.Append(LIBPATH=mono_lib_path)
-            env.Append(CPPPATH=os.path.join(mono_root, 'include', 'mono-2.0'))
-
-            mono_lib = find_file_in_dir(mono_lib_path, mono_lib_names, prefix='lib', extension='.a')
-
-            if not mono_lib:
-                raise RuntimeError('Could not find mono library in: ' + mono_lib_path)
-
-            env.Append(CPPFLAGS=['-D_REENTRANT'])
-
-            if mono_static:
-                mono_lib_file = os.path.join(mono_lib_path, 'lib' + mono_lib + '.a')
-
-                if is_apple:
-                    env.Append(LINKFLAGS=['-Wl,-force_load,' + mono_lib_file])
-                else:
-                    env.Append(LINKFLAGS=['-Wl,-whole-archive', mono_lib_file, '-Wl,-no-whole-archive'])
-            else:
-                env.Append(LIBS=[mono_lib])
-
-            if is_apple:
-                env.Append(LIBS=['iconv', 'pthread'])
-            else:
-                env.Append(LIBS=['m', 'rt', 'dl', 'pthread'])
-
-            if not mono_static:
-                mono_so_name = find_file_in_dir(mono_lib_path, mono_lib_names, prefix='lib', extension=sharedlib_ext)
-
-                if not mono_so_name:
-                    raise RuntimeError('Could not find mono shared library in: ' + mono_lib_path)
-
-                copy_file(mono_lib_path, 'bin', 'lib' + mono_so_name + sharedlib_ext)
-        else:
-            assert not mono_static
-
-            # TODO: Add option to force using pkg-config
-            print('Mono root directory not found. Using pkg-config instead')
-
-            mono_version = pkgconfig_try_find_mono_version()
-            configure_for_mono_version(env, mono_version)
-
-            env.ParseConfig('pkg-config monosgen-2 --cflags --libs')
-
-            mono_lib_path = ''
-            mono_so_name = ''
-
-            tmpenv = Environment()
-            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']:
-                name_found = find_file_in_dir(hint_dir, mono_lib_names, prefix='lib', extension=sharedlib_ext)
-                if name_found:
-                    mono_lib_path = hint_dir
-                    mono_so_name = name_found
-                    break
-
-            if not mono_so_name:
-                raise RuntimeError('Could not find mono shared library in: ' + str(tmpenv['LIBPATH']))
-
-            copy_file(mono_lib_path, 'bin', 'lib' + mono_so_name + sharedlib_ext)
-
-        env.Append(LINKFLAGS='-rdynamic')
-
-    if not tools_enabled:
-        if not mono_root:
-            mono_root = subprocess.check_output(['pkg-config', 'mono-2', '--variable=prefix']).decode('utf8').strip()
-
-        make_template_dir(env, mono_root)
-
-    if copy_mono_root:
-        if not mono_root:
-            mono_root = subprocess.check_output(['pkg-config', 'mono-2', '--variable=prefix']).decode('utf8').strip()
-
-        if tools_enabled:
-           copy_mono_root_files(env, mono_root)
-        else:
-            print("Ignoring option: 'copy_mono_root'. Only available for builds with 'tools' enabled.")
-
-
-def make_template_dir(env, mono_root):
-    from shutil import rmtree
-
-    platform = env['platform']
-    target = env['target']
-
-    template_dir_name = ''
-
-    if platform in ['windows', 'osx', 'x11']:
-        template_dir_name = 'data.mono.%s.%s.%s' % (platform, env['bits'], target)
-    else:
-        assert False
-
-    output_dir = Dir('#bin').abspath
-    template_dir = os.path.join(output_dir, template_dir_name)
-
-    template_mono_root_dir = os.path.join(template_dir, 'Mono')
-
-    if os.path.isdir(template_mono_root_dir):
-        rmtree(template_mono_root_dir) # Clean first
-
-    # Copy etc/mono/
-
-    template_mono_config_dir = os.path.join(template_mono_root_dir, 'etc', 'mono')
-    copy_mono_etc_dir(mono_root, template_mono_config_dir, env['platform'])
-
-    # Copy the required shared libraries
-
-    copy_mono_shared_libs(mono_root, template_mono_root_dir, env['platform'])
-
-
-def copy_mono_root_files(env, mono_root):
-    from glob import glob
-    from shutil import copy
-    from shutil import rmtree
-
-    if not mono_root:
-        raise RuntimeError('Mono installation directory not found')
-
-    output_dir = Dir('#bin').abspath
-    editor_mono_root_dir = os.path.join(output_dir, 'GodotSharp', 'Mono')
-
-    if os.path.isdir(editor_mono_root_dir):
-        rmtree(editor_mono_root_dir) # Clean first
-
-    # Copy etc/mono/
-
-    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'])
-
-    # Copy the required shared libraries
-
-    copy_mono_shared_libs(mono_root, editor_mono_root_dir, env['platform'])
-
-    # Copy framework assemblies
-
-    mono_framework_dir = os.path.join(mono_root, 'lib', 'mono', '4.5')
-    mono_framework_facades_dir = os.path.join(mono_framework_dir, 'Facades')
-
-    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')
-
-    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)
-
-    for assembly in glob(os.path.join(mono_framework_dir, '*.dll')):
-        copy(assembly, editor_mono_framework_dir)
-    for assembly in glob(os.path.join(mono_framework_facades_dir, '*.dll')):
-        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)
-
-    mono_etc_dir = os.path.join(mono_root, 'etc', 'mono')
-    if not os.path.isdir(mono_etc_dir):
-        mono_etc_dir = ''
-        etc_hint_dirs = []
-        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')]
-        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:
-            raise RuntimeError('Mono installation etc directory not found')
-
-    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'))
-    copy_tree(os.path.join(mono_etc_dir, 'mconfig'), os.path.join(target_mono_config_dir, 'mconfig'))
-
-    for file in glob(os.path.join(mono_etc_dir, '*')):
-        if os.path.isfile(file):
-            copy(file, target_mono_config_dir)
-
-
-def copy_mono_shared_libs(mono_root, target_mono_root_dir, platform):
-    from shutil import copy
-
-    if platform == 'windows':
-        target_mono_bin_dir = os.path.join(target_mono_root_dir, 'bin')
-
-        if not os.path.isdir(target_mono_bin_dir):
-            os.makedirs(target_mono_bin_dir)
-
-        copy(os.path.join(mono_root, 'bin', 'MonoPosixHelper.dll'), os.path.join(target_mono_bin_dir, 'MonoPosixHelper.dll'))
-    else:
-        target_mono_lib_dir = os.path.join(target_mono_root_dir, 'lib')
-
-        if not os.path.isdir(target_mono_lib_dir):
-            os.makedirs(target_mono_lib_dir)
-
-        if platform == 'osx':
-            copy(os.path.join(mono_root, 'lib', 'libMonoPosixHelper.dylib'), os.path.join(target_mono_lib_dir, 'libMonoPosixHelper.dylib'))
-        elif platform == 'x11':
-            copy(os.path.join(mono_root, 'lib', 'libmono-btls-shared.so'), os.path.join(target_mono_lib_dir, 'libmono-btls-shared.so'))
-            copy(os.path.join(mono_root, 'lib', 'libMonoPosixHelper.so'), os.path.join(target_mono_lib_dir, 'libMonoPosixHelper.so'))
-
-
-def configure_for_mono_version(env, mono_version):
-    if mono_version is None:
-        raise RuntimeError('Mono JIT compiler version not found')
-    print('Found Mono JIT compiler version: ' + str(mono_version))
-    if mono_version >= LooseVersion('5.12.0'):
-        env.Append(CPPFLAGS=['-DHAS_PENDING_EXCEPTIONS'])
-
-
-def pkgconfig_try_find_mono_root(mono_lib_names, sharedlib_ext):
-    tmpenv = Environment()
-    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']:
-        name_found = find_file_in_dir(hint_dir, mono_lib_names, prefix='lib', extension=sharedlib_ext)
-        if name_found and os.path.isdir(os.path.join(hint_dir, '..', 'include', 'mono-2.0')):
-            return os.path.join(hint_dir, '..')
-    return ''
-
-
-def pkgconfig_try_find_mono_version():
-    from compat import decode_utf8
-
-    lines = subprocess.check_output(['pkg-config', 'monosgen-2', '--modversion']).splitlines()
-    greater_version = None
-    for line in lines:
-        try:
-            version = LooseVersion(decode_utf8(line))
-            if greater_version is None or version > greater_version:
-                greater_version = version
-        except ValueError:
-            pass
-    return greater_version
-
-
-def mono_root_try_find_mono_version(mono_root):
-    from compat import decode_utf8
-
-    mono_bin = os.path.join(mono_root, 'bin')
-    if os.path.isfile(os.path.join(mono_bin, 'mono')):
-        mono_binary = os.path.join(mono_bin, 'mono')
-    elif os.path.isfile(os.path.join(mono_bin, 'mono.exe')):
-        mono_binary = os.path.join(mono_bin, 'mono.exe')
-    else:
-        return None
-    output = subprocess.check_output([mono_binary, '--version'])
-    first_line = decode_utf8(output.splitlines()[0])
-    try:
-        return LooseVersion(first_line.split()[len('Mono JIT compiler version'.split())])
-    except (ValueError, IndexError):
-        return None
+def is_enabled():
+    # The module is disabled by default. Use module_mono_enabled=yes to enable it.
+    return False