Merge pull request godotengine#105621 from Repiteo/scons/begin-decouple

SCons: Begin decoupling generation & build code

Author: Repiteo

core/SCsub

@@ -1,14 +1,14 @@
 #!/usr/bin/env python
 from misc.utility.scons_hints import *
 
-Import("env")
-
 import os
 
 import core_builders
 
 import methods
 
+Import("env")
+
 env.core_sources = []
 
 # Add required thirdparty code.
@@ -161,96 +161,34 @@ env.core_sources += thirdparty_obj
 
 
 # Godot source files
-
 env.add_source_files(env.core_sources, "*.cpp")
 
-
 # Generate disabled classes
-def disabled_class_builder(target, source, env):
-    with methods.generated_wrapper(str(target[0])) as file:
-        for c in source[0].read():
-            if cs := c.strip():
-                file.write(f"#define ClassDB_Disable_{cs} 1\n")
-
-
-env.CommandNoCache("disabled_classes.gen.h", env.Value(env.disabled_classes), env.Run(disabled_class_builder))
-
+env.CommandNoCache(
+    "disabled_classes.gen.h", env.Value(env.disabled_classes), env.Run(core_builders.disabled_class_builder)
+)
 
 # Generate version info
-def version_info_builder(target, source, env):
-    with methods.generated_wrapper(str(target[0])) as file:
-        file.write(
-            """\
-#define GODOT_VERSION_SHORT_NAME "{short_name}"
-#define GODOT_VERSION_NAME "{name}"
-#define GODOT_VERSION_MAJOR {major}
-#define GODOT_VERSION_MINOR {minor}
-#define GODOT_VERSION_PATCH {patch}
-#define GODOT_VERSION_STATUS "{status}"
-#define GODOT_VERSION_BUILD "{build}"
-#define GODOT_VERSION_MODULE_CONFIG "{module_config}"
-#define GODOT_VERSION_WEBSITE "{website}"
-#define GODOT_VERSION_DOCS_BRANCH "{docs_branch}"
-#define GODOT_VERSION_DOCS_URL "https://docs.godotengine.org/en/" GODOT_VERSION_DOCS_BRANCH
-""".format(**source[0].read())
-        )
-
-
 env.CommandNoCache(
     "version_generated.gen.h",
     env.Value(methods.get_version_info(env.module_version_string)),
-    env.Run(version_info_builder),
+    env.Run(core_builders.version_info_builder),
 )
 
-
 # Generate version hash
-def version_hash_builder(target, source, env):
-    with methods.generated_wrapper(str(target[0])) as file:
-        file.write(
-            """\
-#include "core/version.h"
-
-const char *const GODOT_VERSION_HASH = "{git_hash}";
-const uint64_t GODOT_VERSION_TIMESTAMP = {git_timestamp};
-""".format(**source[0].read())
-        )
-
-
-gen_hash = env.CommandNoCache("version_hash.gen.cpp", env.Value(methods.get_git_info()), env.Run(version_hash_builder))
+gen_hash = env.CommandNoCache(
+    "version_hash.gen.cpp", env.Value(methods.get_git_info()), env.Run(core_builders.version_hash_builder)
+)
 env.add_source_files(env.core_sources, gen_hash)
 
-
 # Generate AES256 script encryption key
-def encryption_key_builder(target, source, env):
-    with methods.generated_wrapper(str(target[0])) as file:
-        file.write(
-            f"""\
-#include "core/config/project_settings.h"
-
-uint8_t script_encryption_key[32] = {{
-	{source[0]}
-}};"""
-        )
-
-
-gdkey = os.environ.get("SCRIPT_AES256_ENCRYPTION_KEY", "0" * 64)
-ec_valid = len(gdkey) == 64
-if ec_valid:
-    try:
-        gdkey = ", ".join([str(int(f"{a}{b}", 16)) for a, b in zip(gdkey[0::2], gdkey[1::2])])
-    except Exception:
-        ec_valid = False
-if not ec_valid:
-    methods.print_error(
-        f'Invalid AES256 encryption key, not 64 hexadecimal characters: "{gdkey}".\n'
-        "Unset `SCRIPT_AES256_ENCRYPTION_KEY` in your environment "
-        "or make sure that it contains exactly 64 hexadecimal characters."
-    )
-    Exit(255)
-gen_encrypt = env.CommandNoCache("script_encryption_key.gen.cpp", env.Value(gdkey), env.Run(encryption_key_builder))
+gen_encrypt = env.CommandNoCache(
+    "script_encryption_key.gen.cpp",
+    env.Value(os.environ.get("SCRIPT_AES256_ENCRYPTION_KEY")),
+    env.Run(core_builders.encryption_key_builder),
+)
 env.add_source_files(env.core_sources, gen_encrypt)
 
-
 # Certificates
 env.CommandNoCache(
     "#core/io/certs_compressed.gen.h",

core/core_builders.py

@@ -6,15 +6,80 @@
 import methods
 
 
+# Generate disabled classes
+def disabled_class_builder(target, source, env):
+    with methods.generated_wrapper(str(target[0])) as file:
+        for c in source[0].read():
+            if cs := c.strip():
+                file.write(f"#define ClassDB_Disable_{cs} 1\n")
+
+
+# Generate version info
+def version_info_builder(target, source, env):
+    with methods.generated_wrapper(str(target[0])) as file:
+        file.write(
+            """\
+#define GODOT_VERSION_SHORT_NAME "{short_name}"
+#define GODOT_VERSION_NAME "{name}"
+#define GODOT_VERSION_MAJOR {major}
+#define GODOT_VERSION_MINOR {minor}
+#define GODOT_VERSION_PATCH {patch}
+#define GODOT_VERSION_STATUS "{status}"
+#define GODOT_VERSION_BUILD "{build}"
+#define GODOT_VERSION_MODULE_CONFIG "{module_config}"
+#define GODOT_VERSION_WEBSITE "{website}"
+#define GODOT_VERSION_DOCS_BRANCH "{docs_branch}"
+#define GODOT_VERSION_DOCS_URL "https://docs.godotengine.org/en/" GODOT_VERSION_DOCS_BRANCH
+""".format(**source[0].read())
+        )
+
+
+def version_hash_builder(target, source, env):
+    with methods.generated_wrapper(str(target[0])) as file:
+        file.write(
+            """\
+#include "core/version.h"
+
+const char *const GODOT_VERSION_HASH = "{git_hash}";
+const uint64_t GODOT_VERSION_TIMESTAMP = {git_timestamp};
+""".format(**source[0].read())
+        )
+
+
+def encryption_key_builder(target, source, env):
+    src = source[0].read() or "0" * 64
+    try:
+        buffer = bytes.fromhex(src)
+        if len(buffer) != 32:
+            raise ValueError
+    except ValueError:
+        methods.print_error(
+            f'Invalid AES256 encryption key, not 64 hexadecimal characters: "{src}".\n'
+            "Unset `SCRIPT_AES256_ENCRYPTION_KEY` in your environment "
+            "or make sure that it contains exactly 64 hexadecimal characters."
+        )
+        raise
+
+    with methods.generated_wrapper(str(target[0])) as file:
+        file.write(
+            f"""\
+#include "core/config/project_settings.h"
+
+uint8_t script_encryption_key[32] = {{
+	{methods.format_buffer(buffer, 1)}
+}};"""
+        )
+
+
 def make_certs_header(target, source, env):
     buffer = methods.get_buffer(str(source[0]))
     decomp_size = len(buffer)
     buffer = methods.compress_buffer(buffer)
 
     with methods.generated_wrapper(str(target[0])) as file:
         # System certs path. Editor will use them if defined. (for package maintainers)
-        file.write('#define _SYSTEM_CERTS_PATH "{}"\n'.format(env["system_certs_path"]))
-        if env["builtin_certs"]:
+        file.write(f'#define _SYSTEM_CERTS_PATH "{source[2]}"\n')
+        if source[1].read():
             # Defined here and not in env so changing it does not trigger a full rebuild.
             file.write(f"""\
 #define BUILTIN_CERTS_ENABLED

editor/SCsub

@@ -1,64 +1,25 @@
 #!/usr/bin/env python
 from misc.utility.scons_hints import *
 
-Import("env")
-
-env.editor_sources = []
-
 import os
 
 import editor_builders
 
-import methods
+Import("env")
+
+env.editor_sources = []
 
 if env.editor_build:
     # Generate doc data paths
-    def doc_data_class_path_builder(target, source, env):
-        paths = dict(sorted(source[0].read().items()))
-        data = "\n".join([f'\t{{"{key}", "{value}"}},' for key, value in paths.items()])
-        with methods.generated_wrapper(str(target[0])) as file:
-            file.write(
-                f"""\
-struct _DocDataClassPath {{
-	const char *name;
-	const char *path;
-}};
-
-inline constexpr int _doc_data_class_path_count = {len(paths)};
-inline constexpr _DocDataClassPath _doc_data_class_paths[{len(env.doc_class_path) + 1}] = {{
-{data}
-	{{nullptr, nullptr}},
-}};
-"""
-            )
-
-    env.CommandNoCache("doc_data_class_path.gen.h", env.Value(env.doc_class_path), env.Run(doc_data_class_path_builder))
+    env.CommandNoCache(
+        "doc_data_class_path.gen.h", env.Value(env.doc_class_path), env.Run(editor_builders.doc_data_class_path_builder)
+    )
 
     # Register exporters
-    def register_exporters_builder(target, source, env):
-        platforms = source[0].read()
-        exp_inc = "\n".join([f'#include "platform/{p}/export/export.h"' for p in platforms])
-        exp_reg = "\n".join([f"\tregister_{p}_exporter();" for p in platforms])
-        exp_type = "\n".join([f"\tregister_{p}_exporter_types();" for p in platforms])
-        with methods.generated_wrapper(str(target[0])) as file:
-            file.write(
-                f"""\
-#include "register_exporters.h"
-
-{exp_inc}
-
-void register_exporters() {{
-{exp_reg}
-}}
-
-void register_exporter_types() {{
-{exp_type}
-}}
-"""
-            )
-
     gen_exporters = env.CommandNoCache(
-        "register_exporters.gen.cpp", env.Value(env.platform_exporters), env.Run(register_exporters_builder)
+        "register_exporters.gen.cpp",
+        env.Value(env.platform_exporters),
+        env.Run(editor_builders.register_exporters_builder),
     )
     for e in env.platform_exporters:
         # Add all .cpp files in export folder

editor/editor_builders.py

@@ -9,6 +9,49 @@
 import methods
 
 
+def doc_data_class_path_builder(target, source, env):
+    paths = dict(sorted(source[0].read().items()))
+    data = "\n".join([f'\t{{"{key}", "{value}"}},' for key, value in paths.items()])
+    with methods.generated_wrapper(str(target[0])) as file:
+        file.write(
+            f"""\
+struct _DocDataClassPath {{
+	const char *name;
+	const char *path;
+}};
+
+inline constexpr int _doc_data_class_path_count = {len(paths)};
+inline constexpr _DocDataClassPath _doc_data_class_paths[{len(paths) + 1}] = {{
+	{data}
+	{{nullptr, nullptr}},
+}};
+"""
+        )
+
+
+def register_exporters_builder(target, source, env):
+    platforms = source[0].read()
+    exp_inc = "\n".join([f'#include "platform/{p}/export/export.h"' for p in platforms])
+    exp_reg = "\n\t".join([f"register_{p}_exporter();" for p in platforms])
+    exp_type = "\n\t".join([f"register_{p}_exporter_types();" for p in platforms])
+    with methods.generated_wrapper(str(target[0])) as file:
+        file.write(
+            f"""\
+#include "register_exporters.h"
+
+{exp_inc}
+
+void register_exporters() {{
+	{exp_reg}
+}}
+
+void register_exporter_types() {{
+	{exp_type}
+}}
+"""
+        )
+
+
 def make_doc_header(target, source, env):
     buffer = b"".join([methods.get_buffer(src) for src in map(str, source)])
     decomp_size = len(buffer)