bytecode_generator.py

# This script generates the bytecode classes and headers for all bytecode versions defined in `misc/bytecode_versions.json`.
# This is to avoid the need to manually generate the bytecode classes and headers for each bytecode version.

import os
from pathlib import Path
import json

PRELUDE = """// This file is automatically generated by `bytecode_generator.py`
// Do not edit this file directly, as it will be overwritten.
// Instead, edit `bytecode_generator.py` and run it to generate this file.\n"""

CLANG_FORMAT_OFF = """\n// clang-format off\n"""

# literal integer max
INT_MAX = 2147483647

# TODO: Move this into the JSON file
builtin_func_arg_elements = [
    ("sin", (1, 1)),
    ("cos", (1, 1)),
    ("tan", (1, 1)),
    ("sinh", (1, 1)),
    ("cosh", (1, 1)),
    ("tanh", (1, 1)),
    ("asin", (1, 1)),
    ("acos", (1, 1)),
    ("atan", (1, 1)),
    ("atan2", (2, 2)),
    ("sqrt", (1, 1)),
    ("fmod", (2, 2)),
    ("fposmod", (2, 2)),
    ("posmod", (2, 2)),
    ("floor", (1, 1)),
    ("ceil", (1, 1)),
    ("round", (1, 1)),
    ("abs", (1, 1)),
    ("sign", (1, 1)),
    ("pow", (2, 2)),
    ("log", (1, 1)),
    ("exp", (1, 1)),
    ("is_nan", (1, 1)),
    ("is_inf", (1, 1)),
    ("is_equal_approx", (2, 2)),
    ("is_zero_approx", (1, 1)),
    ("ease", (2, 2)),
    ("decimals", (1, 1)),
    ("step_decimals", (1, 1)),
    ("stepify", (2, 2)),
    ("lerp", (3, 3)),
    ("lerp_angle", (3, 3)),
    ("inverse_lerp", (3, 3)),
    ("range_lerp", (5, 5)),
    ("smoothstep", (3, 3)),
    ("move_toward", (3, 3)),
    ("dectime", (3, 3)),
    ("randomize", (0, 0)),
    ("randi", (0, 0)),
    ("randf", (0, 0)),
    ("rand_range", (2, 2)),
    ("seed", (1, 1)),
    ("rand_seed", (1, 1)),
    ("deg2rad", (1, 1)),
    ("rad2deg", (1, 1)),
    ("linear2db", (1, 1)),
    ("db2linear", (1, 1)),
    ("polar2cartesian", (2, 2)),
    ("cartesian2polar", (2, 2)),
    ("wrapi", (3, 3)),
    ("wrapf", (3, 3)),
    ("max", (2, 2)),
    ("min", (2, 2)),
    ("clamp", (3, 3)),
    ("nearest_po2", (1, 1)),
    ("weakref", (1, 1)),
    ("funcref", (2, 2)),
    ("convert", (2, 2)),
    ("typeof", (1, 1)),
    ("type_exists", (1, 1)),
    ("char", (1, 1)),
    ("ord", (1, 1)),
    ("str", (1, INT_MAX)),
    ("print", (0, INT_MAX)),
    ("printt", (0, INT_MAX)),
    ("prints", (0, INT_MAX)),
    ("printerr", (0, INT_MAX)),
    ("printraw", (0, INT_MAX)),
    ("print_debug", (0, INT_MAX)),
    ("push_error", (1, 1)),
    ("push_warning", (1, 1)),
    ("var2str", (1, 1)),
    ("str2var", (1, 1)),
    ("var2bytes", (1, 1)),
    ("bytes2var", (1, 1)),
    ("range", (1, 3)),
    ("load", (1, 1)),
    ("inst2dict", (1, 1)),
    ("dict2inst", (1, 1)),
    ("validate_json", (1, 1)),
    ("parse_json", (1, 1)),
    ("to_json", (1, 1)),
    ("hash", (1, 1)),
    ("Color8", (3, 4)),
    ("ColorN", (1, 2)),
    ("print_stack", (0, 0)),
    ("get_stack", (0, 0)),
    ("instance_from_id", (1, 1)),
    ("len", (1, 1)),
    ("is_instance_valid", (1, 1)),
    ("deep_equal", (2, 2)),
    ("get_inst", (1, 1)),
]

greater_than_3_1_versions = [
    0xF3F05DC,
    0x506DF14,
    0xA7AAD78,
    0x5565F55,
    0x6694C11,
    0xA60F242,
    0xC00427A,
    0x620EC47,
    0x7F7D97F,
    0x514A3FB,
]


class BytecodeClass:
    def __init__(self):
        self.func_names: list[str] = []
        # self.func_arg_counts: dict[str, tuple[int, int]] = {}
        self.tk_names = []
        self.bytecode_version = 0
        self.bytecode_rev = ""
        self.bytecode_rev_num = 0
        self.engine_ver_major = 0
        self.variant_ver_major = 0
        self.parent = ""
        self.version_string = ""
        self.is_dev = False
        self.removed_tokens: list[str] = []
        self.added_tokens: list[str] = []
        self.removed_functions: list[str] = []
        self.added_functions: list[str] = []
        self.renamed_functions: dict[str, str] = {}
        self.arg_count_changed: list[str] = []
        self.tokens_renamed: dict[str, str] = {}
        self.date = ""
        self.engine_version = ""
        self.max_engine_version = ""

    @property
    def file_stem(self):
        return "bytecode_" + self.bytecode_rev

    @property
    def class_name(self):
        return "GDScriptDecomp_" + self.bytecode_rev


def remove_comments(line: str) -> str:
    line = line.strip()
    if line.startswith("//"):
        return ""
    line = line.split("//")[0].strip()
    return line


# Now, we need to generate the bytecode file
# The cpp file will contain the following:
# 1) the header declarations:
# ```cpp
#
# #include "<file_stem>.h"
# ```
# 2) the builtin function declarations, laid out like this:
# ```cpp
# static const Pair<String, Pair<int, int>> funcs[] = {
# 	{ "sin", Pair<int, int>(1, 1) },
#   { "cos", Pair<int, int>(1, 1) },
#   { "tan", Pair<int, int>(1, 1) },
#   { "sinh", Pair<int, int>(1, 1) },
# 	[etc...]
# 	{ "is_instance_valid", Pair<int, int>(1, 1) },
# };
# static constexpr int num_funcs = sizeof(funcs) / sizeof(Pair<String, Pair<int, int>>);
# ```
# We use a Pair here because we need to store the number of arguments for each function
# we get this by matching the function name with the builtin_func_arg_elements list
# with special care for the "var2bytes" and "bytes2var" functions, which have a variable number of arguments (1-2) IF the bytecode version is > 3.1
# 3) the Token enum declarations, like this:
# ```cpp
# enum Token {
# 	TK_EOF,
# 	TK_IDENTIFIER,
# 	TK_CONSTANT,
# 	[..etc]
#   TK_MAX
# };
# ```
# 4) the `get_function_name` function, which is laid out like this:
# ```cpp
# String <class_name>::get_function_name(int p_func) const {
# 	return funcs[p_func].first;
# }
# ```
# 5) the `get_function_arg_count` function, which is laid out like this:
# ```cpp
# Pair<int, int> <class_name>::get_function_arg_count(int p_func) const {
# 	return funcs[p_func].second;
# }
# ```
# 5.5) the `get_function_index` function, which is laid out like this:
# ```cpp
# int <class_name>::get_function_index(const String &p_func) const {
#   for (int i = 0; i < num_funcs; i++) {
#     if (funcs[i].first == p_func) {
#       return i;
#     }
#   return -1;
# }
# ```
# 6) the `get_global_token` function, which is laid out like this:
# ```cpp
# GDScriptDecomp::GlobalToken <class_name>::get_global_token(int p_token) const {
# 	if (p_token < 0 || p_token >= TK_MAX) {
# 		return GDScriptDecomp::GlobalToken::G_TK_MAX;
# 	}
# 	switch(Token(p_token)) {
# 		case TK_EOF: return GDScriptDecomp::GlobalToken::G_TK_EOF;
# 		case TK_IDENTIFIER: return GDScriptDecomp::GlobalToken::G_TK_IDENTIFIER;
# 		case TK_CONSTANT: return GDScriptDecomp::GlobalToken::G_TK_CONSTANT;
# 		[..etc]
# 		case TK_MAX: return GDScriptDecomp::GlobalToken::G_TK_MAX;
# 	}
# 	return GDScriptDecomp::GlobalToken::G_TK_MAX;
# }
# ```
# 7) the `get_local_token_val` function, which is laid out like this:
# ```cpp
# int <class_name>::get_local_token_val(GDScriptDecomp::GlobalToken p_token) const {
#   switch(p_token) {
#     case GDScriptDecomp::GlobalToken::G_TK_EOF: return (int) TK_EOF;
#     case GDScriptDecomp::GlobalToken::G_TK_IDENTIFIER: return (int) TK_IDENTIFIER;
#     case GDScriptDecomp::GlobalToken::G_TK_CONSTANT: return (int) TK_CONSTANT;
#     [..etc]
#     case GDScriptDecomp::GlobalToken::G_TK_MAX: return (int) TK_MAX;
#     default: return (int) TK_MAX;
#   }
#   return (int) TK_MAX;
# }
# ```
# That's it. We're done.


NO_BUILTIN_FUNCTION_BODY = """
String {0}::get_function_name(int p_func) const {{
    return "";
}}
int {0}::get_function_count() const {{
    return 0;
}}
Pair<int, int> {0}::get_function_arg_count(int p_func) const {{
    return Pair<int, int>(-1, -1);
}}
int {0}::get_function_index(const String &p_func) const {{
    return -1;
}}
"""


def generate_class_cpp(dir: Path, bytecode_class: BytecodeClass) -> None:
    file_stem = bytecode_class.file_stem
    class_name = bytecode_class.class_name
    func_names = bytecode_class.func_names
    tk_names = bytecode_class.tk_names
    bytecode_version = bytecode_class.bytecode_version
    bytecode_rev = bytecode_class.bytecode_rev
    bytecode_rev_num = bytecode_class.bytecode_rev_num
    engine_ver_major = bytecode_class.engine_ver_major
    variant_ver_major = bytecode_class.variant_ver_major
    new_dir = dir
    # ensure the directory exists
    if not new_dir.exists():
        new_dir.mkdir()
    new_file_cpp = new_dir / (file_stem + ".cpp")
    with open(new_file_cpp, "w") as f:
        f.write(PRELUDE)
        f.write(CLANG_FORMAT_OFF)
        # 1) the header declarations:
        f.write('#include "' + file_stem + '.h"\n')
        f.write("\n")

        # 2) the builtin function declarations:
        if len(func_names) != 0:
            f.write("static const Pair<String, Pair<int, int>> funcs[] = {\n")
            for func_name in func_names:
                if func_name == "var2bytes" or func_name == "bytes2var":
                    if bytecode_rev_num in greater_than_3_1_versions:
                        f.write('\t{ "' + func_name + '", Pair<int, int>(1, 2) },\n')
                    else:
                        f.write('\t{ "' + func_name + '", Pair<int, int>(1, 1) },\n')
                else:
                    for builtin_func_arg_element in builtin_func_arg_elements:
                        if builtin_func_arg_element[0] == func_name:
                            last_el = builtin_func_arg_element[1][1]
                            if last_el == INT_MAX:
                                last_el = "INT_MAX"
                            f.write(
                                '\t{ "'
                                + func_name
                                + '", Pair<int, int>('
                                + str(builtin_func_arg_element[1][0])
                                + ", "
                                + str(last_el)
                                + ") },\n"
                            )
                            break
            f.write("};\n")
            f.write("\n")
            f.write("static constexpr int num_funcs = sizeof(funcs) / sizeof(Pair<String, Pair<int, int>>);\n")
        # 3) the Token enum declarations:
        f.write("enum Token {\n")
        for tk_name in tk_names:
            f.write("\t" + tk_name + ",\n")
        f.write("};\n")
        f.write("\n")

        # 3.5) the `get_token_max` function:
        f.write("int " + class_name + "::get_token_max() const {\n")
        f.write("\treturn TK_MAX;\n")
        f.write("}\n")

        if len(func_names) == 0:
            f.write(NO_BUILTIN_FUNCTION_BODY.format(class_name))
        else:
            # 4) the `get_function_name` function:
            f.write("String " + class_name + "::get_function_name(int p_func) const {\n")
            f.write("\tif (p_func < 0 || p_func >= num_funcs) {\n")
            f.write('\t\treturn "";\n')
            f.write("\t}\n")
            f.write("\treturn funcs[p_func].first;\n")
            f.write("}\n")
            f.write("\n")

            # 4.5) the `get_function_count` function:
            f.write("int " + class_name + "::get_function_count() const {\n")
            f.write("\treturn num_funcs;\n")
            f.write("}\n")

            # 5) the `get_function_arg_count` function:
            f.write("Pair<int, int> " + class_name + "::get_function_arg_count(int p_func) const {\n")
            f.write("\tif (p_func < 0 || p_func >= num_funcs) {\n")
            f.write("\t\treturn Pair<int, int>(-1, -1);\n")
            f.write("\t}\n")
            f.write("\treturn funcs[p_func].second;\n")
            f.write("}\n")
            f.write("\n")

            f.write("\n")
            # 5.5) the `get_function_index` function:
            f.write("int " + class_name + "::get_function_index(const String &p_func) const {\n")
            f.write("\tfor (int i = 0; i < num_funcs; i++) {\n")
            f.write("\t\tif (funcs[i].first == p_func) {\n")
            f.write("\t\t\treturn i;\n")
            f.write("\t\t}\n")
            f.write("\t}\n")
            f.write("\treturn -1;\n")
            f.write("}\n")
            f.write("\n")

        # 6) the `get_global_token` function:
        f.write("GDScriptDecomp::GlobalToken " + class_name + "::get_global_token(int p_token) const {\n")
        f.write("\tp_token = p_token & TOKEN_MASK;\n")
        f.write("\tif (p_token < 0 || p_token >= TK_MAX) {\n")
        f.write("\t\treturn GDScriptDecomp::GlobalToken::G_TK_MAX;\n")
        f.write("\t}\n")
        f.write("\tswitch(Token(p_token)) {\n")
        for tk_name in tk_names:
            f.write("\t\tcase " + tk_name + ": return GDScriptDecomp::GlobalToken::G_" + tk_name + ";\n")
        f.write("\t\tdefault: return GDScriptDecomp::GlobalToken::G_TK_MAX;\n")
        f.write("\t}\n")
        f.write("\treturn GDScriptDecomp::GlobalToken::G_TK_MAX;\n")
        f.write("}\n")
        f.write("\n")

        # 7) the `get_local_token_val` function:
        f.write("int " + class_name + "::get_local_token_val(GDScriptDecomp::GlobalToken p_token) const {\n")
        f.write("\tswitch(p_token) {\n")
        for tk_name in tk_names:
            f.write("\t\tcase GDScriptDecomp::GlobalToken::G_" + tk_name + ": return (int) " + tk_name + ";\n")
        f.write("\t\tdefault: return -1;\n")
        f.write("\t}\n")
        f.write("\treturn -1;\n")
        f.write("}\n")
        f.write("\n")

        # 8) the `test_bytecode` function:
        # f.write("GDScriptDecomp::BYTECODE_TEST_RESULT " + class_name + "::test_bytecode(Vector<uint8_t> buffer) {\n")
        # f.write("\treturn GDScriptDecomp::test_bytecode(buffer);\n")
        # f.write("}\n")
        # f.write("\n")


def generate_class_header(dir: Path, bytecode_class: BytecodeClass) -> None:
    file_stem = bytecode_class.file_stem
    class_name = bytecode_class.class_name
    func_names = bytecode_class.func_names
    tk_names = bytecode_class.tk_names
    bytecode_version = bytecode_class.bytecode_version
    bytecode_rev = bytecode_class.bytecode_rev
    bytecode_rev_num = bytecode_class.bytecode_rev_num
    engine_ver_major = bytecode_class.engine_ver_major
    variant_ver_major = bytecode_class.variant_ver_major
    new_dir = dir
    # ensure the directory exists
    if not new_dir.exists():
        new_dir.mkdir()
    new_file_h = new_dir / (file_stem + ".h")

    # Read the template file
    template_path = Path(__file__).parent / "misc" / "bytecode_template.h.inc"
    with open(template_path, "r") as template_file:
        template_content = template_file.read()

    ADDED_TOKEN_PREFIX = "\tvirtual Vector<GlobalToken> get_added_tokens() const override { return {"
    REMOVED_TOKEN_PREFIX = "\tvirtual Vector<GlobalToken> get_removed_tokens() const override { return {"
    ADDED_FUNCTION_PREFIX = "\tvirtual Vector<String> get_added_functions() const override { return {"
    REMOVED_FUNCTION_PREFIX = "\tvirtual Vector<String> get_removed_functions() const override { return {"
    ARG_COUNT_CHANGED_PREFIX = "\tvirtual Vector<String> get_function_arg_count_changed() const override { return {"
    TOKENS_RENAMED_PREFIX = "\tvirtual Dictionary get_tokens_renamed() const override { return {"
    FUNCTIONS_RENAMED_PREFIX = "\tvirtual Dictionary get_renamed_functions() const override { return {"

    # Prepare replacement values
    new_added_tokens = ["GlobalToken::G_" + tk_name for tk_name in bytecode_class.added_tokens]
    new_removed_tokens = ["GlobalToken::G_" + tk_name for tk_name in bytecode_class.removed_tokens]

    added_functions = ['"' + func_name + '"' for func_name in bytecode_class.added_functions]
    removed_functions = ['"' + func_name + '"' for func_name in bytecode_class.removed_functions]
    arg_count_changed = ['"' + func_name + '"' for func_name in bytecode_class.arg_count_changed]

    # Handle parent commit
    parent_value = "0x" + str(bytecode_class.parent) if bytecode_class.parent is not None else "0"
    added_tokens_str = ""
    removed_tokens_str = ""
    added_functions_str = ""
    removed_functions_str = ""
    arg_count_changed_str = ""
    tokens_renamed_str = ""
    renamed_functions_str = ""

    # ARR_PREFIX = "\n\t\t"
    # ARR_SUFFIX = "\n\t}; }\n"
    # ARR_JOIN_STR = ",\n\t\t"

    ARR_PREFIX = ""
    ARR_SUFFIX = "}; }\n"
    ARR_JOIN_STR = ", "
    ARR_STR_JOIN_STR = '", "'
    ARR_STRING_FORMAT = ""
    # Prepare token and function lists
    if len(new_added_tokens) > 0:
        added_tokens_str = ADDED_TOKEN_PREFIX + ARR_PREFIX + ARR_JOIN_STR.join(new_added_tokens) + ARR_SUFFIX
    if len(new_removed_tokens) > 0:
        removed_tokens_str = REMOVED_TOKEN_PREFIX + ARR_PREFIX + ARR_JOIN_STR.join(new_removed_tokens) + ARR_SUFFIX
    if len(bytecode_class.added_functions) > 0:
        added_functions_str = ADDED_FUNCTION_PREFIX + ARR_PREFIX + ARR_JOIN_STR.join(added_functions) + ARR_SUFFIX
    if len(bytecode_class.removed_functions) > 0:
        removed_functions_str = REMOVED_FUNCTION_PREFIX + ARR_PREFIX + ARR_JOIN_STR.join(removed_functions) + ARR_SUFFIX
    if len(bytecode_class.arg_count_changed) > 0:
        arg_count_changed_str = (
            ARG_COUNT_CHANGED_PREFIX + ARR_PREFIX + ARR_JOIN_STR.join(arg_count_changed) + ARR_SUFFIX
        )

    DICT_PREFIX = "\n\t\t\t"
    DICT_SUFFIX = "\n\t\t};\n\t}\n"
    DICT_JOIN_STR = "\n\t\t\t"
    # Prepare renamed tokens dictionary
    tokens_renamed_str = ""
    if len(bytecode_class.tokens_renamed) > 0:
        tokens_renamed_lines = []
        for src, dst in bytecode_class.tokens_renamed.items():
            tokens_renamed_lines.append(f'{{ "{src}", "{dst}" }},')
        tokens_renamed_str = (
            TOKENS_RENAMED_PREFIX + DICT_PREFIX + DICT_JOIN_STR.join(tokens_renamed_lines) + DICT_SUFFIX
        )

    # Prepare renamed functions dictionary
    renamed_functions_str = ""
    if len(bytecode_class.renamed_functions) > 0:
        renamed_functions_lines = []
        for src, dst in bytecode_class.renamed_functions.items():
            renamed_functions_lines.append(f'{{ "{src}", "{dst}" }},')
        renamed_functions_str = (
            FUNCTIONS_RENAMED_PREFIX + DICT_PREFIX + DICT_JOIN_STR.join(renamed_functions_lines) + DICT_SUFFIX
        )

    # Replace placeholders in template
    replacements = {
        "//_PRELUDE_": PRELUDE,
        "__CLASS_NAME__": class_name,
        "/*<BYTECODE_VERSION>*/": str(bytecode_version),
        "/*<BYTECODE_REV>*/": "0x" + bytecode_rev,
        "/*<BYTECODE_REV_STR>*/": '"' + bytecode_rev + '"',
        "/*<ENGINE_VER_MAJOR>*/": str(engine_ver_major),
        "/*<VARIANT_VER_MAJOR>*/": str(variant_ver_major),
        "/*<ENGINE_VERSION>*/": '"' + bytecode_class.engine_version + '"',
        "/*<MAX_ENGINE_VERSION>*/": '"' + bytecode_class.max_engine_version + '"',
        "/*<DATE>*/": '"' + bytecode_class.date + '"',
        "/*<PARENT_COMMIT>*/": parent_value,
        "/*<ADDED_TOKENS>*/\n": added_tokens_str,
        "/*<REMOVED_TOKENS>*/\n": removed_tokens_str,
        "/*<ADDED_FUNCTIONS>*/\n": added_functions_str,
        "/*<REMOVED_FUNCTIONS>*/\n": removed_functions_str,
        "/*<ARG_COUNT_CHANGED>*/\n": arg_count_changed_str,
        "/*<TOKENS_RENAMED>*/\n": tokens_renamed_str,
        "/*<RENAMED_FUNCTIONS>*/\n": renamed_functions_str,
    }

    # Apply replacements
    for placeholder, value in replacements.items():
        template_content = template_content.replace(placeholder, value)
    # Write the generated header file
    with open(new_file_h, "w") as f:
        f.write(template_content)


def write_bytecode_json(dir: Path, bytecode_classes: list[BytecodeClass]) -> None:
    bytecode_json = []
    for bytecode_class in bytecode_classes:
        # if len(bytecode_class.func_arg_counts) == 0:
        #     for func_name in bytecode_class.func_names:
        #         for builtin_func_arg_element in builtin_func_arg_elements:
        #             if builtin_func_arg_element[0] == func_name:
        #                 counts = builtin_func_arg_element[1]
        #                 if func_name == "var2bytes" or func_name == "bytes2var":
        #                     if bytecode_class.bytecode_rev_num in greater_than_3_1_versions:
        #                         counts = (1, 2)
        #                 bytecode_class.func_arg_counts[func_name] = counts
        #                 break
        #         if func_name not in bytecode_class.func_arg_counts:
        #             raise ValueError(f"Function {func_name} not found in builtin_func_arg_elements")
        bytecode_json.append(
            {
                "bytecode_rev": bytecode_class.bytecode_rev,
                "bytecode_version": bytecode_class.bytecode_version,
                "date": bytecode_class.date,
                "engine_version": bytecode_class.engine_version,
                "max_engine_version": bytecode_class.max_engine_version,
                "engine_ver_major": bytecode_class.engine_ver_major,
                "variant_ver_major": bytecode_class.variant_ver_major,
                "parent": bytecode_class.parent,
                "is_dev": bytecode_class.is_dev,
                "added_tokens": bytecode_class.added_tokens,
                "removed_tokens": bytecode_class.removed_tokens,
                "added_functions": bytecode_class.added_functions,
                "removed_functions": bytecode_class.removed_functions,
                "renamed_functions": bytecode_class.renamed_functions,
                "arg_count_changed": bytecode_class.arg_count_changed,
                "tokens_renamed": bytecode_class.tokens_renamed,
                "func_names": bytecode_class.func_names,
                # "func_arg_counts": bytecode_class.func_arg_counts,
                "tk_names": bytecode_class.tk_names,
            }
        )
    with open(dir / "bytecode_versions.json", "w") as f:
        f.write(json.dumps(bytecode_json, indent=4))


def read_bytecode_json(path: Path) -> list[BytecodeClass]:
    bytecode_json = []
    with open(path, "r") as f:
        bytecode_json = json.loads(f.read())
    bytecode_classes = []
    for bytecode in bytecode_json:
        bytecode_class = BytecodeClass()
        bytecode_class.bytecode_rev = bytecode["bytecode_rev"]
        bytecode_class.bytecode_version = bytecode["bytecode_version"]
        bytecode_class.date = bytecode["date"]
        bytecode_class.engine_version = bytecode["engine_version"]
        bytecode_class.max_engine_version = bytecode["max_engine_version"]
        bytecode_class.engine_ver_major = bytecode["engine_ver_major"]
        bytecode_class.variant_ver_major = bytecode["variant_ver_major"]
        bytecode_class.parent = bytecode["parent"]
        bytecode_class.func_names = bytecode["func_names"]
        bytecode_class.tk_names = bytecode["tk_names"]
        bytecode_class.added_tokens = bytecode["added_tokens"]
        bytecode_class.removed_tokens = bytecode["removed_tokens"]
        bytecode_class.added_functions = bytecode["added_functions"]
        bytecode_class.removed_functions = bytecode["removed_functions"]
        bytecode_class.renamed_functions = bytecode["renamed_functions"]
        bytecode_class.arg_count_changed = bytecode["arg_count_changed"]
        bytecode_class.tokens_renamed = bytecode["tokens_renamed"]
        bytecode_class.is_dev = bytecode["is_dev"]
        bytecode_classes.append(bytecode_class)
    return bytecode_classes


def generate_bytecode_description_string(bytecode_class: BytecodeClass) -> str:
    # examples:
    # f3f05dc would have the description: "removed `SYNC` and `SLAVE` tokens"
    # 506df14 would have the description: "removed `decimals` function"
    # a7aad78 would have the description: "added `deep_equal` function"
    # d6b31da would have the description: "added `PUPPET` token, token `SLAVESYNC` renamed to `PUPPETSYNC`"

    description: str = ""

    def add_to_desc(format_str: str, listarg: list[str]) -> None:
        nonlocal description
        if len(description) > 0:
            description += ", "
        description += format_str.format("`, `".join(listarg))
        if len(listarg) > 1:
            description += "s"

    if len(bytecode_class.added_tokens) > 0:
        # make a new list with all the added_tokens with the prefixes "TK_PR_", "TK_CF_", and "TK_" removed
        new_added_tokens = [
            token.replace("TK_PR_", "").replace("TK_CF_", "").replace("TK_", "")
            for token in bytecode_class.added_tokens
        ]

        add_to_desc("added `{}` token", new_added_tokens)
    if len(bytecode_class.removed_tokens) > 0:
        new_removed_tokens = [
            token.replace("TK_PR_", "").replace("TK_CF_", "").replace("TK_", "")
            for token in bytecode_class.removed_tokens
        ]
        add_to_desc("removed `{}` token", new_removed_tokens)
    if len(bytecode_class.added_functions) > 0:
        add_to_desc("added `{}` function", bytecode_class.added_functions)
    if len(bytecode_class.removed_functions) > 0:
        add_to_desc("removed `{}` function", bytecode_class.removed_functions)
    if len(bytecode_class.arg_count_changed) > 0:
        add_to_desc("changed argument count for `{}` function", bytecode_class.arg_count_changed)
    if len(bytecode_class.renamed_functions) > 0:
        for dict_key, dict_val in bytecode_class.renamed_functions.items():
            fmt_insert = "{} to {}".format(dict_key, dict_val)
            add_to_desc("renamed function {}", [fmt_insert])
    if len(bytecode_class.tokens_renamed) > 0:
        for dict_key, dict_val in bytecode_class.tokens_renamed.items():
            fmt_insert = "`{}` to `{}`".format(
                dict_key.replace("TK_PR_", "").replace("TK_CF_", "").replace("TK_", ""),
                dict_val.replace("TK_PR_", "").replace("TK_CF_", "").replace("TK_", ""),
            )
            add_to_desc("renamed token {}", [fmt_insert])
    if len(description) == 0:
        if bytecode_class.bytecode_version == 100:
            return "initial version"
        elif bytecode_class.bytecode_version == 101:
            return "content header size changed"
        else:
            return "bytecode version changed"
    return description[0].upper() + description[1:] + "."


# bytecode_versions.h will contain the following
# ```cpp
# #pragma once
#
# #include "bytecode/bytecode_base.h"
#
# <Includes for each bytecode class>
#
# void register_decomp_versions();
# GDScriptDecomp *create_decomp_for_commit(uint64_t p_commit_hash);
# Vector<Ref<GDScriptDecomp>> get_decomps_for_bytecode_ver(int bytecode_version, bool include_dev = false);
#
#
# struct GDScriptDecompVersion {
# 	uint64_t commit;
# 	String name;
#   int bytecode_version;
#   bool is_dev;
# };
#
# static const GDScriptDecompVersion decomp_versions[] = {
# // This contains a list of all the bytecode versions, in order, with their version, commit hash, date, and bytecode version, followed by a description derived from the "added_tokens", "added_functions", etc. fields>
# // for example:
# { 0xf3f05dc, "     4.0 dev (f3f05dc / 2020-02-13 / Bytecode version: 13) - removed `SYNC` and `SLAVE` tokens", 13, true }, // If it's a dev version, there's 5 leading spaces in the description, otherwise it's 0
# { 0x506df14, "     4.0 dev (506df14 / 2020-02-12 / Bytecode version: 13) - removed `decimals` function", 13, true },
# // etc...
# };

BYTECODE_CLASSDB_REGISTER = "//_BYTECODE_CLASSDB_REGISTER_"
BYTECODE_CASE_STATEMENTS = "//_BYTECODE_CASE_STATEMENTS_"
BYTECODE_HEADERS = "//_BYTECODE_HEADERS_"
BYTECODE_DECOMP_VERSIONS = "//_BYTECODE_DECOMP_VERSIONS_"
BYTECODE_LATEST_VERSION = "/*_BYTECODE_DECOMP_LATEST_VERSION_*/"
PRELUDE_REPLACE = "//_PRELUDE_"


def update_bytecode_version_header(dir: Path, bytecode_classes: list[BytecodeClass]) -> None:
    file_path = dir / "bytecode_versions.h"
    with open(file_path, "r") as f:
        code = f.read()

    # split into lines, find `static constexpr int LATEST_GDSCRIPT_COMMIT`, replace the line with `static constexpr int LATEST_GDSCRIPT_COMMIT = 0x` + the bytecode_rev of the first bytecode_class
    lines = code.split("\n")
    for i, line in enumerate(lines):
        if "static constexpr int LATEST_GDSCRIPT_COMMIT" in line:
            lines[i] = line.split("=")[0] + "= 0x" + str(bytecode_classes[0].bytecode_rev) + ";"
            break
    code = "\n".join(lines)
    with open(file_path, "w") as f:
        f.write(code)


def generate_bytecode_versions_cpp(dir: Path, bytecode_classes: list[BytecodeClass]) -> None:
    new_dir = dir
    # ensure the directory exists
    code = ""
    with open(our_dir / "misc" / "bytecode_versions.cpp.inc", "r") as f:
        code = f.read()
    if not code:
        raise Exception("Failed to read bytecode_versions.cpp.inc")
    if not new_dir.exists():
        new_dir.mkdir()
    new_file_cpp = new_dir / ("bytecode_versions.cpp")
    code = code.replace(PRELUDE_REPLACE, PRELUDE)

    header_str = ""
    for bytecode_class in bytecode_classes:
        header_str += f'#include "bytecode/{bytecode_class.file_stem}.h"\n'

    code = code.replace(BYTECODE_HEADERS, header_str)

    bytecode_classdb_register = ""
    for bytecode_class in bytecode_classes:
        bytecode_classdb_register += "\tClassDB::register_class<" + bytecode_class.class_name + ">();\n"
    code = code.replace(BYTECODE_CLASSDB_REGISTER, bytecode_classdb_register)

    bytecode_case_statements = ""
    for bytecode_class in bytecode_classes:
        bytecode_case_statements += (
            "\t\tcase 0x" + bytecode_class.bytecode_rev + ": return memnew(" + bytecode_class.class_name + ");\n"
        )
    code = code.replace(BYTECODE_CASE_STATEMENTS, bytecode_case_statements)

    version_section = ""
    # "4.3.0 release (77af6ca / 2024-02-09 / Bytecode version: 100) - initial version"
    ver_format = '\t{{ 0x{commit}, "{name}", {bytecode_version}, {is_dev}, "{ver}", "{max_ver}", 0x{parent} }},\n'
    name_format = "{ver} ({commit} / {date} / Bytecode version: {bytecode_version}) - {description}"
    for bytecode_class in bytecode_classes:
        name_tab = "\t" if bytecode_class.is_dev else ""
        line = ver_format.format(
            commit=bytecode_class.bytecode_rev,
            name=(
                name_tab
                + name_format.format(
                    ver=bytecode_class.engine_version,
                    commit=bytecode_class.bytecode_rev,
                    date=bytecode_class.date,
                    bytecode_version=bytecode_class.bytecode_version,
                    description=generate_bytecode_description_string(bytecode_class),
                )
            ),
            bytecode_version=bytecode_class.bytecode_version,
            is_dev=str(bytecode_class.is_dev).lower(),
            ver=bytecode_class.engine_version,
            max_ver=bytecode_class.max_engine_version if bytecode_class.max_engine_version else "",
            parent=bytecode_class.parent if bytecode_class.parent else 0,
        )
        version_section += line
    version_section += ""
    code = code.replace(BYTECODE_DECOMP_VERSIONS, version_section)

    with open(new_file_cpp, "w") as f:
        f.write(code)


bytecode_classes = []

# First, we need to get the bytecode directory
our_dir = Path(os.path.dirname(os.path.realpath(__file__)))
json_path = our_dir / "misc" / "bytecode_versions.json"
bytecode_dir = our_dir / "bytecode"

bytecode_classes = read_bytecode_json(json_path)

# write_bytecode_json(dir=our_dir / "misc", bytecode_classes)


for bytecode_class in bytecode_classes:
    generate_class_cpp(bytecode_dir, bytecode_class)
    generate_class_header(bytecode_dir, bytecode_class)

update_bytecode_version_header(bytecode_dir, bytecode_classes)
generate_bytecode_versions_cpp(bytecode_dir, bytecode_classes)