X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=genbindings.py;h=ca88a3aa989fe43792e5521cf7e6d2d264902cd6;hb=e89532158935ae8f50afa790feea9d525d976ded;hp=96fafb70b39e32f66a4ead0dc2bcc7bbfa9ad8ef;hpb=25b52e9c5f741b49bc708de89faf84a55e003a69;p=ldk-java diff --git a/genbindings.py b/genbindings.py index 96fafb70..ca88a3aa 100755 --- a/genbindings.py +++ b/genbindings.py @@ -14,8 +14,12 @@ else: sys.exit(1) target = None -if sys.argv[6] == "java": +if sys.argv[6] == "java" or sys.argv[6] == "android": + import java_strings from java_strings import Consts + target = java_strings.Target.JAVA + if sys.argv[6] == "android": + target = java_strings.Target.ANDROID elif sys.argv[6] == "typescript": import typescript_strings from typescript_strings import Consts @@ -221,7 +225,8 @@ def java_c_types(fn_arg, ret_arr_len): c_ty = "int64_t" fn_arg = fn_arg[8:].strip() else: - c_ty = "intptr_t" + c_ty = "int64_t" + rust_obj = "uintptr_t" fn_arg = fn_arg[9:].strip() is_primitive = True elif is_const and fn_arg.startswith("char *"): @@ -303,7 +308,6 @@ def java_c_types(fn_arg, ret_arr_len): c_ty = consts.ptr_c_ty java_ty = consts.ptr_native_ty fn_ty_arg = "J" - is_primitive = False var_is_arr = var_is_arr_regex.match(fn_arg) if var_is_arr is not None or ret_arr_len is not None: @@ -344,7 +348,7 @@ with open(sys.argv[1]) as in_h: clone_fns.add(reg_fn.group(2)) else: rty = java_c_types(reg_fn.group(1), None) - if rty is not None and rty.rust_obj is not None and reg_fn.group(2) == rty.java_hu_ty + "_new": + if rty is not None and not rty.is_native_primitive and reg_fn.group(2) == rty.java_hu_ty + "_new": constructor_fns[rty.rust_obj] = reg_fn.group(3) continue arr_fn = fn_ret_arr_regex.match(line) @@ -360,12 +364,12 @@ write_c("static inline struct LDKThirtyTwoBytes ThirtyTwoBytes_clone(const struc java_c_types_none_allowed = False # C structs created by cbindgen are declared in dependency order -with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java: +with open(f"{sys.argv[3]}/structs/UtilMethods{consts.file_ext}", "a") as util: + util.write(consts.util_fn_pfx) +with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java: # Map a top-level function def map_fn(line, re_match, ret_arr_len, c_call_string): - - # PARSING START method_return_type = re_match.group(1) method_name = re_match.group(2) method_comma_separated_arguments = re_match.group(3) @@ -400,24 +404,41 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java: default_constructor_args[argument_conversion_info.arg_name].append(explode_arg_conv) argument_types.append(argument_conversion_info) - has_out_java_struct = ("LDK" + struct_meth in opaque_structs or "LDK" + struct_meth in trait_structs) and not is_free - # PARSING END - out_java.write("\t// " + line) - - (out_java_delta, out_c_delta, out_java_struct_delta) = consts.map_function(argument_types, c_call_string, is_free, method_name, return_type_info, struct_meth, default_constructor_args, takes_self, args_known, has_out_java_struct, type_mapping_generator) - + (out_java_delta, out_c_delta, out_java_struct_delta) = consts.map_function(argument_types, c_call_string, method_name, return_type_info, struct_meth, default_constructor_args, takes_self, args_known, type_mapping_generator) out_java.write(out_java_delta) - write_c(out_c_delta) - if has_out_java_struct: + if is_free: + assert len(argument_types) == 1 + assert return_type_info.c_ty == "void" + write_c(consts.c_fn_ty_pfx + "void " + consts.c_fn_name_define_pfx(method_name, True) + argument_types[0].c_ty + " " + argument_types[0].ty_info.var_name + ") {\n") + if argument_types[0].ty_info.passed_as_ptr and not argument_types[0].ty_info.rust_obj in opaque_structs: + write_c("\tif ((" + argument_types[0].ty_info.var_name + " & 1) != 0) return;\n") + + for info in argument_types: + if info.arg_conv is not None: + write_c("\t" + info.arg_conv.replace('\n', "\n\t") + "\n") + assert c_call_string is None + write_c("\t" + method_name + "(") + if argument_types[0].arg_conv_name is not None: + write_c(argument_types[0].arg_conv_name) + write_c(");") + for info in argument_types: + if info.arg_conv_cleanup is not None: + write_c("\n\t" + info.arg_conv_cleanup.replace("\n", "\n\t")) + write_c("\n}\n\n") + else: + write_c(out_c_delta) + + out_java_struct = None + if ("LDK" + struct_meth in opaque_structs or "LDK" + struct_meth in trait_structs) and not is_free: out_java_struct = open(f"{sys.argv[3]}/structs/{struct_meth}{consts.file_ext}", "a") + elif method_name.startswith("C2Tuple_") and method_name.endswith("_read"): + struct_meth = method_name.rsplit("_", 1)[0] + out_java_struct = open(f"{sys.argv[3]}/structs/UtilMethods{consts.file_ext}", "a") + if out_java_struct is not None: out_java_struct.write(out_java_struct_delta) - - - - def map_unitary_enum(struct_name, field_lines): with open(f"{sys.argv[3]}/enums/{struct_name}{consts.file_ext}", "w") as out_java_enum: unitary_enums.add(struct_name) @@ -550,7 +571,7 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java: out_java.write("\tpublic static native " + res_map.java_ty + " " + struct_name + "_get_ok(long arg);\n") write_c(consts.c_fn_ty_pfx + res_map.c_ty + " " + consts.c_fn_name_define_pfx(struct_name + "_get_ok", True) + consts.ptr_c_ty + " arg) {\n") - write_c("\t" + struct_name + " *val = (" + struct_name + "*)arg;\n") + write_c("\t" + struct_name + " *val = (" + struct_name + "*)(arg & ~1);\n") write_c("\tCHECK(val->result_ok);\n\t") out_java_struct.write("\tpublic static final class " + human_ty + "_OK extends " + human_ty + " {\n") if res_map.ret_conv is not None: @@ -580,14 +601,14 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java: if res_map.from_hu_conv is not None: out_java_struct.write("\t\t\tthis(null, bindings.C" + human_ty + "_ok(" + res_map.from_hu_conv[0] + "));\n") if res_map.from_hu_conv[1] != "": - out_java_struct.write("\t\t\t" + res_map.from_hu_conv[1] + ";\n") + out_java_struct.write("\t\t\t" + res_map.from_hu_conv[1].replace("\n", "\n\t\t\t") + ";\n") else: out_java_struct.write("\t\t\tthis(null, bindings.C" + human_ty + "_ok(res));\n") out_java_struct.write("\t\t}\n\t}\n\n") out_java.write("\tpublic static native " + err_map.java_ty + " " + struct_name + "_get_err(long arg);\n") write_c(consts.c_fn_ty_pfx + err_map.c_ty + " " + consts.c_fn_name_define_pfx(struct_name + "_get_err", True) + consts.ptr_c_ty + " arg) {\n") - write_c("\t" + struct_name + " *val = (" + struct_name + "*)arg;\n") + write_c("\t" + struct_name + " *val = (" + struct_name + "*)(arg & ~1);\n") write_c("\tCHECK(!val->result_ok);\n\t") out_java_struct.write("\tpublic static final class " + human_ty + "_Err extends " + human_ty + " {\n") if err_map.ret_conv is not None: @@ -618,7 +639,7 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java: if err_map.from_hu_conv is not None: out_java_struct.write("\t\t\tthis(null, bindings.C" + human_ty + "_err(" + err_map.from_hu_conv[0] + "));\n") if err_map.from_hu_conv[1] != "": - out_java_struct.write("\t\t\t" + err_map.from_hu_conv[1] + ";\n") + out_java_struct.write("\t\t\t" + err_map.from_hu_conv[1].replace("\n", "\n\t\t\t") + ";\n") else: out_java_struct.write("\t\t\tthis(null, bindings.C" + human_ty + "_err(err));\n") out_java_struct.write("\t\t}\n\t}\n}\n") @@ -659,7 +680,7 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java: e = chr(ord('a') + idx) out_java.write("\tpublic static native " + ty_info.java_ty + " " + struct_name + "_get_" + e + "(long ptr);\n") write_c(consts.c_fn_ty_pfx + ty_info.c_ty + " " + consts.c_fn_name_define_pfx(struct_name + "_get_" + e, True) + consts.ptr_c_ty + " ptr) {\n") - write_c("\t" + struct_name + " *tuple = (" + struct_name + "*)ptr;\n") + write_c("\t" + struct_name + " *tuple = (" + struct_name + "*)(ptr & ~1);\n") conv_info = type_mapping_generator.map_type_with_info(ty_info, False, None, False, True) if conv_info.ret_conv is not None: write_c("\t" + conv_info.ret_conv[0].replace("\n", "\n\t") + "tuple->" + e + conv_info.ret_conv[1].replace("\n", "\n\t") + "\n") @@ -893,3 +914,5 @@ with open(sys.argv[4], "w") as out_c: out_c.write(consts.c_file_pfx) out_c.write(consts.init_str()) out_c.write(c_file) +with open(f"{sys.argv[3]}/structs/UtilMethods{consts.file_ext}", "a") as util: + util.write(consts.util_fn_sfx)