X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=genbindings.py;h=175340d6246c1eb789411aec04c9a07a72a617f1;hb=0b84bd29ac3af544cb8c88a7f581dee337a89ac3;hp=c6d672f1510f4100ed63495294b1ebb2f1e6e5ce;hpb=a9107fb68d1b3b205c70eb959cc7c559bdcffd7b;p=ldk-java

diff --git a/genbindings.py b/genbindings.py
index c6d672f1..175340d6 100755
--- a/genbindings.py
+++ b/genbindings.py
@@ -31,7 +31,7 @@ else:
     sys.exit(1)
 
 
-consts = Consts(DEBUG, target=target)
+consts = Consts(DEBUG, target=target, outdir=sys.argv[4])
 
 local_git_version = os.getenv("LDK_GARBAGECOLLECTED_GIT_OVERRIDE")
 if local_git_version is None:
@@ -150,7 +150,7 @@ def java_c_types(fn_arg, ret_arr_len):
         rust_obj = "LDKSignature"
         arr_access = "compact_form"
     elif fn_arg.startswith("LDKRecoverableSignature"):
-        fn_arg = "uint8_t (*" + fn_arg[25:] + ")[68]"
+        fn_arg = "uint8_t (*" + fn_arg[24:] + ")[68]"
         assert var_is_arr_regex.match(fn_arg[8:])
         rust_obj = "LDKRecoverableSignature"
         arr_access = "serialized_form"
@@ -174,10 +174,10 @@ def java_c_types(fn_arg, ret_arr_len):
         assert var_is_arr_regex.match(fn_arg[8:])
         rust_obj = "LDKTwentyBytes"
         arr_access = "data"
-    elif fn_arg.startswith("LDKTenBytes"):
-        fn_arg = "uint8_t (*" + fn_arg[12:] + ")[10]"
+    elif fn_arg.startswith("LDKTwelveBytes"):
+        fn_arg = "uint8_t (*" + fn_arg[15:] + ")[12]"
         assert var_is_arr_regex.match(fn_arg[8:])
-        rust_obj = "LDKTenBytes"
+        rust_obj = "LDKTwelveBytes"
         arr_access = "data"
     elif fn_arg.startswith("LDKu8slice"):
         fn_arg = "uint8_t (*" + fn_arg[11:] + ")[datalen]"
@@ -214,13 +214,14 @@ def java_c_types(fn_arg, ret_arr_len):
             return None
         if is_ptr:
             res.pass_by_ref = True
+        java_ty = consts.java_arr_ty_str(res.java_ty)
         if res.is_native_primitive or res.passed_as_ptr:
-            return TypeInfo(rust_obj=fn_arg.split(" ")[0], java_ty=res.java_ty + "[]", java_hu_ty=res.java_hu_ty + "[]",
+            return TypeInfo(rust_obj=fn_arg.split(" ")[0], java_ty=java_ty, java_hu_ty=res.java_hu_ty + "[]",
                 java_fn_ty_arg="[" + res.java_fn_ty_arg, c_ty=res.c_ty + "Array", passed_as_ptr=False, is_ptr=is_ptr,
                 nonnull_ptr=nonnull_ptr, is_const=is_const,
                 var_name=res.var_name, arr_len="datalen", arr_access="data", subty=res, is_native_primitive=False)
         else:
-            return TypeInfo(rust_obj=fn_arg.split(" ")[0], java_ty=res.java_ty + "[]", java_hu_ty=res.java_hu_ty + "[]",
+            return TypeInfo(rust_obj=fn_arg.split(" ")[0], java_ty=java_ty, java_hu_ty=res.java_hu_ty + "[]",
                 java_fn_ty_arg="[" + res.java_fn_ty_arg, c_ty=consts.ptr_arr, passed_as_ptr=False, is_ptr=is_ptr,
                 nonnull_ptr=nonnull_ptr, is_const=is_const,
                 var_name=res.var_name, arr_len="datalen", arr_access="data", subty=res, is_native_primitive=False)
@@ -230,6 +231,7 @@ def java_c_types(fn_arg, ret_arr_len):
     arr_len = None
     mapped_type = []
     java_type_plural = None
+    arr_ty = None
     if fn_arg.startswith("void"):
         java_ty = "void"
         c_ty = "void"
@@ -240,6 +242,7 @@ def java_c_types(fn_arg, ret_arr_len):
         java_ty = "boolean"
         c_ty = "jboolean"
         fn_ty_arg = "Z"
+        arr_ty = "bool"
         fn_arg = fn_arg[4:].strip()
         is_primitive = True
     elif fn_arg.startswith("uint8_t"):
@@ -247,6 +250,7 @@ def java_c_types(fn_arg, ret_arr_len):
         java_ty = mapped_type[0]
         c_ty = "int8_t"
         fn_ty_arg = "B"
+        arr_ty = "uint8_t"
         fn_arg = fn_arg[7:].strip()
         is_primitive = True
     elif fn_arg.startswith("LDKu5"):
@@ -254,12 +258,14 @@ def java_c_types(fn_arg, ret_arr_len):
         java_hu_ty = "UInt5"
         rust_obj = "LDKu5"
         c_ty = "int8_t"
+        arr_ty = "uint8_t"
         fn_ty_arg = "B"
         fn_arg = fn_arg[6:].strip()
     elif fn_arg.startswith("uint16_t"):
         mapped_type = consts.c_type_map['uint16_t']
         java_ty = mapped_type[0]
         c_ty = "int16_t"
+        arr_ty = "uint16_t"
         fn_ty_arg = "S"
         fn_arg = fn_arg[8:].strip()
         is_primitive = True
@@ -267,6 +273,7 @@ def java_c_types(fn_arg, ret_arr_len):
         mapped_type = consts.c_type_map['uint32_t']
         java_ty = mapped_type[0]
         c_ty = "int32_t"
+        arr_ty = "uint32_t"
         fn_ty_arg = "I"
         fn_arg = fn_arg[8:].strip()
         is_primitive = True
@@ -277,20 +284,27 @@ def java_c_types(fn_arg, ret_arr_len):
         fn_ty_arg = "J"
         if fn_arg.startswith("uint64_t"):
             c_ty = "int64_t"
+            arr_ty = "uint64_t"
             fn_arg = fn_arg[8:].strip()
         else:
-            c_ty = "int64_t"
+            java_ty = consts.ptr_native_ty
+            c_ty = "intptr_t"
+            arr_ty = "uintptr_t"
             rust_obj = "uintptr_t"
             fn_arg = fn_arg[9:].strip()
         is_primitive = True
     elif is_const and fn_arg.startswith("char *"):
-        java_ty = "String"
+        java_ty = consts.java_type_map["String"]
+        java_hu_ty = consts.java_hu_type_map["String"]
         c_ty = "const char*"
+        arr_ty = "LDKStr"
         fn_ty_arg = "Ljava/lang/String;"
         fn_arg = fn_arg[6:].strip()
     elif fn_arg.startswith("LDKStr"):
         rust_obj = "LDKStr"
-        java_ty = "String"
+        arr_ty = "LDKStr"
+        java_ty = consts.java_type_map["String"]
+        java_hu_ty = consts.java_hu_type_map["String"]
         c_ty = "jstring"
         fn_ty_arg = "Ljava/lang/String;"
         fn_arg = fn_arg[6:].strip()
@@ -298,6 +312,7 @@ def java_c_types(fn_arg, ret_arr_len):
         arr_len = "len"
     else:
         ma = var_ty_regex.match(fn_arg)
+        arr_ty = ma.group(1).strip()
         if ma.group(1).strip() in unitary_enums:
             assert ma.group(1).strip().startswith("LDK")
             java_ty = ma.group(1).strip()[3:]
@@ -332,29 +347,40 @@ def java_c_types(fn_arg, ret_arr_len):
         fn_ty_arg = "J"
 
     var_is_arr = var_is_arr_regex.match(fn_arg)
+    subty = None
     if var_is_arr is not None or ret_arr_len is not None:
         assert(not take_by_ptr)
         assert(not is_ptr)
         # is there a special case for plurals?
-        if len(mapped_type) == 2:
+        if len(mapped_type) == 3:
             java_ty = mapped_type[1]
+            java_hu_ty = mapped_type[2]
         else:
             java_ty = java_ty + "[]"
+            java_hu_ty = java_ty
         c_ty = c_ty + "Array"
+
+        subty = java_c_types(arr_ty, None)
+        if subty is None:
+            assert java_c_types_none_allowed
+            return None
+        if is_ptr:
+            subty.pass_by_ref = True
+
         if var_is_arr is not None:
             if var_is_arr.group(1) == "":
-                return TypeInfo(rust_obj=rust_obj, java_ty=java_ty, java_hu_ty=java_ty, java_fn_ty_arg="[" + fn_ty_arg, c_ty=c_ty, is_const=is_const,
-                    passed_as_ptr=False, is_ptr=False, nonnull_ptr=nonnull_ptr, var_name="arg",
+                return TypeInfo(rust_obj=rust_obj, java_ty=java_ty, java_hu_ty=java_hu_ty, java_fn_ty_arg="[" + fn_ty_arg, c_ty=c_ty, is_const=is_const,
+                    passed_as_ptr=False, is_ptr=False, nonnull_ptr=nonnull_ptr, var_name="arg", subty=subty,
                     arr_len=var_is_arr.group(2), arr_access=arr_access, is_native_primitive=False, contains_trait=contains_trait)
-            return TypeInfo(rust_obj=rust_obj, java_ty=java_ty, java_hu_ty=java_ty, java_fn_ty_arg="[" + fn_ty_arg, c_ty=c_ty, is_const=is_const,
-                passed_as_ptr=False, is_ptr=False, nonnull_ptr=nonnull_ptr, var_name=var_is_arr.group(1),
+            return TypeInfo(rust_obj=rust_obj, java_ty=java_ty, java_hu_ty=java_hu_ty, java_fn_ty_arg="[" + fn_ty_arg, c_ty=c_ty, is_const=is_const,
+                passed_as_ptr=False, is_ptr=False, nonnull_ptr=nonnull_ptr, var_name=var_is_arr.group(1), subty=subty,
                 arr_len=var_is_arr.group(2), arr_access=arr_access, is_native_primitive=False, contains_trait=contains_trait)
 
     if java_hu_ty is None:
         java_hu_ty = java_ty
     return TypeInfo(rust_obj=rust_obj, java_ty=java_ty, java_hu_ty=java_hu_ty, java_fn_ty_arg=fn_ty_arg, c_ty=c_ty, passed_as_ptr=is_ptr or take_by_ptr,
         is_const=is_const, is_ptr=is_ptr, nonnull_ptr=nonnull_ptr, var_name=fn_arg, arr_len=arr_len, arr_access=arr_access, is_native_primitive=is_primitive,
-        contains_trait=contains_trait)
+        contains_trait=contains_trait, subty=subty)
 
 fn_ptr_regex = re.compile("^extern const ([A-Za-z_0-9\* ]*) \(\*(.*)\)\((.*)\);$")
 fn_ret_arr_regex = re.compile("(.*) \(\*(.*)\((.*)\)\)\[([0-9]*)\];$")
@@ -430,6 +456,15 @@ with open(sys.argv[1]) as in_h, open(f"{sys.argv[2]}/bindings{consts.file_ext}",
         else:
             return_type_info = type_mapping_generator.map_type(method_return_type.strip() + " ret", True, ret_arr_len, False, force_holds_ref)
 
+        if method_name.endswith("_clone") and expected_struct not in unitary_enums:
+            meth_line = "uintptr_t " + expected_struct.replace("LDK", "") + "_clone_ptr(" + expected_struct + " *NONNULL_PTR arg)"
+            write_c("static inline " + meth_line + " {\n")
+            write_c("\t" + return_type_info.ret_conv[0].replace("\n", "\n\t"))
+            write_c(method_name + "(arg)")
+            write_c(return_type_info.ret_conv[1])
+            write_c("\n\treturn " + return_type_info.ret_conv_name + ";\n}\n")
+            map_fn(meth_line + ";\n", re.compile("(uintptr_t) ([A-Za-z_0-9]*)\((.*)\)").match(meth_line), None, None, None)
+
         argument_types = []
         default_constructor_args = {}
         takes_self = False
@@ -479,12 +514,34 @@ with open(sys.argv[1]) as in_h, open(f"{sys.argv[2]}/bindings{consts.file_ext}",
                             default_constructor_args[argument_conversion_info.arg_name] = []
                         default_constructor_args[argument_conversion_info.arg_name].append(explode_arg_conv)
             argument_types.append(argument_conversion_info)
+
         if not takes_self and return_type_info.java_hu_ty != struct_meth:
             if not return_type_info.java_hu_ty.startswith("Result_" + struct_meth):
                 struct_meth_name = method_name
                 struct_meth = ""
                 expected_struct = ""
 
+        impl_on_struct = (expected_struct in opaque_structs or expected_struct in trait_structs or
+            expected_struct in complex_enums or expected_struct in complex_enums or
+            expected_struct in result_types or expected_struct in tuple_types) and not is_free
+        impl_on_utils = not impl_on_struct and (not is_free and not method_name.endswith("_clone") and
+            not method_name.startswith("TxOut") and
+            not method_name.startswith("_") and
+            method_name != "check_platform" and method_name != "Result_read" and
+            not expected_struct in unitary_enums and
+            ((not method_name.startswith("C2Tuple_") and not method_name.startswith("C3Tuple_"))
+              or method_name.endswith("_read")))
+
+        # If we're adding a static method, and it returns a primitive or an array of primitives,
+        # and a variable conversion adds a reference on the return type (via `this`), skip the
+        # variable's conversion reference-add (as we obviously cannot need a reference).
+        if impl_on_utils and (return_type_info.is_native_primitive or
+                (return_type_info.ty_info.subty is not None and return_type_info.ty_info.subty.is_native_primitive)):
+            for arg in argument_types:
+                if arg.from_hu_conv is not None and arg.from_hu_conv[1] != "":
+                    if "this" in arg.from_hu_conv[1]:
+                        arg.from_hu_conv = (arg.from_hu_conv[0], "")
+
         out_java.write("\t// " + line)
         (out_java_delta, out_c_delta, out_java_struct_delta) = \
             consts.map_function(argument_types, c_call_string, method_name, struct_meth_name, return_type_info, struct_meth, default_constructor_args, takes_self, takes_self_ptr, args_known, type_mapping_generator, doc_comment)
@@ -513,24 +570,13 @@ with open(sys.argv[1]) as in_h, open(f"{sys.argv[2]}/bindings{consts.file_ext}",
             write_c(out_c_delta)
 
         out_java_struct = None
-        if (expected_struct in opaque_structs or expected_struct in trait_structs
-                or expected_struct in complex_enums or expected_struct in complex_enums
-                or expected_struct in result_types or expected_struct in tuple_types) and not is_free:
+        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 (not is_free and not method_name.endswith("_clone") and
-                not method_name.startswith("TxOut") and
-                not method_name.startswith("_") and
-                method_name != "check_platform" and method_name != "Result_read" and
-                not expected_struct in unitary_enums and
-                ((not method_name.startswith("C2Tuple_") and not method_name.startswith("C3Tuple_"))
-                  or method_name.endswith("_read"))):
+        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():
-                if not line.strip().startswith("this."):
-                    out_java_struct.write(line + "\n")
-                else:
-                    out_java_struct.write("\t\t// " + line.strip() + "\n")
+                out_java_struct.write(line + "\n")
 
     def map_unitary_enum(struct_name, field_lines, enum_doc_comment):
         assert struct_name.startswith("LDK")
@@ -668,83 +714,43 @@ with open(sys.argv[1]) as in_h, open(f"{sys.argv[2]}/bindings{consts.file_ext}",
     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(consts.hu_struct_file_prefix)
-            out_java_struct.write("public class " + human_ty + " extends CommonBase {\n")
-            out_java_struct.write("\tprivate " + human_ty + "(Object _dummy, long ptr) { super(ptr); }\n")
-            out_java_struct.write("\tprotected void finalize() throws Throwable {\n")
-            out_java_struct.write("\t\tif (ptr != 0) { bindings." + struct_name.replace("LDK","") + "_free(ptr); } super.finalize();\n")
-            out_java_struct.write("\t}\n\n")
-            out_java_struct.write("\tstatic " + human_ty + " constr_from_ptr(long ptr) {\n")
-            out_java_struct.write("\t\tif (bindings." + struct_name.replace("LDK", "") + "_is_ok(ptr)) {\n")
-            out_java_struct.write("\t\t\treturn new " + human_ty + "_OK(null, ptr);\n")
-            out_java_struct.write("\t\t} else {\n")
-            out_java_struct.write("\t\t\treturn new " + human_ty + "_Err(null, ptr);\n")
-            out_java_struct.write("\t\t}\n")
-            out_java_struct.write("\t}\n")
-
-            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)
-            can_clone = True
-            if not res_map.is_native_primitive and (res_map.rust_obj.replace("LDK", "") + "_clone" not in clone_fns):
-                can_clone = False
-            if not err_map.is_native_primitive and (err_map.rust_obj.replace("LDK", "") + "_clone" not in clone_fns):
-                can_clone = False
-
-            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 & ~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:
-                write_c(res_map.ret_conv[0].replace("\n", "\n\t") + "(*val->contents.result)")
-                write_c(res_map.ret_conv[1].replace("\n", "\n\t") + "\n\treturn " + res_map.ret_conv_name)
-            else:
-                write_c("return *val->contents.result")
-            write_c(";\n}\n")
-
-            if res_map.java_hu_ty != "void":
-                out_java_struct.write("\t\tpublic final " + res_map.java_hu_ty + " res;\n")
-            out_java_struct.write("\t\tprivate " + human_ty + "_OK(Object _dummy, long ptr) {\n")
-            out_java_struct.write("\t\t\tsuper(_dummy, ptr);\n")
-            if res_map.java_hu_ty == "void":
-                pass
-            elif res_map.to_hu_conv is not None:
-                out_java_struct.write("\t\t\t" + res_map.java_ty + " res = bindings." + struct_name + "_get_ok(ptr);\n")
-                out_java_struct.write("\t\t\t" + res_map.to_hu_conv.replace("\n", "\n\t\t\t"))
-                out_java_struct.write("\n\t\t\tthis.res = " + res_map.to_hu_conv_name + ";\n")
-            else:
-                out_java_struct.write("\t\t\tthis.res = bindings." + struct_name + "_get_ok(ptr);\n")
-            out_java_struct.write("\t\t}\n")
-            out_java_struct.write("\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 & ~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:
-                write_c(err_map.ret_conv[0].replace("\n", "\n\t") + "(*val->contents.err)")
-                write_c(err_map.ret_conv[1].replace("\n", "\n\t") + "\n\treturn " + err_map.ret_conv_name)
-            else:
-                write_c("return *val->contents.err")
-            write_c(";\n}\n")
-
-            if err_map.java_hu_ty != "void":
-                out_java_struct.write("\t\tpublic final " + err_map.java_hu_ty + " err;\n")
-            out_java_struct.write("\t\tprivate " + human_ty + "_Err(Object _dummy, long ptr) {\n")
-            out_java_struct.write("\t\t\tsuper(_dummy, ptr);\n")
-            if err_map.java_hu_ty == "void":
-                pass
-            elif err_map.to_hu_conv is not None:
-                out_java_struct.write("\t\t\t" + err_map.java_ty + " err = bindings." + struct_name + "_get_err(ptr);\n")
-                out_java_struct.write("\t\t\t" + err_map.to_hu_conv.replace("\n", "\n\t\t\t"))
-                out_java_struct.write("\n\t\t\tthis.err = " + err_map.to_hu_conv_name + ";\n")
-            else:
-                out_java_struct.write("\t\t\tthis.err = bindings." + struct_name + "_get_err(ptr);\n")
-            out_java_struct.write("\t\t}\n")
-
-            out_java_struct.write("\t}\n\n")
+            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
+        else:
+            fn_defn = ptr_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
+        write_c("}\n")
+        dummy_line = fn_defn + ";\n"
+        map_fn_with_ref_option(dummy_line, reg_fn_regex.match(dummy_line), None, None, "", holds_ref)
 
     def map_tuple(struct_name, field_lines):
         human_ty = struct_name.replace("LDKC2Tuple", "TwoTuple").replace("LDKC3Tuple", "ThreeTuple")
@@ -761,27 +767,7 @@ with open(sys.argv[1]) as in_h, open(f"{sys.argv[2]}/bindings{consts.file_ext}",
             if idx != 0 and idx < len(field_lines) - 2:
                 field_name = chr(ord('a') + idx - 1)
                 assert line.endswith(" " + field_name + ";")
-                field_ty = java_c_types(line[:-1], None)
-                ptr_fn_defn = line[:-3].strip() + " *" + struct_name.replace("LDK", "") + "_get_" + field_name + "(" + struct_name + " *NONNULL_PTR tuple)"
-                owned_fn_defn = line[:-3].strip() + " " + struct_name.replace("LDK", "") + "_get_" + field_name + "(" + struct_name + " *NONNULL_PTR tuple)"
-
-                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")
-                    write_c("\treturn " + field_ty.rust_obj.replace("LDK", "") + "_clone(&tuple->" + field_name + ");\n")
-                elif field_ty.arr_len is not None or field_ty.is_native_primitive:
-                    fn_defn = owned_fn_defn
-                    write_c("static inline " + fn_defn + "{\n")
-                    write_c("\treturn tuple->" + field_name + ";\n")
-                else:
-                    fn_defn = ptr_fn_defn
-                    write_c("static inline " + fn_defn + "{\n")
-                    write_c("\treturn &tuple->" + field_name + ";\n")
-                    holds_ref = True
-                write_c("}\n")
-                dummy_line = fn_defn + ";\n"
-                map_fn_with_ref_option(dummy_line, reg_fn_regex.match(dummy_line), None, None, "", holds_ref)
+                create_getter(struct_name, line[:-3].strip(), field_name, ("", "->" + field_name), None)
 
     out_java.write(consts.bindings_header)
     with open(f"{sys.argv[2]}/version{consts.file_ext}", "w") as out_java_version:
@@ -846,7 +832,7 @@ with open(sys.argv[1]) as in_h, open(f"{sys.argv[2]}/bindings{consts.file_ext}",
                             last_struct_block_comment = block_comment.strip("\n")
                             block_comment = None
                         else:
-                            block_comment = block_comment + "\n" + struct_line.strip(" /*")
+                            block_comment = block_comment + "\n" + struct_line.strip(" /*").replace("…", "...")
                     else:
                         struct_name_match = struct_name_regex.match(struct_line)
                         if struct_name_match is not None:
@@ -911,33 +897,6 @@ with open(sys.argv[1]) as in_h, open(f"{sys.argv[2]}/bindings{consts.file_ext}",
                     map_tuple(struct_name, field_lines)
                 elif vec_ty is not None:
                     ty_info = type_mapping_generator.map_type(vec_ty + " arr_elem", False, None, False, False)
-                    if len(ty_info.java_fn_ty_arg) == 1: # ie we're a primitive of some form
-                        out_java.write("\tpublic static native long " + struct_name + "_new(" + ty_info.java_ty + "[] elems);\n")
-                        write_c(consts.c_fn_ty_pfx + consts.ptr_c_ty + " " + consts.c_fn_name_define_pfx(struct_name + "_new", True) + ty_info.c_ty + "Array elems) {\n")
-                        write_c("\t" + struct_name + " *ret = MALLOC(sizeof(" + struct_name + "), \"" + struct_name + "\");\n")
-                        write_c("\tret->datalen = " + consts.get_native_arr_len_call[0] + "elems" + consts.get_native_arr_len_call[1] + ";\n")
-                        write_c("\tif (ret->datalen == 0) {\n")
-                        write_c("\t\tret->data = NULL;\n")
-                        write_c("\t} else {\n")
-                        write_c("\t\tret->data = MALLOC(sizeof(" + vec_ty + ") * ret->datalen, \"" + struct_name + " Data\");\n")
-                        native_arr_ptr_call = consts.get_native_arr_ptr_call(ty_info.ty_info)
-                        write_c("\t\t" + ty_info.c_ty + " *java_elems = " + native_arr_ptr_call[0] + "elems" + native_arr_ptr_call[1] + ";\n")
-                        write_c("\t\tfor (size_t i = 0; i < ret->datalen; i++) {\n")
-                        if ty_info.arg_conv is not None:
-                            write_c("\t\t\t" + ty_info.c_ty + " arr_elem = java_elems[i];\n")
-                            write_c("\t\t\t" + ty_info.arg_conv.replace("\n", "\n\t\t\t") + "\n")
-                            write_c("\t\t\tret->data[i] = " + ty_info.arg_conv_name + ";\n")
-                            assert ty_info.arg_conv_cleanup is None
-                        else:
-                            write_c("\t\t\tret->data[i] = java_elems[i];\n")
-                        write_c("\t\t}\n")
-                        cleanup = consts.release_native_arr_ptr_call(ty_info.ty_info, "elems", "java_elems")
-                        if cleanup is not None:
-                            write_c("\t\t" + cleanup + ";\n")
-                        write_c("\t}\n")
-                        write_c("\treturn (uint64_t)ret;\n")
-                        write_c("}\n")
-
                     if ty_info.is_native_primitive:
                         clone_fns.add(struct_name.replace("LDK", "") + "_clone")
                         write_c("static inline " + struct_name + " " + struct_name.replace("LDK", "") + "_clone(const " + struct_name + " *orig) {\n")
@@ -990,30 +949,7 @@ with open(sys.argv[1]) as in_h, open(f"{sys.argv[2]}/bindings{consts.file_ext}",
                 elif struct_name == "LDKTxOut":
                     with open(f"{sys.argv[3]}/structs/TxOut{consts.file_ext}", "w") as out_java_struct:
                         out_java_struct.write(consts.hu_struct_file_prefix)
-                        out_java_struct.write("public class TxOut extends CommonBase{\n")
-                        out_java_struct.write("\t/** The script_pubkey in this output */\n")
-                        out_java_struct.write("\tpublic final byte[] script_pubkey;\n")
-                        out_java_struct.write("\t/** The value, in satoshis, of this output */\n")
-                        out_java_struct.write("\tpublic final long value;\n")
-                        out_java_struct.write("\n")
-                        out_java_struct.write("\tTxOut(java.lang.Object _dummy, long ptr) {\n")
-                        out_java_struct.write("\t\tsuper(ptr);\n")
-                        out_java_struct.write("\t\tthis.script_pubkey = bindings.TxOut_get_script_pubkey(ptr);\n")
-                        out_java_struct.write("\t\tthis.value = bindings.TxOut_get_value(ptr);\n")
-                        out_java_struct.write("\t}\n")
-                        out_java_struct.write("\tpublic TxOut(long value, byte[] script_pubkey) {\n")
-                        out_java_struct.write("\t\tsuper(bindings.TxOut_new(script_pubkey, value));\n")
-                        out_java_struct.write("\t\tthis.script_pubkey = bindings.TxOut_get_script_pubkey(ptr);\n")
-                        out_java_struct.write("\t\tthis.value = bindings.TxOut_get_value(ptr);\n")
-                        out_java_struct.write("\t}\n")
-                        out_java_struct.write("\n")
-                        out_java_struct.write("\t@Override @SuppressWarnings(\"deprecation\")\n")
-                        out_java_struct.write("\tprotected void finalize() throws Throwable {\n")
-                        out_java_struct.write("\t\tsuper.finalize();\n")
-                        out_java_struct.write("\t\tif (ptr != 0) { bindings.TxOut_free(ptr); }\n")
-                        out_java_struct.write("\t}\n")
-                        out_java_struct.write("\n")
-                        out_java_struct.write("}")
+                        out_java_struct.write(consts.txout_defn)
                         fn_line = "struct LDKCVec_u8Z TxOut_get_script_pubkey (struct LDKTxOut* thing)"
                         write_c(fn_line + " {")
                         write_c("\treturn CVec_u8Z_clone(&thing->script_pubkey);")
@@ -1085,3 +1021,4 @@ with open(f"{sys.argv[4]}/version.c", "w") as out_c:
     out_c.write(consts.c_version_file.replace('<git_version_ldk_garbagecollected>', local_git_version))
 with open(f"{sys.argv[3]}/structs/UtilMethods{consts.file_ext}", "a") as util:
     util.write(consts.util_fn_sfx)
+consts.cleanup()