mirror of
https://github.com/Relintai/gdnative_cpp.git
synced 2024-11-12 10:25:31 +01:00
998 lines
33 KiB
Python
998 lines
33 KiB
Python
#!/usr/bin/env python
|
|
from __future__ import print_function
|
|
import json
|
|
import os
|
|
import errno
|
|
from pathlib import Path
|
|
|
|
# Convenience function for using template get_node
|
|
def correct_method_name(method_list):
|
|
for method in method_list:
|
|
if method["name"] == "get_node":
|
|
method["name"] = "get_node_internal"
|
|
|
|
def class_name_to_file_name(class_name):
|
|
new_name = ""
|
|
|
|
upper_count = 0
|
|
upper_str = ""
|
|
for i in range(len(class_name)):
|
|
c = class_name[i]
|
|
|
|
if c.isupper():
|
|
upper_str += c
|
|
else:
|
|
if len(upper_str) > 0:
|
|
if len(new_name) > 0:
|
|
new_name += "_"
|
|
|
|
new_name += upper_str.lower()
|
|
upper_str = ""
|
|
|
|
new_name += c
|
|
|
|
if len(upper_str) > 0:
|
|
if len(new_name) > 0:
|
|
new_name += "_"
|
|
|
|
new_name += upper_str.lower()
|
|
|
|
return new_name
|
|
|
|
classes = []
|
|
|
|
|
|
def get_file_list(api_filepath, output_dir, headers=False, sources=False):
|
|
global classes
|
|
files = []
|
|
with open(api_filepath) as api_file:
|
|
classes = json.load(api_file)
|
|
include_gen_folder = Path(output_dir) / "gen"
|
|
source_gen_folder = Path(output_dir) / "gen"
|
|
for _class in classes:
|
|
header_filename = include_gen_folder / (class_name_to_file_name(strip_name(_class["name"])) + ".h")
|
|
source_filename = source_gen_folder / (class_name_to_file_name(strip_name(_class["name"])) + ".cpp")
|
|
if headers:
|
|
files.append(str(header_filename.as_posix()))
|
|
if sources:
|
|
files.append(str(source_filename.as_posix()))
|
|
icall_header_filename = include_gen_folder / "__icalls.h"
|
|
register_types_filename = source_gen_folder / "__register_types.cpp"
|
|
init_method_bindings_filename = source_gen_folder / "__init_method_bindings.cpp"
|
|
if headers:
|
|
files.append(str(icall_header_filename.as_posix()))
|
|
if sources:
|
|
files.append(str(register_types_filename.as_posix()))
|
|
files.append(str(init_method_bindings_filename.as_posix()))
|
|
return files
|
|
|
|
|
|
def print_file_list(api_filepath, output_dir, headers=False, sources=False):
|
|
for f in get_file_list(api_filepath, output_dir, headers, sources):
|
|
print(f, end=";")
|
|
|
|
|
|
def scons_emit_files(target, source, env):
|
|
files = [env.File(f) for f in get_file_list(str(source[0]), target[0].abspath, True, True)]
|
|
env.Clean(target, files)
|
|
env["pandemonium_cpp_gen_dir"] = target[0].abspath
|
|
return files, source
|
|
|
|
|
|
def scons_generate_bindings(target, source, env):
|
|
generate_bindings(str(source[0]), env["generate_template_get_node"], env["pandemonium_cpp_gen_dir"])
|
|
return None
|
|
|
|
|
|
def generate_bindings(api_filepath, use_template_get_node, output_dir="."):
|
|
global classes
|
|
with open(api_filepath) as api_file:
|
|
classes = json.load(api_file)
|
|
|
|
icalls = set()
|
|
include_gen_folder = Path(output_dir) / "gen"
|
|
source_gen_folder = Path(output_dir) / "gen"
|
|
|
|
include_gen_folder.mkdir(parents=True, exist_ok=True)
|
|
source_gen_folder.mkdir(parents=True, exist_ok=True)
|
|
|
|
for c in classes:
|
|
# print(c['name'])
|
|
used_classes = sorted(get_used_classes(c))
|
|
if use_template_get_node and c["name"] == "Node":
|
|
correct_method_name(c["methods"])
|
|
|
|
header = generate_class_header(used_classes, c, use_template_get_node)
|
|
|
|
impl = generate_class_implementation(icalls, used_classes, c, use_template_get_node)
|
|
|
|
header_filename = include_gen_folder / (class_name_to_file_name(strip_name(c["name"])) + ".h")
|
|
with header_filename.open("w+") as header_file:
|
|
header_file.write(header)
|
|
|
|
source_filename = source_gen_folder / (class_name_to_file_name(strip_name(c["name"]) )+ ".cpp")
|
|
with source_filename.open("w+") as source_file:
|
|
source_file.write(impl)
|
|
|
|
icall_header_filename = include_gen_folder / "__icalls.h"
|
|
with icall_header_filename.open("w+") as icall_header_file:
|
|
icall_header_file.write(generate_icall_header(icalls))
|
|
|
|
register_types_filename = source_gen_folder / "__register_types.cpp"
|
|
with register_types_filename.open("w+") as register_types_file:
|
|
register_types_file.write(generate_type_registry(classes))
|
|
|
|
init_method_bindings_filename = source_gen_folder / "__init_method_bindings.cpp"
|
|
with init_method_bindings_filename.open("w+") as init_method_bindings_file:
|
|
init_method_bindings_file.write(generate_init_method_bindings(classes))
|
|
|
|
|
|
def is_reference_type(t):
|
|
for c in classes:
|
|
if c["name"] != t:
|
|
continue
|
|
if c["is_reference"]:
|
|
return True
|
|
return False
|
|
|
|
|
|
def make_gdnative_type(t, ref_allowed):
|
|
if is_enum(t):
|
|
return remove_enum_prefix(t) + " "
|
|
elif is_class_type(t):
|
|
if is_reference_type(t) and ref_allowed:
|
|
return "Ref<" + strip_name(t) + "> "
|
|
else:
|
|
return strip_name(t) + " *"
|
|
else:
|
|
if t == "int":
|
|
return "int64_t "
|
|
if t == "float" or t == "real":
|
|
return "real_t "
|
|
return strip_name(t) + " "
|
|
|
|
|
|
def generate_class_header(used_classes, c, use_template_get_node):
|
|
|
|
source = []
|
|
source.append("#ifndef PANDEMONIUM_CPP_" + strip_name(c["name"]).upper() + "_H")
|
|
source.append("#define PANDEMONIUM_CPP_" + strip_name(c["name"]).upper() + "_H")
|
|
source.append("")
|
|
source.append("")
|
|
|
|
source.append("#include <gdnative_api_struct.gen.h>")
|
|
source.append("#include <cstdint>")
|
|
source.append("")
|
|
|
|
source.append("#include <core/core_types.h>")
|
|
|
|
class_name = strip_name(c["name"])
|
|
|
|
# Ref<T> is not included in object.h in Pandemonium either,
|
|
# so don't include it here because it's not needed
|
|
if class_name != "Object" and class_name != "Reference":
|
|
source.append("#include <core/ref.h>")
|
|
ref_allowed = True
|
|
else:
|
|
source.append("#include <core/tag_db.h>")
|
|
ref_allowed = False
|
|
|
|
included = []
|
|
|
|
for used_class in used_classes:
|
|
if is_enum(used_class) and is_nested_type(used_class):
|
|
used_class_name = remove_enum_prefix(extract_nested_type(used_class))
|
|
if used_class_name not in included:
|
|
included.append(used_class_name)
|
|
source.append('#include "' + class_name_to_file_name(used_class_name) + '.h"')
|
|
elif is_enum(used_class) and is_nested_type(used_class) and not is_nested_type(used_class, class_name):
|
|
used_class_name = remove_enum_prefix(used_class)
|
|
if used_class_name not in included:
|
|
included.append(used_class_name)
|
|
source.append('#include "' + class_name_to_file_name(used_class_name) + '.h"')
|
|
|
|
source.append("")
|
|
|
|
if c["base_class"] != "":
|
|
source.append('#include "' + class_name_to_file_name(strip_name(c["base_class"])) + '.h"')
|
|
|
|
source.append("")
|
|
|
|
for used_type in used_classes:
|
|
if is_enum(used_type) or is_nested_type(used_type, class_name):
|
|
continue
|
|
else:
|
|
source.append("class " + strip_name(used_type) + ";")
|
|
|
|
source.append("")
|
|
|
|
vararg_templates = ""
|
|
|
|
# generate the class definition here
|
|
source.append(
|
|
"class "
|
|
+ class_name
|
|
+ (" : public _Wrapped" if c["base_class"] == "" else (" : public " + strip_name(c["base_class"])))
|
|
+ " {"
|
|
)
|
|
|
|
if c["base_class"] == "":
|
|
source.append("public: enum { ___CLASS_IS_SCRIPT = 0, };")
|
|
source.append("")
|
|
source.append("private:")
|
|
|
|
if c["singleton"]:
|
|
source.append("\tstatic " + class_name + " *_singleton;")
|
|
source.append("")
|
|
source.append("\t" + class_name + "();")
|
|
source.append("")
|
|
|
|
# Generate method table
|
|
source.append("\tstruct ___method_bindings {")
|
|
|
|
for method in c["methods"]:
|
|
source.append("\t\tpandemonium_method_bind *mb_" + method["name"] + ";")
|
|
|
|
source.append("\t};")
|
|
source.append("\tstatic ___method_bindings ___mb;")
|
|
source.append("\tstatic void *_detail_class_tag;")
|
|
source.append("")
|
|
source.append("public:")
|
|
source.append("\tstatic void ___init_method_bindings();")
|
|
|
|
# class id from core engine for casting
|
|
source.append("\tinline static size_t ___get_id() { return (size_t)_detail_class_tag; }")
|
|
|
|
source.append("")
|
|
|
|
if c["singleton"]:
|
|
source.append("\tstatic inline " + class_name + " *get_singleton()")
|
|
source.append("\t{")
|
|
source.append("\t\tif (!" + class_name + "::_singleton) {")
|
|
source.append("\t\t\t" + class_name + "::_singleton = new " + class_name + ";")
|
|
source.append("\t\t}")
|
|
source.append("\t\treturn " + class_name + "::_singleton;")
|
|
source.append("\t}")
|
|
source.append("")
|
|
|
|
# Pandemonium::api->pandemonium_global_get_singleton((char *) \"" + strip_name(c["name"]) + "\");"
|
|
|
|
# class name:
|
|
# Two versions needed needed because when the user implements a custom class,
|
|
# we want to override `___get_class_name` while `___get_pandemonium_class_name` can keep returning the base name
|
|
source.append(
|
|
'\tstatic inline const char *___get_class_name() { return (const char *) "' + strip_name(c["name"]) + '"; }'
|
|
)
|
|
source.append(
|
|
'\tstatic inline const char *___get_pandemonium_class_name() { return (const char *) "'
|
|
+ strip_name(c["name"])
|
|
+ '"; }'
|
|
)
|
|
|
|
source.append(
|
|
"\tstatic inline Object *___get_from_variant(Variant a) { pandemonium_object *o = (pandemonium_object*) a; return (o) ? (Object *) Pandemonium::nativescript_api->pandemonium_nativescript_get_instance_binding_data(_RegisterState::language_index, o) : nullptr; }"
|
|
)
|
|
|
|
enum_values = []
|
|
|
|
source.append("\n\t// enums")
|
|
for enum in c["enums"]:
|
|
source.append("\tenum " + strip_name(enum["name"]) + " {")
|
|
for value in enum["values"]:
|
|
source.append("\t\t" + remove_nested_type_prefix(value) + " = " + str(enum["values"][value]) + ",")
|
|
enum_values.append(value)
|
|
source.append("\t};")
|
|
|
|
source.append("\n\t// constants")
|
|
|
|
for name in c["constants"]:
|
|
if name not in enum_values:
|
|
source.append("\tconst static int " + name + " = " + str(c["constants"][name]) + ";")
|
|
|
|
if c["instanciable"]:
|
|
source.append("")
|
|
source.append("")
|
|
source.append("\tstatic " + class_name + " *_new();")
|
|
|
|
source.append("\n\t// methods")
|
|
|
|
if class_name == "Object":
|
|
source.append("#ifndef PANDEMONIUM_CPP_NO_OBJECT_CAST")
|
|
source.append("\ttemplate<class T>")
|
|
source.append("\tstatic T *cast_to(const Object *obj);")
|
|
source.append("#endif")
|
|
source.append("")
|
|
|
|
for method in c["methods"]:
|
|
method_signature = ""
|
|
|
|
# TODO decide what to do about virtual methods
|
|
# method_signature += "virtual " if method["is_virtual"] else ""
|
|
method_signature += make_gdnative_type(method["return_type"], ref_allowed)
|
|
method_name = escape_cpp(method["name"])
|
|
method_signature += method_name + "("
|
|
|
|
has_default_argument = False
|
|
method_arguments = ""
|
|
|
|
for i, argument in enumerate(method["arguments"]):
|
|
method_signature += "const " + make_gdnative_type(argument["type"], ref_allowed)
|
|
argument_name = escape_cpp(argument["name"])
|
|
method_signature += argument_name
|
|
method_arguments += argument_name
|
|
|
|
# default arguments
|
|
def escape_default_arg(_type, default_value):
|
|
if _type == "Color":
|
|
return "Color" + default_value
|
|
if _type == "bool" or _type == "int":
|
|
return default_value.lower()
|
|
if _type == "Array":
|
|
return "Array()"
|
|
if _type in [
|
|
"PoolVector2Array",
|
|
"PoolVector2iArray",
|
|
"PoolStringArray",
|
|
"PoolVector3Array",
|
|
"PoolVector3iArray",
|
|
"PoolVector4Array",
|
|
"PoolVector4iArray",
|
|
"PoolColorArray",
|
|
"PoolIntArray",
|
|
"PoolRealArray",
|
|
"PoolByteArray",
|
|
]:
|
|
return _type + "()"
|
|
if _type == "Vector2":
|
|
return "Vector2" + default_value
|
|
if _type == "Vector2i":
|
|
return "Vector2i" + default_value
|
|
if _type == "Vector3":
|
|
return "Vector3" + default_value
|
|
if _type == "Vector3i":
|
|
return "Vector3i" + default_value
|
|
if _type == "Vector4":
|
|
return "Vector4" + default_value
|
|
if _type == "Vector4i":
|
|
return "Vector4i" + default_value
|
|
if _type == "Transform":
|
|
return "Transform()"
|
|
if _type == "Transform2D":
|
|
return "Transform2D()"
|
|
if _type == "Projection":
|
|
return "Transform2D()"
|
|
if _type == "Rect2":
|
|
return "Rect2" + default_value.replace('[P: (', "(").replace("), S: (", ", ").replace(")]", ")")
|
|
if _type == "Rect2i":
|
|
return "Rect2i" + default_value.replace('[P: (', "(").replace("), S: (", ", ").replace(")]", ")")
|
|
if _type == "Variant":
|
|
return "Variant()" if default_value == "Null" else default_value
|
|
if _type == "String" or _type == "NodePath" or _type == "StringName":
|
|
return '"' + default_value + '"'
|
|
if _type == "RID":
|
|
return "RID()"
|
|
|
|
if default_value == "Null" or default_value == "[Object:null]":
|
|
return "nullptr"
|
|
|
|
if _type == 'float':
|
|
return default_value.replace("inf", "Math_INF")
|
|
|
|
return default_value
|
|
|
|
if argument["has_default_value"] or has_default_argument:
|
|
method_signature += " = " + escape_default_arg(argument["type"], argument["default_value"])
|
|
has_default_argument = True
|
|
|
|
if i != len(method["arguments"]) - 1:
|
|
method_signature += ", "
|
|
method_arguments += ","
|
|
|
|
if method["has_varargs"]:
|
|
if len(method["arguments"]) > 0:
|
|
method_signature += ", "
|
|
method_arguments += ", "
|
|
vararg_templates += (
|
|
"\ttemplate <class... Args> "
|
|
+ method_signature
|
|
+ "Args... args){\n\t\treturn "
|
|
+ method_name
|
|
+ "("
|
|
+ method_arguments
|
|
+ "Array::make(args...));\n\t}\n"
|
|
""
|
|
)
|
|
method_signature += "const Array& __var_args = Array()"
|
|
|
|
method_signature += ")" + (" const" if method["is_const"] else "")
|
|
|
|
source.append("\t" + method_signature + ";")
|
|
|
|
source.append(vararg_templates)
|
|
|
|
if use_template_get_node and class_name == "Node":
|
|
# Extra definition for template get_node that calls the renamed get_node_internal; has a default template parameter for backwards compatibility.
|
|
source.append("\ttemplate <class T = Node>")
|
|
source.append("\tT *get_node(const NodePath path) const {")
|
|
source.append("\t\treturn Object::cast_to<T>(get_node_internal(path));")
|
|
source.append("\t}")
|
|
|
|
source.append("};")
|
|
source.append("")
|
|
|
|
# ...And a specialized version so we don't unnecessarily cast when using the default.
|
|
source.append("template <>")
|
|
source.append("inline Node *Node::get_node<Node>(const NodePath path) const {")
|
|
source.append("\treturn get_node_internal(path);")
|
|
source.append("}")
|
|
source.append("")
|
|
else:
|
|
source.append("};")
|
|
source.append("")
|
|
|
|
source.append("")
|
|
|
|
source.append("#endif")
|
|
|
|
return "\n".join(source)
|
|
|
|
|
|
def generate_class_implementation(icalls, used_classes, c, use_template_get_node):
|
|
class_name = strip_name(c["name"])
|
|
|
|
ref_allowed = class_name != "Object" and class_name != "Reference"
|
|
|
|
source = []
|
|
source.append('#include "' + class_name_to_file_name(class_name) + '.h"')
|
|
source.append("")
|
|
source.append("")
|
|
|
|
source.append("#include <core/pandemonium_global.h>")
|
|
source.append("#include <core/core_types.h>")
|
|
source.append("#include <core/ref.h>")
|
|
|
|
source.append("#include <core/pandemonium.h>")
|
|
source.append("")
|
|
|
|
source.append('#include "__icalls.h"')
|
|
source.append("")
|
|
source.append("")
|
|
|
|
for used_class in used_classes:
|
|
if is_enum(used_class):
|
|
continue
|
|
else:
|
|
source.append('#include "' + class_name_to_file_name(strip_name(used_class)) + '.h"')
|
|
|
|
source.append("")
|
|
source.append("")
|
|
|
|
core_object_name = "this"
|
|
|
|
source.append("")
|
|
source.append("")
|
|
|
|
if c["singleton"]:
|
|
source.append("" + class_name + " *" + class_name + "::_singleton = NULL;")
|
|
source.append("")
|
|
source.append("")
|
|
|
|
# FIXME Test if inlining has a huge impact on binary size
|
|
source.append(class_name + "::" + class_name + "() {")
|
|
source.append('\t_owner = Pandemonium::api->pandemonium_global_get_singleton((char *) "' + strip_name(c["name"]) + '");')
|
|
source.append("}")
|
|
|
|
source.append("")
|
|
source.append("")
|
|
|
|
# Method table initialization
|
|
source.append(class_name + "::___method_bindings " + class_name + "::___mb = {};")
|
|
source.append("")
|
|
|
|
source.append("void *" + class_name + "::_detail_class_tag = nullptr;")
|
|
source.append("")
|
|
|
|
source.append("void " + class_name + "::___init_method_bindings() {")
|
|
|
|
for method in c["methods"]:
|
|
source.append(
|
|
"\t___mb.mb_"
|
|
+ method["name"]
|
|
+ ' = Pandemonium::api->pandemonium_method_bind_get_method("'
|
|
+ c["name"]
|
|
+ '", "'
|
|
+ ("get_node" if use_template_get_node and method["name"] == "get_node_internal" else method["name"])
|
|
+ '");'
|
|
)
|
|
|
|
source.append("\tpandemonium_string_name class_name;")
|
|
source.append('\tPandemonium::api->pandemonium_string_name_new_data_char(&class_name, "' + c["name"] + '");')
|
|
source.append("\t_detail_class_tag = Pandemonium::api->pandemonium_get_class_tag(&class_name);")
|
|
source.append("\tPandemonium::api->pandemonium_string_name_destroy(&class_name);")
|
|
|
|
source.append("}")
|
|
source.append("")
|
|
|
|
if c["instanciable"]:
|
|
source.append(class_name + " *" + strip_name(c["name"]) + "::_new()")
|
|
source.append("{")
|
|
source.append(
|
|
"\treturn ("
|
|
+ class_name
|
|
+ ' *) Pandemonium::nativescript_api->pandemonium_nativescript_get_instance_binding_data(_RegisterState::language_index, Pandemonium::api->pandemonium_get_class_constructor((char *)"'
|
|
+ c["name"]
|
|
+ '")());'
|
|
)
|
|
source.append("}")
|
|
|
|
for method in c["methods"]:
|
|
method_signature = ""
|
|
|
|
method_signature += make_gdnative_type(method["return_type"], ref_allowed)
|
|
method_signature += strip_name(c["name"]) + "::" + escape_cpp(method["name"]) + "("
|
|
|
|
for i, argument in enumerate(method["arguments"]):
|
|
method_signature += "const " + make_gdnative_type(argument["type"], ref_allowed)
|
|
method_signature += escape_cpp(argument["name"])
|
|
|
|
if i != len(method["arguments"]) - 1:
|
|
method_signature += ", "
|
|
|
|
if method["has_varargs"]:
|
|
if len(method["arguments"]) > 0:
|
|
method_signature += ", "
|
|
method_signature += "const Array& __var_args"
|
|
|
|
method_signature += ")" + (" const" if method["is_const"] else "")
|
|
|
|
source.append(method_signature + " {")
|
|
|
|
if method["name"] == "free":
|
|
# dirty hack because Object::free is marked virtual but doesn't actually exist...
|
|
source.append("\tPandemonium::api->pandemonium_object_destroy(_owner);")
|
|
source.append("}")
|
|
source.append("")
|
|
continue
|
|
|
|
return_statement = ""
|
|
return_type_is_ref = is_reference_type(method["return_type"]) and ref_allowed
|
|
|
|
if method["return_type"] != "void":
|
|
if is_class_type(method["return_type"]):
|
|
if is_enum(method["return_type"]):
|
|
return_statement += "return (" + remove_enum_prefix(method["return_type"]) + ") "
|
|
elif return_type_is_ref:
|
|
return_statement += "return Ref<" + strip_name(method["return_type"]) + ">::__internal_constructor("
|
|
else:
|
|
return_statement += "return " + (
|
|
"(" + strip_name(method["return_type"]) + " *) " if is_class_type(method["return_type"]) else ""
|
|
)
|
|
else:
|
|
return_statement += "return "
|
|
|
|
def get_icall_type_name(name):
|
|
if is_enum(name):
|
|
return "int"
|
|
if is_class_type(name):
|
|
return "Object"
|
|
return name
|
|
|
|
if method["has_varargs"]:
|
|
|
|
if len(method["arguments"]) != 0:
|
|
source.append("\tVariant __given_args[" + str(len(method["arguments"])) + "];")
|
|
|
|
for i, argument in enumerate(method["arguments"]):
|
|
source.append("\tPandemonium::api->pandemonium_variant_new_nil((pandemonium_variant *) &__given_args[" + str(i) + "]);")
|
|
|
|
source.append("")
|
|
|
|
for i, argument in enumerate(method["arguments"]):
|
|
source.append("\t__given_args[" + str(i) + "] = " + escape_cpp(argument["name"]) + ";")
|
|
|
|
source.append("")
|
|
|
|
size = ""
|
|
if method["has_varargs"]:
|
|
size = "(__var_args.size() + " + str(len(method["arguments"])) + ")"
|
|
else:
|
|
size = "(" + str(len(method["arguments"])) + ")"
|
|
|
|
source.append(
|
|
"\tpandemonium_variant **__args = (pandemonium_variant **) alloca(sizeof(pandemonium_variant *) * " + size + ");"
|
|
)
|
|
|
|
source.append("")
|
|
|
|
for i, argument in enumerate(method["arguments"]):
|
|
source.append("\t__args[" + str(i) + "] = (pandemonium_variant *) &__given_args[" + str(i) + "];")
|
|
|
|
source.append("")
|
|
|
|
if method["has_varargs"]:
|
|
source.append("\tfor (int i = 0; i < __var_args.size(); i++) {")
|
|
source.append(
|
|
"\t\t__args[i + "
|
|
+ str(len(method["arguments"]))
|
|
+ "] = (pandemonium_variant *) &((Array &) __var_args)[i];"
|
|
)
|
|
source.append("\t}")
|
|
|
|
source.append("")
|
|
|
|
source.append("\tVariant __result;")
|
|
source.append(
|
|
"\t*(pandemonium_variant *) &__result = Pandemonium::api->pandemonium_method_bind_call(___mb.mb_"
|
|
+ method["name"]
|
|
+ ", ((const Object *) "
|
|
+ core_object_name
|
|
+ ")->_owner, (const pandemonium_variant **) __args, "
|
|
+ size
|
|
+ ", nullptr);"
|
|
)
|
|
|
|
source.append("")
|
|
|
|
if is_class_type(method["return_type"]):
|
|
source.append("\tObject *obj = Object::___get_from_variant(__result);")
|
|
source.append('\tif (obj->has_method("reference"))')
|
|
source.append('\t\tobj->callv("reference", Array());')
|
|
|
|
source.append("")
|
|
|
|
for i, argument in enumerate(method["arguments"]):
|
|
source.append("\tPandemonium::api->pandemonium_variant_destroy((pandemonium_variant *) &__given_args[" + str(i) + "]);")
|
|
|
|
source.append("")
|
|
|
|
if method["return_type"] != "void":
|
|
cast = ""
|
|
if is_class_type(method["return_type"]):
|
|
if return_type_is_ref:
|
|
cast += "Ref<" + strip_name(method["return_type"]) + ">::__internal_constructor(__result);"
|
|
else:
|
|
cast += (
|
|
"("
|
|
+ strip_name(method["return_type"])
|
|
+ " *) "
|
|
+ strip_name(method["return_type"] + "::___get_from_variant(")
|
|
+ "__result);"
|
|
)
|
|
else:
|
|
cast += "__result;"
|
|
source.append("\treturn " + cast)
|
|
|
|
else:
|
|
|
|
args = []
|
|
for arg in method["arguments"]:
|
|
args.append(get_icall_type_name(arg["type"]))
|
|
|
|
icall_ret_type = get_icall_type_name(method["return_type"])
|
|
|
|
icall_sig = tuple((icall_ret_type, tuple(args)))
|
|
|
|
icalls.add(icall_sig)
|
|
|
|
icall_name = get_icall_name(icall_sig)
|
|
|
|
return_statement += icall_name + "(___mb.mb_" + method["name"] + ", (const Object *) " + core_object_name
|
|
|
|
for arg in method["arguments"]:
|
|
arg_is_ref = is_reference_type(arg["type"]) and ref_allowed
|
|
return_statement += ", " + escape_cpp(arg["name"]) + (".ptr()" if arg_is_ref else "")
|
|
|
|
return_statement += ")"
|
|
|
|
if return_type_is_ref:
|
|
return_statement += ")"
|
|
|
|
source.append("\t" + return_statement + ";")
|
|
|
|
source.append("}")
|
|
source.append("")
|
|
|
|
return "\n".join(source)
|
|
|
|
|
|
def generate_icall_header(icalls):
|
|
|
|
source = []
|
|
source.append("#ifndef PANDEMONIUM_CPP__ICALLS_H")
|
|
source.append("#define PANDEMONIUM_CPP__ICALLS_H")
|
|
|
|
source.append("")
|
|
|
|
source.append("#include <gdnative_api_struct.gen.h>")
|
|
source.append("#include <stdint.h>")
|
|
source.append("")
|
|
|
|
source.append("#include <core/pandemonium_global.h>")
|
|
source.append("#include <core/core_types.h>")
|
|
source.append('#include "object.h"')
|
|
source.append("")
|
|
source.append("")
|
|
|
|
source.append("")
|
|
|
|
for icall in icalls:
|
|
ret_type = icall[0]
|
|
args = icall[1]
|
|
|
|
method_signature = "static inline "
|
|
|
|
method_signature += (
|
|
get_icall_return_type(ret_type) + get_icall_name(icall) + "(pandemonium_method_bind *mb, const Object *inst"
|
|
)
|
|
|
|
for i, arg in enumerate(args):
|
|
method_signature += ", const "
|
|
|
|
if is_core_type(arg):
|
|
method_signature += arg + "&"
|
|
elif arg == "int":
|
|
method_signature += "int64_t "
|
|
elif arg == "float":
|
|
method_signature += "double "
|
|
elif is_primitive(arg):
|
|
method_signature += arg + " "
|
|
else:
|
|
method_signature += "Object *"
|
|
|
|
method_signature += "arg" + str(i)
|
|
|
|
method_signature += ")"
|
|
|
|
source.append(method_signature + " {")
|
|
|
|
if ret_type != "void":
|
|
source.append(
|
|
"\t" + ("pandemonium_object *" if is_class_type(ret_type) else get_icall_return_type(ret_type)) + "ret;"
|
|
)
|
|
if is_class_type(ret_type):
|
|
source.append("\tret = nullptr;")
|
|
|
|
source.append("\tconst void *args[" + ("1" if len(args) == 0 else "") + "] = {")
|
|
|
|
for i, arg in enumerate(args):
|
|
|
|
wrapped_argument = "\t\t"
|
|
if is_primitive(arg) or is_core_type(arg):
|
|
wrapped_argument += "(void *) &arg" + str(i)
|
|
else:
|
|
wrapped_argument += "(void *) (arg" + str(i) + ") ? arg" + str(i) + "->_owner : nullptr"
|
|
|
|
wrapped_argument += ","
|
|
source.append(wrapped_argument)
|
|
|
|
source.append("\t};")
|
|
source.append("")
|
|
|
|
source.append(
|
|
"\tPandemonium::api->pandemonium_method_bind_ptrcall(mb, inst->_owner, args, "
|
|
+ ("nullptr" if ret_type == "void" else "&ret")
|
|
+ ");"
|
|
)
|
|
|
|
if ret_type != "void":
|
|
if is_class_type(ret_type):
|
|
source.append("\tif (ret) {")
|
|
source.append(
|
|
"\t\treturn (Object *) Pandemonium::nativescript_api->pandemonium_nativescript_get_instance_binding_data(_RegisterState::language_index, ret);"
|
|
)
|
|
source.append("\t}")
|
|
source.append("")
|
|
source.append("\treturn (Object *) ret;")
|
|
else:
|
|
source.append("\treturn ret;")
|
|
|
|
source.append("}")
|
|
source.append("")
|
|
|
|
source.append("")
|
|
|
|
source.append("#endif")
|
|
|
|
return "\n".join(source)
|
|
|
|
|
|
def generate_type_registry(classes):
|
|
source = []
|
|
|
|
source.append('#include "tag_db.h"')
|
|
source.append("#include <typeinfo>")
|
|
source.append("\n")
|
|
|
|
for c in classes:
|
|
source.append("#include <" + class_name_to_file_name(strip_name(c["name"])) + ".h>")
|
|
|
|
source.append("")
|
|
source.append("")
|
|
|
|
source.append("void ___register_types()")
|
|
source.append("{")
|
|
|
|
for c in classes:
|
|
class_name = strip_name(c["name"])
|
|
base_class_name = strip_name(c["base_class"])
|
|
|
|
class_type_hash = "typeid(" + class_name + ").hash_code()"
|
|
|
|
base_class_type_hash = "typeid(" + base_class_name + ").hash_code()"
|
|
|
|
if base_class_name == "":
|
|
base_class_type_hash = "0"
|
|
|
|
source.append(
|
|
'\t_TagDB::register_global_type("'
|
|
+ c["name"]
|
|
+ '", '
|
|
+ class_type_hash
|
|
+ ", "
|
|
+ base_class_type_hash
|
|
+ ");"
|
|
)
|
|
|
|
source.append("}")
|
|
|
|
source.append("")
|
|
|
|
return "\n".join(source)
|
|
|
|
|
|
def generate_init_method_bindings(classes):
|
|
source = []
|
|
|
|
for c in classes:
|
|
source.append("#include <" + class_name_to_file_name(strip_name(c["name"])) + ".h>")
|
|
|
|
source.append("")
|
|
source.append("")
|
|
|
|
source.append("void ___init_method_bindings()")
|
|
source.append("{")
|
|
|
|
for c in classes:
|
|
source.append("\t" + strip_name(c["name"]) + "::___init_method_bindings();")
|
|
|
|
source.append("}")
|
|
|
|
source.append("")
|
|
|
|
return "\n".join(source)
|
|
|
|
|
|
def get_icall_return_type(t):
|
|
if is_class_type(t):
|
|
return "Object *"
|
|
if t == "int":
|
|
return "int64_t "
|
|
if t == "float" or t == "real":
|
|
return "double "
|
|
return t + " "
|
|
|
|
|
|
def get_icall_name(sig):
|
|
ret_type = sig[0]
|
|
args = sig[1]
|
|
|
|
name = "___pandemonium_icall_"
|
|
name += strip_name(ret_type)
|
|
for arg in args:
|
|
name += "_" + strip_name(arg)
|
|
|
|
return name
|
|
|
|
|
|
def get_used_classes(c):
|
|
classes = []
|
|
for method in c["methods"]:
|
|
if is_class_type(method["return_type"]) and not (method["return_type"] in classes):
|
|
classes.append(method["return_type"])
|
|
|
|
for arg in method["arguments"]:
|
|
if is_class_type(arg["type"]) and not (arg["type"] in classes):
|
|
classes.append(arg["type"])
|
|
return classes
|
|
|
|
|
|
def strip_name(name):
|
|
if len(name) == 0:
|
|
return name
|
|
if name[0] == "_":
|
|
return name[1:]
|
|
return name
|
|
|
|
|
|
def extract_nested_type(nested_type):
|
|
return strip_name(nested_type[: nested_type.find("::")])
|
|
|
|
|
|
def remove_nested_type_prefix(name):
|
|
return name if name.find("::") == -1 else strip_name(name[name.find("::") + 2 :])
|
|
|
|
|
|
def remove_enum_prefix(name):
|
|
return strip_name(name[name.find("enum.") + 5 :])
|
|
|
|
|
|
def is_nested_type(name, type=""):
|
|
return name.find(type + "::") != -1
|
|
|
|
|
|
def is_enum(name):
|
|
return name.find("enum.") == 0
|
|
|
|
|
|
def is_class_type(name):
|
|
return not is_core_type(name) and not is_primitive(name)
|
|
|
|
|
|
def is_core_type(name):
|
|
core_types = [
|
|
"String",
|
|
"Rect2",
|
|
"Rect2i",
|
|
"Vector2",
|
|
"Vector2i",
|
|
"Vector3",
|
|
"Vector3i",
|
|
"Vector4",
|
|
"Vector4i",
|
|
"Plane",
|
|
"Quaternion",
|
|
"AABB",
|
|
"Basis",
|
|
"Transform",
|
|
"Transform2D",
|
|
"Projection",
|
|
"Color",
|
|
"NodePath",
|
|
"RID",
|
|
# Object
|
|
"StringName",
|
|
"Dictionary",
|
|
"Array",
|
|
"PoolByteArray",
|
|
"PoolIntArray",
|
|
"PoolRealArray",
|
|
"PoolStringArray",
|
|
"PoolVector2Array",
|
|
"PoolVector2iArray",
|
|
"PoolVector3Array",
|
|
"PoolVector3iArray",
|
|
"PoolVector4Array",
|
|
"PoolVector4iArray",
|
|
"PoolColorArray",
|
|
"Error",
|
|
"Variant",
|
|
]
|
|
return name in core_types
|
|
|
|
|
|
def is_primitive(name):
|
|
core_types = ["int", "bool", "real", "float", "void"]
|
|
return name in core_types
|
|
|
|
|
|
def escape_cpp(name):
|
|
escapes = {
|
|
"class": "_class",
|
|
"enum": "_enum",
|
|
"char": "_char",
|
|
"short": "_short",
|
|
"bool": "_bool",
|
|
"int": "_int",
|
|
"default": "_default",
|
|
"case": "_case",
|
|
"switch": "_switch",
|
|
"export": "_export",
|
|
"template": "_template",
|
|
"new": "new_",
|
|
"operator": "_operator",
|
|
"typename": "_typename",
|
|
}
|
|
if name in escapes:
|
|
return escapes[name]
|
|
return name
|