diff options
Diffstat (limited to 'binding_generator.py')
| -rw-r--r-- | binding_generator.py | 462 |
1 files changed, 205 insertions, 257 deletions
diff --git a/binding_generator.py b/binding_generator.py index 3b45a97..9efd2b7 100644 --- a/binding_generator.py +++ b/binding_generator.py @@ -562,23 +562,8 @@ def generate_builtin_class_source(builtin_api, size, used_classes, fully_used_cl # Done in the header because of the template. continue - method_signature = "" - if "return_type" in method: - method_signature += f'{correct_type(method["return_type"])} ' - else: - method_signature += "void " - - method_signature += f'{class_name}::{method["name"]}(' - if "arguments" in method: - method_signature += make_function_parameters( - method["arguments"], include_default=False, for_builtin=True - ) - method_signature += ")" - if method["is_const"]: - method_signature += " const" - method_signature += " {" - - result.append(method_signature) + method_signature = make_signature(class_name, method, for_builtin=True) + result.append(method_signature + "{") method_call = "\t" if "return_type" in method: @@ -758,6 +743,12 @@ def generate_engine_class_header(class_api, used_classes, fully_used_classes, us if len(fully_used_classes) > 0: result.append("") + if class_name != "Object": + result.append("#include <godot_cpp/core/class_db.hpp>") + result.append("") + result.append("#include <type_traits>") + result.append("") + result.append("namespace godot {") result.append("") @@ -783,114 +774,52 @@ def generate_engine_class_header(class_api, used_classes, fully_used_classes, us result.append("\t};") result.append("") - has_vararg_method = False - if "methods" in class_api: for method in class_api["methods"]: if method["is_virtual"]: - # TODO: See how to bind virtual methods (if they are even needed). + # Will be done later. continue - method_signature = "\t" - vararg = "is_vararg" in method and method["is_vararg"] + + method_signature = "\t" if vararg: - has_vararg_method = True method_signature += "private: " - - if "return_value" in method: - method_signature += correct_type( - method["return_value"]["type"], - method["return_value"]["meta"] if "meta" in method["return_value"] else None, - ) - else: - method_signature += "void" - - if not method_signature.endswith("*"): - method_signature += " " - - method_signature += f'{escape_identifier(method["name"])}' - - if vararg or (use_template_get_node and class_name == "Node" and method["name"] == "get_node"): - method_signature += "_internal" - - method_signature += "(" - - method_arguments = [] - if "arguments" in method: - method_arguments = method["arguments"] - - if not vararg: - method_signature += make_function_parameters( - method_arguments, include_default=True, is_vararg=vararg, for_builtin=False - ) - else: - method_signature += "const Variant **args, GDNativeInt arg_count" - - method_signature += ")" - - if method["is_const"]: - method_signature += " const" - - method_signature += ";" - result.append(method_signature) + method_signature += make_signature( + class_name, method, for_header=True, use_template_get_node=use_template_get_node + ) + result.append(method_signature + ";") if vararg: # Add templated version. - method_signature = "\tpublic: template<class... Args> " - - if "return_value" in method: - method_signature += correct_type( - method["return_value"]["type"], - method["return_value"]["meta"] if "meta" in method["return_value"] else None, - ) - else: - method_signature += "void" - - if not method_signature.endswith("*"): - method_signature += " " - - method_signature += f'{escape_identifier(method["name"])}' - - method_arguments = [] - if "arguments" in method: - method_arguments = method["arguments"] - - method_signature += "(" - - method_signature += make_function_parameters(method_arguments, include_default=True, is_vararg=vararg) + result += make_varargs_template(method) - method_signature += ")" - - if method["is_const"]: - method_signature += " const" - - method_signature += " {" - result.append(method_signature) + # Virtuals now. + for method in class_api["methods"]: + if not method["is_virtual"]: + continue - args_array = f"\t\tstd::array<Variant, {len(method_arguments)} + sizeof...(Args)> variant_args {{ " - for argument in method_arguments: - if argument["type"] == "Variant": - args_array += argument["name"] - else: - args_array += f'Variant({argument["name"]})' - args_array += ", " - - args_array += "Variant(args)... };" - result.append(args_array) - result.append(f"\t\tstd::array<const Variant *, {len(method_arguments)} + sizeof...(Args)> call_args;") - result.append("\t\tfor(size_t i = 0; i < variant_args.size(); i++) {") - result.append("\t\t\tcall_args[i] = &variant_args[i];") + method_signature = "\t" + method_signature += make_signature(class_name, method, for_header=True, use_template_get_node=use_template_get_node) + result.append(method_signature + ";") + + result.append("protected:") + result.append("\ttemplate <class T>") + result.append("\tstatic void register_virtuals() {") + if class_name != "Object": + result.append(f"\t\t{inherits}::register_virtuals<T>();") + if "methods" in class_api: + for method in class_api["methods"]: + if not method["is_virtual"]: + continue + method_name = escape_identifier(method["name"]) + result.append(f"\t\tif constexpr (!std::is_same_v<decltype(&{class_name}::{method_name}),decltype(&T::{method_name})>) {{") + result.append(f"\t\t\tBIND_VIRTUAL_METHOD(T, {method_name});") result.append("\t\t}") - call_line = "\t\t" - - if "return_value" in method and method["return_value"]["type"] != "void": - call_line += "return " - - call_line += f'{escape_identifier(method["name"])}_internal(call_args.data(), variant_args.size());' - result.append(call_line) - result.append("\t}") + result.append("\t}") + result.append("") + result.append("public:") # Special cases. if class_name == "Object": @@ -899,7 +828,7 @@ def generate_engine_class_header(class_api, used_classes, fully_used_classes, us result.append("\tstatic T *cast_to(Object *p_object);") elif use_template_get_node and class_name == "Node": result.append("\ttemplate<class T>") - result.append("\tT *get_node(const NodePath &p_path) { return Object::cast_to<T>(get_node_internal(p_path)); }") + result.append("\tT *get_node(const NodePath &p_path) const { return Object::cast_to<T>(get_node_internal(p_path)); }") # Constructor. result.append("") @@ -943,49 +872,14 @@ def generate_engine_class_source(class_api, used_classes, fully_used_classes, us if "methods" in class_api: for method in class_api["methods"]: if method["is_virtual"]: - # TODO: See how to bind virtual methods (if they are even needed). + # Will be done later continue vararg = "is_vararg" in method and method["is_vararg"] # Method signature. - method_signature = "" - if "return_value" in method: - method_signature += correct_type( - method["return_value"]["type"], - method["return_value"]["meta"] if "meta" in method["return_value"] else None, - ) - else: - method_signature += "void" - - if not method_signature.endswith("*"): - method_signature += " " - - method_signature += f'{class_name}::{escape_identifier(method["name"])}' - - if vararg or (use_template_get_node and class_name == "Node" and method["name"] == "get_node"): - method_signature += "_internal" - - method_signature += "(" - - method_arguments = [] - if "arguments" in method: - method_arguments = method["arguments"] - - if not vararg: - method_signature += make_function_parameters( - method_arguments, include_default=False, is_vararg=vararg, for_builtin=False - ) - else: - method_signature += "const Variant **args, GDNativeInt arg_count" - - method_signature += ")" - - if method["is_const"]: - method_signature += " const" - - method_signature += " {" - result.append(method_signature) + method_signature = make_signature(class_name, method, use_template_get_node=use_template_get_node) + result.append(method_signature + " {") # Method body. result.append( @@ -1044,6 +938,22 @@ def generate_engine_class_source(class_api, used_classes, fully_used_classes, us result.append("}") result.append("") + # Virtuals now. + for method in class_api["methods"]: + if not method["is_virtual"]: + continue + + method_signature = make_signature(class_name, method, use_template_get_node=use_template_get_node) + method_signature += " {" + if "return_value" in method and correct_type(method["return_value"]["type"]) != "void": + result.append(method_signature) + result.append(f'\treturn {get_default_value_for_type(method["return_value"]["type"])};') + result.append("}") + else: + method_signature += "}" + result.append(method_signature) + result.append("") + # Constructor. result.append(f"{class_name}::{class_name}() : {inherits}(godot::internal::empty_constructor()) {{") result.append( @@ -1138,85 +1048,12 @@ def generate_utility_functions(api, output_dir): vararg = "is_vararg" in function and function["is_vararg"] function_signature = "\t" - if vararg: - function_signature += "private: " - function_signature += "static " - - if "return_type" in function: - if not vararg: - function_signature += f'{correct_type(function["return_type"])} ' - else: - function_signature += "Variant " - else: - function_signature += "void " - - function_signature += f'{escape_identifier(function["name"])}' - - if vararg: - function_signature += "_internal" - - function_signature += "(" - - function_arguments = [] - if "arguments" in function: - function_arguments = function["arguments"] - - if not vararg: - function_signature += make_function_parameters(function_arguments, include_default=False) - else: - function_signature += "const Variant **args, GDNativeInt arg_count" - function_signature += ");" - - header.append(function_signature) + function_signature += make_signature("UtilityFunctions", function, for_header=True, static=True) + header.append(function_signature + ";") if vararg: # Add templated version. - method_signature = "\tpublic: template<class... Args> static " - - if "return_type" in function: - method_signature += correct_type(function["return_type"]) - else: - method_signature += "void" - - if not method_signature.endswith("*"): - method_signature += " " - - method_signature += f'{escape_identifier(function["name"])}' - - method_arguments = [] - if "arguments" in function: - method_arguments = function["arguments"] - - method_signature += "(" - method_signature += make_function_parameters(method_arguments, include_default=True, is_vararg=vararg) - method_signature += ")" - - method_signature += " {" - header.append(method_signature) - - args_array = f"\t\tstd::array<Variant, {len(method_arguments)} + sizeof...(Args)> variant_args {{ " - for argument in method_arguments: - if argument["type"] == "Variant": - args_array += argument["name"] - else: - args_array += f'Variant({argument["name"]})' - args_array += ", " - - args_array += "Variant(args)... };" - header.append(args_array) - header.append(f"\t\tstd::array<const Variant *, {len(method_arguments)} + sizeof...(Args)> call_args;") - header.append("\t\tfor(size_t i = 0; i < variant_args.size(); i++) {") - header.append("\t\t\tcall_args[i] = &variant_args[i];") - header.append("\t\t}") - - call_line = "\t\t" - - if "return_type" in function and function["return_type"] != "void": - call_line += "return " - - call_line += f'{escape_identifier(function["name"])}_internal(call_args.data(), variant_args.size());' - header.append(call_line) - header.append("\t}") + header += make_varargs_template(function, static=True) header.append("};") header.append("") @@ -1244,34 +1081,8 @@ def generate_utility_functions(api, output_dir): for function in api["utility_functions"]: vararg = "is_vararg" in function and function["is_vararg"] - function_signature = "" - if "return_type" in function: - if not vararg: - function_signature += f'{correct_type(function["return_type"])}' - else: - function_signature += "Variant" - else: - function_signature += "void" - - if not function_signature.endswith("*"): - function_signature += " " - - function_signature += f'UtilityFunctions::{escape_identifier(function["name"])}' - if vararg: - function_signature += "_internal" - function_signature += "(" - - function_arguments = [] - if "arguments" in function: - function_arguments = function["arguments"] - - if not vararg: - function_signature += make_function_parameters(function_arguments, include_default=False) - else: - function_signature += "const Variant **args, GDNativeInt arg_count" - function_signature += ") {" - - source.append(function_signature) + function_signature = make_signature("UtilityFunctions", function) + source.append(function_signature + " {") # Function body. @@ -1340,14 +1151,20 @@ def camel_to_snake(name): def make_function_parameters(parameters, include_default=False, for_builtin=False, is_vararg=False): signature = [] - for par in parameters: + for index, par in enumerate(parameters): parameter = type_for_parameter(par["type"], par["meta"] if "meta" in par else None) - parameter += escape_identifier(par["name"]) + parameter_name = escape_identifier(par["name"]) + if len(parameter_name) == 0: + parameter_name = "arg_" + str(index + 1) + parameter += parameter_name if include_default and "default_value" in par and (not for_builtin or par["type"] != "Variant"): parameter += " = " if is_enum(par["type"]): - parameter += f'({correct_type(par["type"])})' + parameter_type = correct_type(par["type"]) + if parameter_type == "void": + parameter_type = "Variant" + parameter += f'({parameter_type})' parameter += correct_default_value(par["default_value"], par["type"]) signature.append(parameter) @@ -1358,7 +1175,9 @@ def make_function_parameters(parameters, include_default=False, for_builtin=Fals def type_for_parameter(type_name, meta=None): - if is_pod_type(type_name) and type_name != "Nil" or is_enum(type_name): + if type_name == "void": + return "Variant " + elif is_pod_type(type_name) and type_name != "Nil" or is_enum(type_name): return f"{correct_type(type_name, meta)} " elif is_variant(type_name) or is_refcounted(type_name): return f"const {correct_type(type_name)} &" @@ -1395,6 +1214,135 @@ def get_encoded_arg(arg_name, type_name, type_meta): return (result, name) +def make_signature(class_name, function_data, for_header=False, use_template_get_node=True, for_builtin=False, static=False): + function_signature = "" + + is_vararg = "is_vararg" in function_data and function_data["is_vararg"] + + if for_header: + if "is_virtual" in function_data and function_data["is_virtual"]: + function_signature += "virtual " + + if is_vararg: + function_signature += "private: " + + if static: + function_signature += "static " + + return_type = "void" + return_meta = None + if "return_type" in function_data: + return_type = correct_type(function_data["return_type"]) + elif "return_value" in function_data: + return_type = function_data["return_value"]["type"] + return_meta = function_data["return_value"]["meta"] if "meta" in function_data["return_value"] else None + + function_signature += correct_type( + return_type, + return_meta, + ) + + if not function_signature.endswith("*"): + function_signature += " " + + if not for_header: + function_signature += f"{class_name}::" + + function_signature += escape_identifier(function_data["name"]) + + if is_vararg or ( + not for_builtin and use_template_get_node and class_name == "Node" and function_data["name"] == "get_node" + ): + function_signature += "_internal" + + function_signature += "(" + + arguments = function_data["arguments"] if "arguments" in function_data else [] + + if not is_vararg: + function_signature += make_function_parameters(arguments, for_header, for_builtin, is_vararg) + else: + function_signature += "const Variant **args, GDNativeInt arg_count" + + function_signature += ")" + + if "is_const" in function_data and function_data["is_const"]: + function_signature += " const" + + return function_signature + + +def make_varargs_template(function_data, static=False): + result = [] + + function_signature = "\tpublic: template<class... Args> " + + if static: + function_signature += "static " + + return_type = "void" + return_meta = None + if "return_type" in function_data: + return_type = correct_type(function_data["return_type"]) + elif "return_value" in function_data: + return_type = function_data["return_value"]["type"] + return_meta = function_data["return_value"]["meta"] if "meta" in function_data["return_value"] else None + + function_signature += correct_type( + return_type, + return_meta, + ) + + if not function_signature.endswith("*"): + function_signature += " " + + function_signature += f'{escape_identifier(function_data["name"])}' + + method_arguments = [] + if "arguments" in function_data: + method_arguments = function_data["arguments"] + + function_signature += "(" + + is_vararg = "is_vararg" in function_data and function_data["is_vararg"] + + function_signature += make_function_parameters(method_arguments, include_default=True, is_vararg=is_vararg) + + function_signature += ")" + + if "is_const" in function_data and function_data["is_const"]: + function_signature += " const" + + function_signature += " {" + result.append(function_signature) + + args_array = f"\t\tstd::array<Variant, {len(method_arguments)} + sizeof...(Args)> variant_args {{ " + for argument in method_arguments: + if argument["type"] == "Variant": + args_array += argument["name"] + else: + args_array += f'Variant({argument["name"]})' + args_array += ", " + + args_array += "Variant(args)... };" + result.append(args_array) + result.append(f"\t\tstd::array<const Variant *, {len(method_arguments)} + sizeof...(Args)> call_args;") + result.append("\t\tfor(size_t i = 0; i < variant_args.size(); i++) {") + result.append("\t\t\tcall_args[i] = &variant_args[i];") + result.append("\t\t}") + + call_line = "\t\t" + + if "return_value" in function_data and function_data["return_value"]["type"] != "void": + call_line += "return " + + call_line += f'{escape_identifier(function_data["name"])}_internal(call_args.data(), variant_args.size());' + result.append(call_line) + result.append("\t}") + + return result + + # Engine idiosyncrasies. |