update wip

Author: Ughuuu

binding_generator.py

@@ -200,7 +200,7 @@ def generate_virtuals(target):
         f.write(txt)
 
 
-def get_file_list(api_filepath, output_dir, headers=False, sources=False, compat=False, profile_filepath=""):
+def get_file_list(api_filepath, output_dir, headers=False, sources=False, profile_filepath=""):
     api = {}
     files = []
     with open(api_filepath, encoding="utf-8") as api_file:
@@ -210,7 +210,6 @@ def get_file_list(api_filepath, output_dir, headers=False, sources=False, compat
 
     core_gen_folder = Path(output_dir) / "gen" / "include" / "godot_cpp" / "core"
     include_gen_folder = Path(output_dir) / "gen" / "include" / "godot_cpp"
-    include_gen_compat_folder = Path(output_dir) / "gen" / "include" / "godot_compat"
     source_gen_folder = Path(output_dir) / "gen" / "src"
 
     files.append(str((core_gen_folder / "ext_wrappers.gen.inc").as_posix()))
@@ -224,12 +223,9 @@ def get_file_list(api_filepath, output_dir, headers=False, sources=False, compat
             continue
 
         header_filename = include_gen_folder / "variant" / (camel_to_snake(builtin_class["name"]) + ".hpp")
-        header_compat_filename = include_gen_compat_folder / "variant" / (camel_to_snake(builtin_class["name"]) + ".hpp")
         source_filename = source_gen_folder / "variant" / (camel_to_snake(builtin_class["name"]) + ".cpp")
         if headers:
             files.append(str(header_filename.as_posix()))
-        if compat:
-            files.append(str(header_compat_filename.as_posix()))
         if sources:
             files.append(str(source_filename.as_posix()))
 
@@ -239,12 +235,9 @@ def get_file_list(api_filepath, output_dir, headers=False, sources=False, compat
             engine_class["name"] = "ClassDBSingleton"
             engine_class["alias_for"] = "ClassDB"
         header_filename = include_gen_folder / "classes" / (camel_to_snake(engine_class["name"]) + ".hpp")
-        header_compat_filename = include_gen_compat_folder / "classes" / (camel_to_snake(engine_class["name"]) + ".hpp")
         source_filename = source_gen_folder / "classes" / (camel_to_snake(engine_class["name"]) + ".cpp")
         if headers:
             files.append(str(header_filename.as_posix()))
-        if compat:
-            files.append(str(header_compat_filename.as_posix()))
         if sources and is_class_included(engine_class["name"], build_profile):
             files.append(str(source_filename.as_posix()))
 
@@ -255,39 +248,30 @@ def get_file_list(api_filepath, output_dir, headers=False, sources=False, compat
         snake_struct_name = camel_to_snake(struct_name)
 
         header_filename = include_gen_folder / "classes" / (snake_struct_name + ".hpp")
-        header_compat_filename = include_gen_compat_folder / "classes" / (snake_struct_name + ".hpp")
         if headers:
             files.append(str(header_filename.as_posix()))
-        if compat:
-            files.append(str(header_compat_filename.as_posix()))
 
     if headers:
-        relative_paths = [
-            ["variant", "builtin_types.hpp"],
-            ["variant", "builtin_binds.hpp"],
-            ["variant", "utility_functions.hpp"],
-            ["variant", "variant_size.hpp"],
-            ["variant", "builtin_vararg_methods.hpp"],
-            ["classes", "global_constants.hpp"],
-            ["classes", "global_constants_binds.hpp"],
-            ["core", "version.hpp"]
-        ]
-
-        for relative_path_parts in relative_paths:
-            full_header_path = include_gen_folder.joinpath(*relative_path_parts)
-            files.append(str(full_header_path.as_posix()))
-            if compat:
-                full_compat_path = include_gen_compat_folder.joinpath(*relative_path_parts)
-                files.append(str(full_compat_path.as_posix()))
+        for path in [
+            include_gen_folder / "variant" / "builtin_types.hpp",
+            include_gen_folder / "variant" / "builtin_binds.hpp",
+            include_gen_folder / "variant" / "utility_functions.hpp",
+            include_gen_folder / "variant" / "variant_size.hpp",
+            include_gen_folder / "variant" / "builtin_vararg_methods.hpp",
+            include_gen_folder / "classes" / "global_constants.hpp",
+            include_gen_folder / "classes" / "global_constants_binds.hpp",
+            include_gen_folder / "core" / "version.hpp",
+         ]:
+            files.append(str(path.as_posix()))
     if sources:
         utility_functions_source_path = source_gen_folder / "variant" / "utility_functions.cpp"
         files.append(str(utility_functions_source_path.as_posix()))
 
     return files
 
 
-def print_file_list(api_filepath, output_dir, headers=False, sources=False, compat=False, profile_filepath=""):
-    print(*get_file_list(api_filepath, output_dir, headers, sources, compat, profile_filepath), sep=";", end=None)
+def print_file_list(api_filepath, output_dir, headers=False, sources=False, profile_filepath=""):
+    print(*get_file_list(api_filepath, output_dir, headers, sources, profile_filepath), sep=";", end=None)
 
 
 def parse_build_profile(profile_filepath, api):
@@ -384,7 +368,7 @@ def scons_emit_files(target, source, env):
     if profile_filepath and not Path(profile_filepath).is_absolute():
         profile_filepath = str((Path(env.Dir("#").abspath) / profile_filepath).as_posix())
 
-    files = [env.File(f) for f in get_file_list(str(source[0]), target[0].abspath, True, True, env["godot_repo"] != "", profile_filepath)]
+    files = [env.File(f) for f in get_file_list(str(source[0]), target[0].abspath, True, True, profile_filepath)]
     env.Clean(target, files)
     env["godot_cpp_gen_dir"] = target[0].abspath
     return files, source
@@ -423,7 +407,7 @@ def generate_bindings(api_filepath, use_template_get_node, bits="64", precision=
     generate_engine_classes_bindings(api, target_dir, use_template_get_node)
     generate_utility_functions(api, target_dir)
     if godot_repo != "":
-        generate_compat_includes(godot_repo, output_dir)
+        generate_compat_includes(godot_repo, output_dir, target_dir)
 
 
 CLASS_ALIASES = {
@@ -1567,40 +1551,49 @@ def generate_engine_classes_bindings(api, output_dir, use_template_get_node):
             header_file.write("\n".join(result))
 
 
-def generate_compat_includes(godot_repo: Path, output_dir: Path):
-    file_types_mapping_godot_cpp_gen = map_header_files(output_dir)
+def generate_compat_includes(godot_repo: Path, output_dir: Path, target_dir: Path):
+    target_dir = output_dir
+    file_types_mapping_godot_cpp_gen = map_header_files(target_dir)
     file_types_mapping_godot = map_header_files(godot_repo)
     # Match the headers
     file_types_mapping = match_headers(file_types_mapping_godot_cpp_gen, file_types_mapping_godot)
-
     for file_godot_cpp_name, file_godot_names in file_types_mapping.items():
-        file_godot_cpp_name = Path(file_godot_cpp_name).as_posix()
-        header_filepath = file_godot_cpp_name.replace("godot_cpp", "godot_compat")
-        if "gen/include" not in header_filepath:
-            header_filepath = header_filepath.replace("include/", "gen/include/")
-        Path(os.path.dirname(Path(output_dir) / Path(header_filepath))).mkdir(parents=True, exist_ok=True)
         result = []
-        snake_header_name = camel_to_snake(header_filepath)
-        add_header(f"{snake_header_name}.hpp", result)
+        with (Path(target_dir) / Path(file_godot_cpp_name)).open("r", encoding="utf-8") as header_file:
+            content = header_file.readlines()
+        # Find the last line (#endif guard)
+        last_endif_idx = len(content) - 1
+        # Look for the marker for the header guard (usually #define)
+        marker_pos = next((i for i, line in enumerate(content) if line.startswith("#define")), -1)
+
+        if marker_pos != -1:
+            # Add content before the last #endif
+            before_marker = content[:marker_pos + 1]  # Include up to the marker line
+            after_marker = content[marker_pos + 1:last_endif_idx]  # Content excluding the final #endif
+
+            result.extend(before_marker)  # Append original content up to marker
+            result.append("\n")  # Blank line for separation
+
+            # Insert the #ifdef block
+            result.append(f"#ifdef GODOT_MODULE_COMPAT\n")
+            if len(file_godot_names) == 0:
+                print("No header found for", file_godot_cpp_name)
+            for file_godot_name in file_godot_names:
+                result.append(f"#include <{Path(file_godot_name).as_posix()}>\n")
+            result.append(f"#else\n")
+
+            result.extend(after_marker)  # Append the remaining content inside the guard
+
+            # Add the namespace and endif
+            result.append(f"#endif\n")
+            
+            # Finally, append the original final #endif line
+            result.append(content[last_endif_idx].strip())
 
-        header_guard = f"GODOT_COMPAT_{os.path.splitext(os.path.basename(header_filepath).upper())[0]}_HPP"
-        result.append(f"#ifndef {header_guard}")
-        result.append(f"#define {header_guard}")
-        result.append("")
-        result.append(f"#ifdef GODOT_MODULE_COMPAT")
-        for file_godot_name in file_godot_names:
-            result.append(f"#include <{Path(file_godot_name).as_posix()}>")
-        
-        result.append(f"#else")
-        file_godot_cpp_name = file_godot_cpp_name.replace("gen/include/", "")
-        file_godot_cpp_name = file_godot_cpp_name.replace("include/", "")
-        result.append(f"#include <{file_godot_cpp_name}>")
-        result.append(f"using namespace godot;")
-        result.append(f"#endif")
-        result.append("")
-        result.append(f"#endif // ! {header_guard}")
-        with (Path(output_dir) / Path(header_filepath)).open("w+", encoding="utf-8") as header_file:
-            header_file.write("\n".join(result))
+        else:
+            print(f"Marker not found in {file_godot_cpp_name}")
+        with (Path(target_dir) / Path(file_godot_cpp_name)).open("w+", encoding="utf-8") as header_file:
+            header_file.write("".join(result))
 
 
 def generate_engine_class_header(class_api, used_classes, fully_used_classes, use_template_get_node):

compat_generator.py

@@ -7,21 +7,28 @@
 
 
 def parse_header_file(file_path):
-    types = {"classes": [], "structs": [], "defines": []}
+    types = {"classes": [], "structs": [], "defines": [], "enums": []}
 
     with open(file_path, "r", encoding="utf-8") as file:
         content = file.read()
 
         # Regular expressions to match different types
-        struct_pattern = r"struct\s+[\w\s]*?([a-zA-Z_]\w*)\s*[:{]"
+        struct_pattern = r"struct.*\s(\S+)\s*\{"
+        type_pattern = r"typedef.*\s(\S+)\s*\;"
+        enum_pattern = r"enum.*\s(\S+)\s*\{"
         class_pattern = r"class\s+[\w\s]*?([a-zA-Z_]\w*)\s*[:{]"
         define_pattern = r"#define\s+([a-zA-Z_]\w*)"
 
         # Extract classes
         types["classes"] += re.findall(class_pattern, content)
 
         # Extract structs
-        types["structs"] += re.findall(struct_pattern, content)
+        struct_names = re.findall(struct_pattern, content)
+        types["structs"].extend(struct_names)
+        type_names = re.findall(type_pattern, content)
+        types["structs"].extend(type_names)
+        enum_names = re.findall(enum_pattern, content)
+        types["enums"].extend(enum_names)
 
         # Extract defines
         define_matches = re.findall(define_pattern, content)
@@ -35,7 +42,6 @@ def parse_header_file(file_path):
 
 def map_header_files(directory):
     file_types_mapping = {}
-
     for root, dirs, files in os.walk(directory):
         if "thirdparty" in dirs:
             dirs.remove("thirdparty")
@@ -57,8 +63,8 @@ def map_header_files(directory):
 
 
 if __name__ == "__main__":
-    # Get current directory
-    current_directory = os.getcwd()
+    # Get current directory for godot-cpp
+    current_directory = os.path.join(os.getcwd(), "")
     mapping_name = ""
     if len(sys.argv) > 1:
         mapping_name = f"_godot"

header_matcher.py

@@ -11,7 +11,8 @@ def match_headers(mapping1, mapping2):
                 matches[header_file] = []
             if (any(class_name in data2["classes"] for class_name in data1["classes"]) or
                 any(define_name in data2["defines"] for define_name in data1["defines"]) or
-                any(define_name in data2["structs"] for define_name in data1["structs"])):
+                any(define_name in data2["structs"] for define_name in data1["structs"])):#  or
+                #any(define_name in data2["enums"] for define_name in data1["enums"])):
                 matches[header_file].append(header_file2)
     return matches