- return TypeInfo(c_ty = c_ty, java_ty = java_ty, arg_name = var_name,
- ret_conv = ("long ret = (long)", ";"), ret_conv_name = "ret",
- arg_conv = None, arg_conv_name = None)
- else:
- return TypeInfo(c_ty = c_ty, java_ty = java_ty, arg_name = var_name,
- arg_conv = None, arg_conv_name = None, ret_conv = None, ret_conv_name = None)
-
- def map_fn(re_match, ret_arr_len):
- out_java.write("\t/// " + line)
- out_java.write("\tpublic static native ")
- out_c.write("JNIEXPORT ")
-
- ret_info = map_type(re_match.group(1), True, ret_arr_len, False)
- ret_info.print_ty()
- if ret_info.ret_conv is not None:
- ret_conv_pfx, ret_conv_sfx = ret_info.ret_conv
-
- out_java.write(" " + re_match.group(2) + "(")
- out_c.write(" JNICALL Java_org_ldk_impl_bindings_" + re_match.group(2).replace('_', '_1') + "(JNIEnv * _env, jclass _b")
-
- arg_names = []
- for idx, arg in enumerate(re_match.group(3).split(',')):
- if idx != 0:
- out_java.write(", ")
- if arg != "void":
- out_c.write(", ")
- arg_conv_info = map_type(arg, False, None, re_match.group(2).endswith("_free"))
- if arg_conv_info.c_ty != "void":
- arg_conv_info.print_ty()
- arg_conv_info.print_name()
- arg_names.append(arg_conv_info)
-
- out_java.write(");\n")
- out_c.write(") {\n")
-
- for info in arg_names:
- if info.arg_conv is not None:
- out_c.write("\t" + info.arg_conv.replace('\n', "\n\t") + "\n");
-
- if ret_info.ret_conv is not None:
- out_c.write("\t" + ret_conv_pfx.replace('\n', '\n\t'));
- else:
- out_c.write("\treturn ");
-
- out_c.write(re_match.group(2) + "(")
- for idx, info in enumerate(arg_names):
- if info.arg_conv_name is not None:
- if idx != 0:
- out_c.write(", ")
- out_c.write(info.arg_conv_name)
- out_c.write(")")
- if ret_info.ret_conv is not None:
- out_c.write(ret_conv_sfx.replace('\n', '\n\t'))
- out_c.write("\n\treturn " + ret_info.ret_conv_name + ";")
+ enum_variants.append(ComplexEnumVariantInfo(variant_name, variant_docs, fields, True))
+ complex_enums[struct_name] = contains_trait
+
+ with open(f"{sys.argv[3]}/structs/{java_hu_type}{consts.file_ext}", "w") as out_java_enum:
+ (out_java_addendum, out_java_enum_addendum, out_c_addendum) = consts.map_complex_enum(struct_name, enum_variants, camel_to_snake, enum_doc_comment)
+
+ out_java_enum.write(out_java_enum_addendum)
+ out_java.write(out_java_addendum)
+ write_c(out_c_addendum)
+
+ def map_trait(struct_name, field_var_lines, trait_fn_lines, trait_doc_comment):
+ with open(f"{sys.argv[3]}/structs/{struct_name.replace('LDK', '')}{consts.file_ext}", "w") as out_java_trait:
+ field_var_convs = []
+ flattened_field_var_convs = []
+ for var_line in field_var_lines:
+ if var_line.group(1) in trait_structs:
+ field_var_convs.append((var_line.group(1), var_line.group(2), trait_structs[var_line.group(1)]))
+ flattened_field_var_convs.append((var_line.group(1), var_line.group(2), var_line.group(2)))
+ for field_var in trait_structs[var_line.group(1)]:
+ if isinstance(field_var, ConvInfo):
+ flattened_field_var_convs.append(field_var)
+ else:
+ path = var_line.group(2)
+ if len(field_var) > 2:
+ path = var_line.group(2) + "." + field_var[2]
+ flattened_field_var_convs.append((field_var[0], field_var[1], path))
+ else:
+ mapped = type_mapping_generator.map_type(var_line.group(1) + " " + var_line.group(2), False, None, False, False)
+ field_var_convs.append(mapped)
+ flattened_field_var_convs.append(mapped)
+ trait_structs[struct_name] = flattened_field_var_convs
+
+ field_fns = []
+ for fn_docs, fn_line in trait_fn_lines:
+ if fn_line == "cloned":
+ ret_ty_info = type_mapping_generator.map_type("void", True, None, False, False)
+ field_fns.append(TraitMethInfo("cloned", False, ret_ty_info, [], fn_docs))
+ else:
+ (nullable_params, ret_nullable) = doc_to_params_ret_nullable(fn_docs)
+ if ret_nullable:
+ ret_ty_info = type_mapping_generator.map_nullable_type(fn_line.group(2).strip() + " ret", True, None, False, False)
+ ret_ty_info.nullable = True
+ else:
+ ret_ty_info = type_mapping_generator.map_type(fn_line.group(2).strip() + " ret", True, None, False, False)
+ is_const = fn_line.group(4) is not None
+
+ arg_tys = []
+ for idx, arg in enumerate(fn_line.group(5).split(',')):
+ if arg == "":
+ continue
+ arg_ty_info = type_mapping_generator.java_c_types(arg, None)
+ if arg_ty_info.var_name in nullable_params:
+ # Types that are actually null instead of all-0s aren't yet handled on the Java side:
+ arg_conv_info = type_mapping_generator.map_type_with_info(arg_ty_info, True, None, False, False, True)
+ else:
+ arg_conv_info = type_mapping_generator.map_type_with_info(arg_ty_info, True, None, False, False, False)
+ arg_tys.append(arg_conv_info)
+ field_fns.append(TraitMethInfo(fn_line.group(3), is_const, ret_ty_info, arg_tys, fn_docs))
+
+ (out_java_addendum, out_java_trait_addendum, out_c_addendum) = consts.native_c_map_trait(struct_name, field_var_convs, flattened_field_var_convs, field_fns, trait_doc_comment)
+ write_c(out_c_addendum)
+ out_java_trait.write(out_java_trait_addendum)
+ out_java.write(out_java_addendum)
+
+ for fn_docs, fn_line in trait_fn_lines:
+ if fn_line == "cloned":
+ continue
+ # For now, just disable enabling the _call_log - we don't know how to inverse-map String
+ is_log = fn_line.group(3) == "log" and struct_name == "LDKLogger"
+ if fn_line.group(3) != "free" and fn_line.group(3) != "eq" and not is_log:
+ dummy_line = fn_line.group(2) + struct_name.replace("LDK", "") + "_" + fn_line.group(3) + " " + struct_name + " *NONNULL_PTR this_arg" + fn_line.group(5) + "\n"
+ map_fn(dummy_line, re.compile("([A-Za-z_0-9]*) *([A-Za-z_0-9]*) *(.*)").match(dummy_line), None, "(this_arg_conv->" + fn_line.group(3) + ")(this_arg_conv->this_arg", fn_docs)
+ for idx, var_line in enumerate(field_var_lines):
+ if var_line.group(1) not in trait_structs:
+ write_c(var_line.group(1) + " " + struct_name + "_set_get_" + var_line.group(2) + "(" + struct_name + "* this_arg) {\n")
+ write_c("\tif (this_arg->set_" + var_line.group(2) + " != NULL)\n")
+ write_c("\t\tthis_arg->set_" + var_line.group(2) + "(this_arg);\n")
+ write_c("\treturn this_arg->" + var_line.group(2) + ";\n")
+ write_c("}\n")
+ dummy_line = var_line.group(1) + " " + struct_name.replace("LDK", "") + "_get_" + var_line.group(2) + " " + struct_name + " *NONNULL_PTR this_arg" + fn_line.group(5) + "\n"
+ map_fn(dummy_line, re.compile("([A-Za-z_0-9]*) *([A-Za-z_0-9]*) *(.*)").match(dummy_line), None, struct_name + "_set_get_" + var_line.group(2) + "(this_arg_conv", fn_docs)
+
+ def map_result(struct_name, res_ty, err_ty):
+ result_types.add(struct_name)
+ human_ty = struct_name.replace("LDKCResult", "Result")
+ res_map = type_mapping_generator.map_type(res_ty + " res", True, None, False, True)
+ err_map = type_mapping_generator.map_type(err_ty + " err", True, None, False, True)
+ java_hu_struct = consts.map_result(struct_name, res_map, err_map)
+ create_getter(struct_name, res_ty, "ok", ("*", "->contents.result"), ("", "->result_ok"))
+ create_getter(struct_name, err_ty, "err", ("*", "->contents.err"), ("!", "->result_ok"))
+ with open(f"{sys.argv[3]}/structs/{human_ty}{consts.file_ext}", "w") as out_java_struct:
+ out_java_struct.write(java_hu_struct)
+
+ def create_getter(struct_name, field_decl, field_name, accessor, check_sfx):
+ field_ty = java_c_types(field_decl + " " + field_name, None)
+ ptr_fn_defn = field_decl + " *" + struct_name.replace("LDK", "") + "_get_" + field_name + "(" + struct_name + " *NONNULL_PTR owner)"
+ owned_fn_defn = field_decl + " " + struct_name.replace("LDK", "") + "_get_" + field_name + "(" + struct_name + " *NONNULL_PTR owner)"
+
+ holds_ref = False
+ if field_ty.rust_obj is not None and field_ty.rust_obj in opaque_structs:
+ fn_defn = owned_fn_defn
+ write_c("static inline " + fn_defn + "{\n")
+ write_c("\t" + field_ty.rust_obj + " ret = " + accessor[0] + "owner" + accessor[1] + ";\n")
+ write_c("\tret.is_owned = false;\n")
+ write_c("\treturn ret;\n")
+ elif field_ty.rust_obj is not None and field_ty.rust_obj.replace("LDK", "") + "_clone" in clone_fns:
+ fn_defn = owned_fn_defn
+ write_c("static inline " + fn_defn + "{\n")
+ if check_sfx is not None:
+ write_c("CHECK(" + check_sfx[0] + "owner" + check_sfx[1] + ");\n")
+ write_c("\treturn " + field_ty.rust_obj.replace("LDK", "") + "_clone(&" + accessor[0] + "owner" + accessor[1] + ");\n")
+ elif field_ty.arr_len is not None or field_ty.is_native_primitive or field_ty.rust_obj in unitary_enums:
+ fn_defn = owned_fn_defn
+ write_c("static inline " + fn_defn + "{\n")
+ if check_sfx is not None:
+ write_c("CHECK(" + check_sfx[0] + "owner" + check_sfx[1] + ");\n")
+ write_c("\treturn " + accessor[0] + "owner" + accessor[1] + ";\n")
+ holds_ref = True