+ write_c(out_c_delta)
+
+ out_java_struct = None
+ if impl_on_struct:
+ out_java_struct = open(f"{sys.argv[3]}/structs/{struct_meth}{consts.file_ext}", "a")
+ out_java_struct.write(out_java_struct_delta)
+ elif impl_on_utils:
+ out_java_struct = open(f"{sys.argv[3]}/structs/UtilMethods{consts.file_ext}", "a")
+ for line in out_java_struct_delta.splitlines():
+ out_java_struct.write(line + "\n")
+
+ def map_unitary_enum(struct_name, field_lines, enum_doc_comment):
+ assert struct_name.startswith("LDK")
+ with open(f"{sys.argv[3]}/enums/{struct_name[3:]}{consts.file_ext}", "w") as out_java_enum:
+ unitary_enums.add(struct_name)
+ for idx, (struct_line, _) in enumerate(field_lines):
+ if idx == 0:
+ assert(struct_line == "typedef enum %s {" % struct_name)
+ elif idx == len(field_lines) - 3:
+ assert(struct_line.endswith("_Sentinel,"))
+ elif idx == len(field_lines) - 2:
+ assert(struct_line == "} %s;" % struct_name)
+ elif idx == len(field_lines) - 1:
+ assert(struct_line == "")
+ assert struct_name.startswith("LDK")
+ (c_out, native_file_out, native_out) = consts.native_c_unitary_enum_map(struct_name[3:], [(x.strip().strip(","), y) for x, y in field_lines[1:-3]], enum_doc_comment)
+ write_c(c_out)
+ out_java_enum.write(native_file_out)
+ out_java.write(native_out)
+
+ def map_complex_enum(struct_name, union_enum_items, inline_enum_variants, enum_doc_comment):
+ java_hu_type = struct_name.replace("LDK", "").replace("COption", "Option")
+
+ enum_variants = []
+ tag_field_lines = union_enum_items["field_lines"]
+ contains_trait = False
+ for idx, (struct_line, variant_docs) in enumerate(tag_field_lines):
+ if idx == 0:
+ assert(struct_line == "typedef enum %s_Tag {" % struct_name)
+ elif idx == len(tag_field_lines) - 3:
+ assert(struct_line.endswith("_Sentinel,"))
+ elif idx == len(tag_field_lines) - 2:
+ assert(struct_line == "} %s_Tag;" % struct_name)
+ elif idx == len(tag_field_lines) - 1:
+ assert(struct_line == "")
+ else:
+ variant_name = struct_line.strip(' ,')[len(struct_name) + 1:]
+ fields = []
+ if "LDK" + variant_name in union_enum_items:
+ enum_var_lines = union_enum_items["LDK" + variant_name]
+ for idx, (field, field_docs) in enumerate(enum_var_lines):
+ if idx != 0 and idx < len(enum_var_lines) - 2 and field.strip() != "":
+ field_ty = type_mapping_generator.java_c_types(field.strip(' ;'), None)
+ contains_trait |= field_ty.contains_trait
+ if field_docs is not None and doc_to_field_nullable(field_docs):
+ field_conv = type_mapping_generator.map_type_with_info(field_ty, False, None, False, True, True)
+ else:
+ field_conv = type_mapping_generator.map_type_with_info(field_ty, False, None, False, True, False)
+ fields.append((field_conv, field_docs))
+ enum_variants.append(ComplexEnumVariantInfo(variant_name, variant_docs, fields, False))
+ elif camel_to_snake(variant_name) in inline_enum_variants:
+ # TODO: If we ever have a rust enum Variant(Option<Struct>) we need to pipe
+ # docs through to there, and then potentially mark the field nullable.
+ mapped = type_mapping_generator.map_type(inline_enum_variants[camel_to_snake(variant_name)] + " " + camel_to_snake(variant_name), False, None, False, True)
+ contains_trait |= mapped.ty_info.contains_trait
+ fields.append((mapped, None))
+ enum_variants.append(ComplexEnumVariantInfo(variant_name, variant_docs, fields, True))
+ else:
+ 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), ))
+ flattened_field_var_convs.extend(trait_structs[var_line.group(1)])
+ 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] = 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:
+ assert False # This isn't yet handled on the Java side
+ ret_ty_info.nullable = True
+ ret_ty_info = type_mapping_generator.map_nullable_type(fn_line.group(2).strip() + " ret", True, None, False, False)
+ 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.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