_ Git - ldk-java/blob - genbindings.py

   1 #!/usr/bin/env python3
   2 import os, sys, re, subprocess
   3
   4 if len(sys.argv) < 7:
   5     print("USAGE: /path/to/lightning.h /path/to/bindings/output /path/to/bindings/ /path/to/bindings/output.c debug lang")
   6     sys.exit(1)
   7
   8 if sys.argv[5] == "false":
   9     DEBUG = False
  10 elif sys.argv[5] == "true":
  11     DEBUG = True
  12 else:
  13     print("debug should be true or false and indicates whether to track allocations and ensure we don't leak")
  14     sys.exit(1)
  15
  16 target = None
  17 if sys.argv[6] == "java" or sys.argv[6] == "android":
  18     import java_strings
  19     from java_strings import Consts
  20     target = java_strings.Target.JAVA
  21     if sys.argv[6] == "android":
  22         target = java_strings.Target.ANDROID
  23 elif sys.argv[6] == "typescript":
  24     import typescript_strings
  25     from typescript_strings import Consts
  26     target = typescript_strings.Target.NODEJS
  27     if len(sys.argv) == 8 and sys.argv[7] == 'browser':
  28         target = typescript_strings.Target.BROWSER
  29 elif sys.argv[6] == "c_sharp":
  30     import csharp_strings
  31     from csharp_strings import Consts
  32     target = csharp_strings.Target.CSHARP
  33 else:
  34     print("Only java, typescript, or c_sharp can be set for lang")
  35     sys.exit(1)
  36
  37
  38 consts = Consts(DEBUG, target=target, outdir=sys.argv[4])
  39
  40 local_git_version = os.getenv("LDK_GARBAGECOLLECTED_GIT_OVERRIDE")
  41 if local_git_version is None:
  42     local_git_version = subprocess.check_output(["git", "describe", '--tag', '--dirty']).decode("utf-8").strip()
  43
  44 from bindingstypes import *
  45
  46 c_file = ""
  47 def write_c(s):
  48     global c_file
  49     c_file += s
  50
  51 def camel_to_snake(s):
  52     # Convert camel case to snake case, in a way that appears to match cbindgen
  53     con = "_"
  54     ret = ""
  55     lastchar = ""
  56     lastund = False
  57     for char in s:
  58         if lastchar.isupper():
  59             if not char.isupper() and not lastund:
  60                 ret = ret + "_"
  61                 lastund = True
  62             else:
  63                 lastund = False
  64             ret = ret + lastchar.lower()
  65         else:
  66             ret = ret + lastchar
  67             if char.isupper() and not lastund:
  68                 ret = ret + "_"
  69                 lastund = True
  70             else:
  71                 lastund = False
  72         lastchar = char
  73         if char.isnumeric():
  74             lastund = True
  75     return (ret + lastchar.lower()).strip("_")
  76
  77 def doc_to_field_nullable(doc):
  78     if doc is None:
  79         return False
  80     for line in doc.splitlines():
  81         if "Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None" in line:
  82             return True
  83     return False
  84
  85 def doc_to_params_ret_nullable(doc):
  86     if doc is None:
  87         return (set(), False)
  88     params = set()
  89     ret_null = False
  90     for line in doc.splitlines():
  91         if "may be NULL or all-0s to represent None" not in line:
  92             continue
  93         if "Note that the return value" in line:
  94             ret_null = True
  95         elif "Note that " in line:
  96             param = line.split("Note that ")[1].split(" ")[0]
  97             params.add(param)
  98     return (params, ret_null)
  99
 100 unitary_enums = set()
 101 # Map from enum name to "contains trait object"
 102 complex_enums = {}
 103 opaque_structs = set()
 104 trait_structs = {}
 105 result_types = set()
 106 tuple_types = {}
 107
 108 var_is_arr_regex = re.compile("\(\* ?([A-za-z0-9_]*)\)\[([a-z0-9]*)\]")
 109 var_ty_regex = re.compile("([A-za-z_0-9]*)(.*)")
 110 java_c_types_none_allowed = True # Unset when we do the real pass that populates the above sets
 111 def java_c_types(fn_arg, ret_arr_len):
 112     fn_arg = fn_arg.strip()
 113     if fn_arg.startswith("MUST_USE_RES "):
 114         fn_arg = fn_arg[13:]
 115     is_const = False
 116     if fn_arg.startswith("const "):
 117         fn_arg = fn_arg[6:]
 118         is_const = True
 119     if fn_arg.startswith("struct "):
 120         fn_arg = fn_arg[7:]
 121     if fn_arg.startswith("enum "):
 122         fn_arg = fn_arg[5:]
 123     nonnull_ptr = "NONNULL_PTR" in fn_arg
 124     fn_arg = fn_arg.replace("NONNULL_PTR", "")
 125
 126     is_ptr = False
 127     take_by_ptr = False
 128     rust_obj = None
 129     arr_access = None
 130     java_hu_ty = None
 131     if fn_arg.startswith("LDKPaymentPreimage") or fn_arg.startswith("LDKPaymentSecret") or fn_arg.startswith("LDKPaymentHash"):
 132         if fn_arg.startswith("LDKPaymentPreimage"):
 133             fn_arg = "uint8_t (*" + fn_arg[19:] + ")[32]"
 134         elif fn_arg.startswith("LDKPaymentSecret"):
 135             fn_arg = "uint8_t (*" + fn_arg[17:] + ")[32]"
 136         elif fn_arg.startswith("LDKPaymentHash"):
 137             fn_arg = "uint8_t (*" + fn_arg[15:] + ")[32]"
 138         assert var_is_arr_regex.match(fn_arg[8:])
 139         rust_obj = "LDKThirtyTwoBytes"
 140         arr_access = "data"
 141     elif fn_arg.startswith("LDKThirtyTwoBytes"):
 142         fn_arg = "uint8_t (*" + fn_arg[18:] + ")[32]"
 143         assert var_is_arr_regex.match(fn_arg[8:])
 144         rust_obj = "LDKThirtyTwoBytes"
 145         arr_access = "data"
 146     elif fn_arg.startswith("LDKEightU16s"):
 147         fn_arg = "uint16_t (*" + fn_arg[13:] + ")[8]"
 148         assert var_is_arr_regex.match(fn_arg[9:])
 149         rust_obj = "LDKEightU16s"
 150         arr_access = "data"
 151     elif fn_arg.startswith("LDKU128"):
 152         if fn_arg == "LDKU128":
 153             fn_arg = "LDKU128 arg"
 154         if fn_arg.startswith("LDKU128*") or fn_arg.startswith("LDKU128 *"):
 155             fn_arg = "uint8_t (" + fn_arg[8:] + ")[16]"
 156         else:
 157             fn_arg = "uint8_t (*" + fn_arg[8:] + ")[16]"
 158         assert var_is_arr_regex.match(fn_arg[8:])
 159         rust_obj = "LDKU128"
 160         arr_access = "le_bytes"
 161     elif fn_arg.startswith("LDKTxid"):
 162         fn_arg = "uint8_t (*" + fn_arg[8:] + ")[32]"
 163         assert var_is_arr_regex.match(fn_arg[8:])
 164         rust_obj = "LDKThirtyTwoBytes"
 165         arr_access = "data"
 166     elif fn_arg.startswith("LDKPublicKey"):
 167         fn_arg = "uint8_t (*" + fn_arg[13:] + ")[33]"
 168         assert var_is_arr_regex.match(fn_arg[8:])
 169         rust_obj = "LDKPublicKey"
 170         arr_access = "compressed_form"
 171     elif fn_arg.startswith("LDKSecretKey"):
 172         fn_arg = "uint8_t (*" + fn_arg[13:] + ")[32]"
 173         assert var_is_arr_regex.match(fn_arg[8:])
 174         rust_obj = "LDKSecretKey"
 175         arr_access = "bytes"
 176     elif fn_arg.startswith("LDKSignature"):
 177         fn_arg = "uint8_t (*" + fn_arg[13:] + ")[64]"
 178         assert var_is_arr_regex.match(fn_arg[8:])
 179         rust_obj = "LDKSignature"
 180         arr_access = "compact_form"
 181     elif fn_arg.startswith("LDKRecoverableSignature"):
 182         fn_arg = "uint8_t (*" + fn_arg[24:] + ")[68]"
 183         assert var_is_arr_regex.match(fn_arg[8:])
 184         rust_obj = "LDKRecoverableSignature"
 185         arr_access = "serialized_form"
 186     elif fn_arg.startswith("LDKThreeBytes"):
 187         fn_arg = "uint8_t (*" + fn_arg[14:] + ")[3]"
 188         assert var_is_arr_regex.match(fn_arg[8:])
 189         rust_obj = "LDKThreeBytes"
 190         arr_access = "data"
 191     elif fn_arg.startswith("LDKFourBytes"):
 192         fn_arg = "uint8_t (*" + fn_arg[13:] + ")[4]"
 193         assert var_is_arr_regex.match(fn_arg[8:])
 194         rust_obj = "LDKFourBytes"
 195         arr_access = "data"
 196     elif fn_arg.startswith("LDKSixteenBytes"):
 197         fn_arg = "uint8_t (*" + fn_arg[16:] + ")[16]"
 198         assert var_is_arr_regex.match(fn_arg[8:])
 199         rust_obj = "LDKSixteenBytes"
 200         arr_access = "data"
 201     elif fn_arg.startswith("LDKTwentyBytes"):
 202         fn_arg = "uint8_t (*" + fn_arg[15:] + ")[20]"
 203         assert var_is_arr_regex.match(fn_arg[8:])
 204         rust_obj = "LDKTwentyBytes"
 205         arr_access = "data"
 206     elif fn_arg.startswith("LDKTwelveBytes"):
 207         fn_arg = "uint8_t (*" + fn_arg[15:] + ")[12]"
 208         assert var_is_arr_regex.match(fn_arg[8:])
 209         rust_obj = "LDKTwelveBytes"
 210         arr_access = "data"
 211     elif fn_arg.startswith("LDKu8slice"):
 212         fn_arg = "uint8_t (*" + fn_arg[11:] + ")[datalen]"
 213         assert var_is_arr_regex.match(fn_arg[8:])
 214         rust_obj = "LDKu8slice"
 215         arr_access = "data"
 216     elif fn_arg.startswith("LDKCVec_u8Z"):
 217         fn_arg = "uint8_t (*" + fn_arg[12:] + ")[datalen]"
 218         rust_obj = "LDKCVec_u8Z"
 219         assert var_is_arr_regex.match(fn_arg[8:])
 220         arr_access = "data"
 221     elif fn_arg.startswith("LDKTransaction ") or fn_arg == "LDKTransaction":
 222         fn_arg = "uint8_t (*" + fn_arg[15:] + ")[datalen]"
 223         rust_obj = "LDKTransaction"
 224         assert var_is_arr_regex.match(fn_arg[8:])
 225         arr_access = "data"
 226     elif fn_arg.startswith("LDKWitness ") or fn_arg == "LDKWitness":
 227         fn_arg = "uint8_t (*" + fn_arg[11:] + ")[datalen]"
 228         rust_obj = "LDKWitness"
 229         assert var_is_arr_regex.match(fn_arg[8:])
 230         arr_access = "data"
 231     elif fn_arg.startswith("LDKCVec_"):
 232         is_ptr = False
 233         if "*" in fn_arg:
 234             fn_arg = fn_arg.replace("*", "")
 235             is_ptr = True
 236
 237         tyn = fn_arg[8:].split(" ")
 238         assert tyn[0].endswith("Z")
 239         if tyn[0] == "u64Z":
 240             new_arg = "uint64_t"
 241         else:
 242             new_arg = "LDK" + tyn[0][:-1]
 243         for a in tyn[1:]:
 244             new_arg = new_arg + " " + a
 245         res = java_c_types(new_arg, ret_arr_len)
 246         if res is None:
 247             assert java_c_types_none_allowed
 248             return None
 249         if is_ptr:
 250             res.pass_by_ref = True
 251         java_ty = consts.java_arr_ty_str(res.java_ty)
 252         if res.is_native_primitive or res.passed_as_ptr:
 253             return TypeInfo(rust_obj=fn_arg.split(" ")[0], java_ty=java_ty, java_hu_ty=res.java_hu_ty + "[]",
 254                 java_fn_ty_arg="[" + res.java_fn_ty_arg, c_ty=res.c_ty + "Array", passed_as_ptr=False, is_ptr=is_ptr,
 255                 nonnull_ptr=nonnull_ptr, is_const=is_const,
 256                 var_name=res.var_name, arr_len="datalen", arr_access="data", subty=res, is_native_primitive=False)
 257         else:
 258             return TypeInfo(rust_obj=fn_arg.split(" ")[0], java_ty=java_ty, java_hu_ty=res.java_hu_ty + "[]",
 259                 java_fn_ty_arg="[" + res.java_fn_ty_arg, c_ty=consts.ptr_arr, passed_as_ptr=False, is_ptr=is_ptr,
 260                 nonnull_ptr=nonnull_ptr, is_const=is_const,
 261                 var_name=res.var_name, arr_len="datalen", arr_access="data", subty=res, is_native_primitive=False)
 262
 263     is_primitive = False
 264     contains_trait = False
 265     arr_len = None
 266     mapped_type = []
 267     java_type_plural = None
 268     arr_ty = None
 269     if fn_arg.startswith("void"):
 270         java_ty = "void"
 271         c_ty = "void"
 272         fn_ty_arg = "V"
 273         fn_arg = fn_arg[4:].strip()
 274         is_primitive = True
 275     elif fn_arg.startswith("bool"):
 276         java_ty = consts.c_type_map['bool'][0]
 277         c_ty = "jboolean"
 278         fn_ty_arg = "Z"
 279         arr_ty = "bool"
 280         fn_arg = fn_arg[4:].strip()
 281         is_primitive = True
 282     elif fn_arg.startswith("uint8_t"):
 283         mapped_type = consts.c_type_map['uint8_t']
 284         java_ty = mapped_type[0]
 285         c_ty = "int8_t"
 286         fn_ty_arg = "B"
 287         arr_ty = "uint8_t"
 288         fn_arg = fn_arg[7:].strip()
 289         is_primitive = True
 290     elif fn_arg.startswith("LDKU5") or fn_arg.startswith("LDKWitnessVersion"):
 291         java_ty = consts.c_type_map['uint8_t'][0]
 292         if fn_arg.startswith("LDKU5"):
 293             java_hu_ty = "UInt5"
 294             rust_obj = "LDKU5"
 295             fn_arg = fn_arg[6:].strip()
 296         else:
 297             java_hu_ty = "WitnessVersion"
 298             rust_obj = "LDKWitnessVersion"
 299             fn_arg = fn_arg[18:].strip()
 300         c_ty = "int8_t"
 301         arr_ty = "uint8_t"
 302         fn_ty_arg = "B"
 303     elif fn_arg.startswith("uint16_t"):
 304         mapped_type = consts.c_type_map['uint16_t']
 305         java_ty = mapped_type[0]
 306         c_ty = "int16_t"
 307         arr_ty = "uint16_t"
 308         fn_ty_arg = "S"
 309         fn_arg = fn_arg[8:].strip()
 310         is_primitive = True
 311     elif fn_arg.startswith("uint32_t"):
 312         mapped_type = consts.c_type_map['uint32_t']
 313         java_ty = mapped_type[0]
 314         c_ty = "int32_t"
 315         arr_ty = "uint32_t"
 316         fn_ty_arg = "I"
 317         fn_arg = fn_arg[8:].strip()
 318         is_primitive = True
 319     elif fn_arg.startswith("uint64_t") or fn_arg.startswith("uintptr_t"):
 320         # TODO: uintptr_t is arch-dependent :(
 321         mapped_type = consts.c_type_map['uint64_t']
 322         java_ty = mapped_type[0]
 323         fn_ty_arg = "J"
 324         if fn_arg.startswith("uint64_t"):
 325             c_ty = "int64_t"
 326             arr_ty = "uint64_t"
 327             fn_arg = fn_arg[8:].strip()
 328         else:
 329             java_ty = consts.usize_native_ty
 330             c_ty = consts.usize_c_ty
 331             arr_ty = "uintptr_t"
 332             rust_obj = "uintptr_t"
 333             fn_arg = fn_arg[9:].strip()
 334         is_primitive = True
 335     elif is_const and fn_arg.startswith("char *"):
 336         java_ty = consts.java_type_map["String"]
 337         java_hu_ty = consts.java_hu_type_map["String"]
 338         c_ty = "const char*"
 339         arr_ty = "LDKStr"
 340         fn_ty_arg = "Ljava/lang/String;"
 341         fn_arg = fn_arg[6:].strip()
 342     elif fn_arg.startswith("LDKStr"):
 343         rust_obj = "LDKStr"
 344         arr_ty = "LDKStr"
 345         java_ty = consts.java_type_map["String"]
 346         java_hu_ty = consts.java_hu_type_map["String"]
 347         c_ty = "jstring"
 348         fn_ty_arg = "Ljava/lang/String;"
 349         fn_arg = fn_arg[6:].strip()
 350         arr_access = "chars"
 351         arr_len = "len"
 352     elif fn_arg.startswith("LDKError ") or fn_arg == "LDKError":
 353         java_ty = consts.c_type_map['uint32_t'][0]
 354         java_hu_ty = "UnqualifiedError"
 355         rust_obj = "LDKError"
 356         c_ty = "int32_t"
 357         arr_ty = "uint32_t"
 358         fn_ty_arg = "I"
 359         fn_arg = fn_arg[8:].strip()
 360     else:
 361         ma = var_ty_regex.match(fn_arg)
 362         arr_ty = ma.group(1).strip()
 363         if ma.group(1).strip() in unitary_enums:
 364             assert ma.group(1).strip().startswith("LDK")
 365             java_ty = ma.group(1).strip()[3:]
 366             java_hu_ty = java_ty
 367             c_ty = consts.result_c_ty
 368             fn_ty_arg = "Lorg/ldk/enums/" + java_ty + ";"
 369             fn_arg = ma.group(2).strip()
 370             rust_obj = ma.group(1).strip()
 371         else:
 372             c_ty = consts.ptr_c_ty
 373             java_ty = consts.ptr_native_ty
 374             java_hu_ty = ma.group(1).strip()
 375             java_hu_ty = java_hu_ty.replace("LDKCOption", "Option")
 376             java_hu_ty = java_hu_ty.replace("LDKCResult", "Result")
 377             java_hu_ty = java_hu_ty.replace("LDKC2Tuple", "TwoTuple")
 378             java_hu_ty = java_hu_ty.replace("LDKC3Tuple", "ThreeTuple")
 379             java_hu_ty = java_hu_ty.replace("LDK", "")
 380             fn_ty_arg = "J"
 381             fn_arg = ma.group(2).strip()
 382             rust_obj = ma.group(1).strip()
 383             if rust_obj in trait_structs:
 384                 contains_trait = True
 385             elif rust_obj in complex_enums:
 386                 contains_trait = complex_enums[rust_obj]
 387             take_by_ptr = True
 388
 389     if fn_arg.startswith(" *") or fn_arg.startswith("*"):
 390         fn_arg = fn_arg.replace("*", "").strip()
 391         is_ptr = True
 392         c_ty = consts.ptr_c_ty
 393         java_ty = consts.ptr_native_ty
 394         fn_ty_arg = "J"
 395
 396     var_is_arr = var_is_arr_regex.match(fn_arg)
 397     subty = None
 398     if var_is_arr is not None or ret_arr_len is not None:
 399         assert(not take_by_ptr)
 400         assert(not is_ptr)
 401         # is there a special case for plurals?
 402         if len(mapped_type) == 3:
 403             java_ty = mapped_type[1]
 404             java_hu_ty = mapped_type[2]
 405         else:
 406             java_ty = java_ty + "[]"
 407             java_hu_ty = java_ty
 408         if rust_obj == "LDKU128":
 409             java_hu_ty = consts.u128_native_ty
 410         c_ty = c_ty + "Array"
 411
 412         subty = java_c_types(arr_ty, None)
 413         if subty is None:
 414             assert java_c_types_none_allowed
 415             return None
 416         if is_ptr:
 417             subty.pass_by_ref = True
 418
 419         if var_is_arr is not None:
 420             if var_is_arr.group(1) == "":
 421                 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,
 422                     passed_as_ptr=False, is_ptr=False, nonnull_ptr=nonnull_ptr, var_name="arg", subty=subty,
 423                     arr_len=var_is_arr.group(2), arr_access=arr_access, is_native_primitive=False, contains_trait=contains_trait)
 424             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,
 425                 passed_as_ptr=False, is_ptr=False, nonnull_ptr=nonnull_ptr, var_name=var_is_arr.group(1), subty=subty,
 426                 arr_len=var_is_arr.group(2), arr_access=arr_access, is_native_primitive=False, contains_trait=contains_trait)
 427
 428     if java_hu_ty is None:
 429         java_hu_ty = java_ty
 430     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,
 431         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,
 432         contains_trait=contains_trait, subty=subty)
 433
 434 fn_ptr_regex = re.compile("^extern const ([A-Za-z_0-9\* ]*) \(\*(.*)\)\((.*)\);$")
 435 fn_ret_arr_regex = re.compile("(.*) \(\*(.*)\((.*)\)\)\[([0-9]*)\];$")
 436 reg_fn_regex = re.compile("([A-Za-z_0-9\* ]* \*?)([a-zA-Z_0-9]*)\((.*)\);$")
 437 clone_fns = set()
 438 constructor_fns = {}
 439
 440 from gen_type_mapping import TypeMappingGenerator
 441 type_mapping_generator = TypeMappingGenerator(java_c_types, consts, opaque_structs, clone_fns, unitary_enums, trait_structs, complex_enums, result_types, tuple_types)
 442
 443 with open(sys.argv[1]) as in_h:
 444     for line in in_h:
 445         reg_fn = reg_fn_regex.match(line)
 446         if reg_fn is not None:
 447             if reg_fn.group(2).endswith("_clone"):
 448                 clone_fns.add(reg_fn.group(2))
 449             else:
 450                 rty = java_c_types(reg_fn.group(1), None)
 451                 if rty is not None and not rty.is_native_primitive and reg_fn.group(2) == rty.java_hu_ty + "_new":
 452                     constructor_fns[rty.rust_obj] = reg_fn.group(3)
 453             continue
 454         arr_fn = fn_ret_arr_regex.match(line)
 455         if arr_fn is not None:
 456             if arr_fn.group(2).endswith("_clone"):
 457                 clone_fns.add(arr_fn.group(2))
 458             # No object constructors return arrays, as then they wouldn't be an object constructor
 459             continue
 460
 461 # Define some manual clones...
 462 clone_fns.add("ThirtyTwoBytes_clone")
 463 write_c("static inline struct LDKThirtyTwoBytes ThirtyTwoBytes_clone(const struct LDKThirtyTwoBytes *orig) { struct LDKThirtyTwoBytes ret; memcpy(ret.data, orig->data, 32); return ret; }\n\n")
 464
 465
 466 write_c("static inline void* untag_ptr(uint64_t ptr) {\n")
 467 write_c("\tif (ptr < 4096) return (void*)ptr;\n")
 468 write_c("\tif (sizeof(void*) == 4) {\n")
 469 write_c("\t\t// For 32-bit systems, store pointers as 64-bit ints and use the 31st bit\n")
 470 write_c("\t\treturn (void*)(uintptr_t)ptr;\n")
 471 write_c("\t} else {\n")
 472 write_c("\t\t// For 64-bit systems, assume the top byte is used for tagging, then\n")
 473 write_c("\t\t// use bit 9 ^ bit 10.\n")
 474 write_c("\t\tuint64_t tenth_bit = (((uintptr_t)ptr) & (1ULL << 54)) >> 54;\n")
 475 write_c("\t\tuintptr_t p = (ptr & ~(1ULL << 55)) | (tenth_bit << 55);\n")
 476 write_c("#ifdef LDK_DEBUG_BUILD\n")
 477 write_c("\t\t// On debug builds we also use the 11th bit as a debug flag\n")
 478 write_c("\t\tuintptr_t eleventh_bit = (((uintptr_t)ptr) & (1ULL << 53)) >> 53;\n")
 479 write_c("\t\tCHECK(tenth_bit != eleventh_bit);\n")
 480 write_c("\t\tp ^= 1ULL << 53;\n")
 481 write_c("#endif\n")
 482 write_c("\t\treturn (void*)p;\n")
 483 write_c("\t}\n")
 484 write_c("}\n")
 485
 486 write_c("static inline bool ptr_is_owned(uint64_t ptr) {\n")
 487 write_c("\tif(ptr < 4096) return true;\n")
 488 write_c("\tif (sizeof(void*) == 4) {\n")
 489 write_c("\t\treturn ptr & (1ULL << 32);\n")
 490 write_c("\t} else {\n")
 491 write_c("\t\tuintptr_t ninth_bit = (((uintptr_t)ptr) & (1ULL << 55)) >> 55;\n")
 492 write_c("\t\tuintptr_t tenth_bit = (((uintptr_t)ptr) & (1ULL << 54)) >> 54;\n")
 493 write_c("#ifdef LDK_DEBUG_BUILD\n")
 494 write_c("\t\t// On debug builds we also use the 11th bit as a debug flag\n")
 495 write_c("\t\tuintptr_t eleventh_bit = (((uintptr_t)ptr) & (1ULL << 53)) >> 53;\n")
 496 write_c("\t\tCHECK(tenth_bit != eleventh_bit);\n")
 497 write_c("#endif\n")
 498 write_c("\t\treturn (ninth_bit ^ tenth_bit) ? true : false;\n")
 499 write_c("\t}\n")
 500 write_c("}\n")
 501
 502 write_c("static inline uint64_t tag_ptr(const void* ptr, bool is_owned) {\n")
 503 write_c("\tif ((uintptr_t)ptr < 4096) return (uint64_t)ptr;\n")
 504 write_c("\tif (sizeof(void*) == 4) {\n")
 505 write_c("\t\treturn (((uint64_t)ptr) | ((is_owned ? 1ULL : 0) << 32));\n")
 506 write_c("\t} else {\n")
 507 write_c("\t\tCHECK(sizeof(uintptr_t) == 8);\n")
 508 write_c("\t\tuintptr_t tenth_bit = (((uintptr_t)ptr) & (1ULL << 54)) >> 54;\n")
 509 write_c("\t\tuintptr_t t = (((uintptr_t)ptr) | (((is_owned ? 1ULL : 0ULL) ^ tenth_bit) << 55));\n")
 510 write_c("#ifdef LDK_DEBUG_BUILD\n")
 511 write_c("\t\tuintptr_t ninth_bit = (((uintptr_t)ptr) & (1ULL << 55)) >> 55;\n")
 512 write_c("\t\tuintptr_t eleventh_bit = (((uintptr_t)ptr) & (1ULL << 53)) >> 53;\n")
 513 write_c("\t\tCHECK(ninth_bit == tenth_bit);\n")
 514 write_c("\t\tCHECK(ninth_bit == eleventh_bit);\n")
 515 write_c("\t\tt ^= 1ULL << 53;\n")
 516 write_c("#endif\n")
 517 write_c("\t\tCHECK(ptr_is_owned(t) == is_owned);\n")
 518 write_c("\t\tCHECK(untag_ptr(t) == ptr);\n")
 519 #write_c("\t\tCHECK(untag_ptr((uintptr_t)untag_ptr(t)) == ptr);\n")
 520 write_c("\t\treturn t;\n")
 521 write_c("\t}\n")
 522 write_c("}\n\n")
 523
 524 java_c_types_none_allowed = False # C structs created by cbindgen are declared in dependency order
 525
 526 with open(f"{sys.argv[3]}/structs/UtilMethods{consts.file_ext}", "a") as util:
 527     util.write(consts.util_fn_pfx)
 528
 529 with open(sys.argv[1]) as in_h, open(f"{sys.argv[2]}/bindings{consts.file_ext}", "w") as out_java:
 530     # Map a top-level function
 531     def map_fn(line, re_match, ret_arr_len, c_call_string, doc_comment):
 532         map_fn_with_ref_option(line, re_match, ret_arr_len, c_call_string, doc_comment, False)
 533     def map_fn_with_ref_option(line, re_match, ret_arr_len, c_call_string, doc_comment, force_holds_ref):
 534         method_return_type = re_match.group(1)
 535         method_name = re_match.group(2)
 536         method_comma_separated_arguments = re_match.group(3)
 537         method_arguments = method_comma_separated_arguments.split(',')
 538
 539         if method_name.startswith("__"):
 540             return
 541
 542         is_free = method_name.endswith("_free")
 543         if method_name.startswith("COption") or method_name.startswith("CResult"):
 544             struct_meth = method_name.rsplit("Z", 1)[0][1:] + "Z"
 545             expected_struct = "LDKC" + struct_meth
 546             struct_meth_name = method_name[len(struct_meth) + 1:].strip("_")
 547         elif method_name.startswith("C2Tuple") or method_name.startswith("C3Tuple"):
 548             tuple_name = method_name.rsplit("Z", 1)[0][2:] + "Z"
 549             if method_name.startswith("C2Tuple"):
 550                 struct_meth = "Two" + tuple_name
 551                 expected_struct = "LDKC2" + tuple_name
 552             else:
 553                 struct_meth = "Three" + tuple_name
 554                 expected_struct = "LDKC3" + tuple_name
 555             struct_meth_name = method_name[len(tuple_name) + 2:].strip("_")
 556         else:
 557             struct_meth = method_name.split("_")[0]
 558             expected_struct = "LDK" + struct_meth
 559             struct_meth_name = method_name[len(struct_meth) + 1 if len(struct_meth) != 0 else 0:].strip("_")
 560
 561         (params_nullable, ret_nullable) = doc_to_params_ret_nullable(doc_comment)
 562         if ret_nullable:
 563             return_type_info = type_mapping_generator.map_nullable_type(method_return_type.strip() + " ret", True, ret_arr_len, False, force_holds_ref)
 564         else:
 565             return_type_info = type_mapping_generator.map_type(method_return_type.strip() + " ret", True, ret_arr_len, False, force_holds_ref)
 566
 567         if method_name.endswith("_clone") and expected_struct not in unitary_enums:
 568             meth_line = "uint64_t " + expected_struct.replace("LDK", "") + "_clone_ptr(" + expected_struct + " *NONNULL_PTR arg)"
 569             write_c("static inline " + meth_line + " {\n")
 570             write_c("\t" + return_type_info.ret_conv[0].replace("\n", "\n\t"))
 571             write_c(method_name + "(arg)")
 572             write_c(return_type_info.ret_conv[1].replace("\n", "\n\t"))
 573             write_c("\n\treturn " + return_type_info.ret_conv_name + ";\n}\n")
 574             map_fn(meth_line + ";\n", re.compile("(uint64_t) ([A-Za-z_0-9]*)\((.*)\)").match(meth_line), None, None, None)
 575
 576         argument_types = []
 577         default_constructor_args = {}
 578         takes_self = False
 579         takes_self_ptr = False
 580
 581         for argument_index, argument in enumerate(method_arguments):
 582             arg_ty = type_mapping_generator.java_c_types(argument, None)
 583             argument_conversion_info = None
 584             if argument_index == 0 and arg_ty.java_hu_ty == struct_meth:
 585                 argument_conversion_info = type_mapping_generator.map_type_with_info(arg_ty, False, None, is_free, True, False)
 586                 takes_self = True
 587                 if argument_conversion_info.ty_info.is_ptr:
 588                     takes_self_ptr = True
 589             elif arg_ty.var_name in params_nullable:
 590                 argument_conversion_info = type_mapping_generator.map_type_with_info(arg_ty, False, None, is_free, True, True)
 591                 if argument_conversion_info.arg_conv is not None and "WARNING" in argument_conversion_info.arg_conv:
 592                     arg_ty_info = java_c_types(argument, None)
 593                     print("WARNING: Remapping argument " + arg_ty_info.var_name + " of function " + method_name + " to a reference")
 594                     print("    The argument appears to require a move, or not clonable, and is nullable.")
 595                     print("    Normally for arguments that require a move and are not clonable, we split")
 596                     print("    the argument into the type's constructor's arguments and just use those to")
 597                     print("    construct a new object on the fly.")
 598                     print("    However, because the object is nullable, doing so would mean we can no")
 599                     print("    longer allow the user to pass null, as we now have an argument list instead.")
 600                     print("    Thus, we blindly assume its really an Option<&Type> instead of an Option<Type>.")
 601                     print("    It may or may not actually be a reference, but its the simplest mapping option")
 602                     print("    and also the only use of this code today.")
 603                     arg_ty_info.requires_clone = False
 604                     argument_conversion_info = type_mapping_generator.map_type_with_info(arg_ty_info, False, None, is_free, True, True)
 605                     assert argument_conversion_info.nullable
 606                     assert argument_conversion_info.arg_conv is not None and "WARNING" not in argument_conversion_info.arg_conv
 607             else:
 608                 argument_conversion_info = type_mapping_generator.map_type_with_info(arg_ty, False, None, is_free, True, False)
 609
 610             if argument_conversion_info.arg_conv is not None and "WARNING" in argument_conversion_info.arg_conv:
 611                 if argument_conversion_info.rust_obj in constructor_fns:
 612                     assert not is_free
 613                     for explode_idx, explode_arg in enumerate(constructor_fns[argument_conversion_info.rust_obj].split(',')):
 614                         explode_arg_conv = type_mapping_generator.map_type(explode_arg, False, None, False, True)
 615                         if explode_idx == 0 and explode_arg_conv.c_ty == "void":
 616                             continue # (void) is C lingo for "no arguments)
 617                         if explode_arg_conv.c_ty == "void":
 618                             assert False
 619                         if not argument_conversion_info.arg_name in default_constructor_args:
 620                             default_constructor_args[argument_conversion_info.arg_name] = []
 621                         default_constructor_args[argument_conversion_info.arg_name].append(explode_arg_conv)
 622             argument_types.append(argument_conversion_info)
 623
 624         if not takes_self and return_type_info.java_hu_ty != struct_meth:
 625             if not return_type_info.java_hu_ty.startswith("Result_" + struct_meth):
 626                 struct_meth_name = method_name
 627                 struct_meth = ""
 628                 expected_struct = ""
 629
 630         impl_on_struct = (expected_struct in opaque_structs or expected_struct in trait_structs or
 631             expected_struct in complex_enums or expected_struct in complex_enums or
 632             expected_struct in result_types or expected_struct in tuple_types) and not is_free
 633         impl_on_utils = not impl_on_struct and (not is_free and not method_name.endswith("_clone") and
 634             not method_name.startswith("TxOut") and not method_name.startswith("BigEndianScalar") and
 635             not method_name.startswith("_") and
 636             method_name != "check_platform" and method_name != "Result_read" and
 637             not expected_struct in unitary_enums and
 638             ((not method_name.startswith("C2Tuple_") and not method_name.startswith("C3Tuple_"))
 639               or method_name.endswith("_read")))
 640
 641         # If we're adding a static method, and it returns a primitive or an array of primitives,
 642         # and a variable conversion adds a reference on the return type (via `this`), skip the
 643         # variable's conversion reference-add (as we obviously cannot need a reference).
 644         if impl_on_utils and (return_type_info.is_native_primitive or
 645                 (return_type_info.ty_info.subty is not None and return_type_info.ty_info.subty.is_native_primitive)):
 646             for arg in argument_types:
 647                 if arg.from_hu_conv is not None and arg.from_hu_conv[1] != "":
 648                     if "this" in arg.from_hu_conv[1]:
 649                         arg.from_hu_conv = (arg.from_hu_conv[0], "")
 650
 651         out_java.write("\t// " + line)
 652         args_known = True # We no longer ever set this to false
 653         (out_java_delta, out_c_delta, out_java_struct_delta) = \
 654             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)
 655         out_java.write(out_java_delta)
 656
 657         if is_free:
 658             assert len(argument_types) == 1
 659             assert return_type_info.c_ty == "void"
 660             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")
 661             if argument_types[0].ty_info.passed_as_ptr and not argument_types[0].ty_info.rust_obj in opaque_structs:
 662                 write_c("\tif (!ptr_is_owned(" + argument_types[0].ty_info.var_name + ")) return;\n")
 663
 664             for info in argument_types:
 665                 if info.arg_conv is not None:
 666                     write_c("\t" + info.arg_conv.replace('\n', "\n\t") + "\n")
 667             assert c_call_string is None
 668             write_c("\t" + method_name + "(")
 669             if argument_types[0].arg_conv_name is not None:
 670                 write_c(argument_types[0].arg_conv_name)
 671             write_c(");")
 672             for info in argument_types:
 673                 if info.arg_conv_cleanup is not None:
 674                     write_c("\n\t" + info.arg_conv_cleanup.replace("\n", "\n\t"))
 675             write_c("\n}\n\n")
 676         else:
 677             write_c(out_c_delta)
 678
 679         out_java_struct = None
 680         if impl_on_struct:
 681             out_java_struct = open(f"{sys.argv[3]}/structs/{struct_meth}{consts.file_ext}", "a")
 682             out_java_struct.write(out_java_struct_delta)
 683         elif impl_on_utils:
 684             out_java_struct = open(f"{sys.argv[3]}/structs/UtilMethods{consts.file_ext}", "a")
 685             for line in out_java_struct_delta.splitlines():
 686                 out_java_struct.write(line + "\n")
 687
 688     def map_unitary_enum(struct_name, field_lines, enum_doc_comment):
 689         assert struct_name.startswith("LDK")
 690         with open(f"{sys.argv[3]}/enums/{struct_name[3:]}{consts.file_ext}", "w") as out_java_enum:
 691             unitary_enums.add(struct_name)
 692             for idx, (struct_line, _) in enumerate(field_lines):
 693                 if idx == 0:
 694                     assert(struct_line == "typedef enum %s {" % struct_name)
 695                 elif idx == len(field_lines) - 3:
 696                     assert(struct_line.endswith("_Sentinel,"))
 697                 elif idx == len(field_lines) - 2:
 698                     assert(struct_line == "} %s;" % struct_name)
 699                 elif idx == len(field_lines) - 1:
 700                     assert(struct_line == "")
 701             assert struct_name.startswith("LDK")
 702             (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)
 703             write_c(c_out)
 704             out_java_enum.write(native_file_out)
 705             out_java.write(native_out)
 706
 707     def map_complex_enum(struct_name, union_enum_items, inline_enum_variants, enum_doc_comment):
 708         java_hu_type = struct_name.replace("LDK", "").replace("COption", "Option")
 709
 710         enum_variants = []
 711         tag_field_lines = union_enum_items["field_lines"]
 712         contains_trait = False
 713         for idx, (struct_line, variant_docs) in enumerate(tag_field_lines):
 714             if idx == 0:
 715                 assert(struct_line == "typedef enum %s_Tag {" % struct_name)
 716             elif idx == len(tag_field_lines) - 3:
 717                 assert(struct_line.endswith("_Sentinel,"))
 718             elif idx == len(tag_field_lines) - 2:
 719                 assert(struct_line == "} %s_Tag;" % struct_name)
 720             elif idx == len(tag_field_lines) - 1:
 721                 assert(struct_line == "")
 722             else:
 723                 variant_name = struct_line.strip(' ,')[len(struct_name) + 1:]
 724                 fields = []
 725                 if "LDK" + variant_name in union_enum_items:
 726                     enum_var_lines = union_enum_items["LDK" + variant_name]
 727                     for idx, (field, field_docs) in enumerate(enum_var_lines):
 728                         if idx != 0 and idx < len(enum_var_lines) - 2 and field.strip() != "":
 729                             field_ty = type_mapping_generator.java_c_types(field.strip(' ;'), None)
 730                             contains_trait |= field_ty.contains_trait
 731                             if field_docs is not None and doc_to_field_nullable(field_docs):
 732                                 field_conv = type_mapping_generator.map_type_with_info(field_ty, False, None, False, True, True)
 733                             else:
 734                                 field_conv = type_mapping_generator.map_type_with_info(field_ty, False, None, False, True, False)
 735                             fields.append((field_conv, field_docs))
 736                     enum_variants.append(ComplexEnumVariantInfo(variant_name, variant_docs, fields, False))
 737                 elif camel_to_snake(variant_name) in inline_enum_variants:
 738                     # TODO: If we ever have a rust enum Variant(Option<Struct>) we need to pipe
 739                     # docs through to there, and then potentially mark the field nullable.
 740                     (variant_info, variant_field_docs) = inline_enum_variants[camel_to_snake(variant_name)]
 741                     variant_ty_text = variant_info + " " + camel_to_snake(variant_name)
 742                     variant_ty_info = type_mapping_generator.java_c_types(variant_ty_text, None)
 743                     if variant_field_docs is not None and doc_to_field_nullable(variant_field_docs):
 744                         mapped = type_mapping_generator.map_type_with_info(variant_ty_info, False, None, False, True, True)
 745                     else:
 746                         mapped = type_mapping_generator.map_type_with_info(variant_ty_info, False, None, False, True, False)
 747                     contains_trait |= mapped.ty_info.contains_trait
 748                     fields.append((mapped, None))
 749                     enum_variants.append(ComplexEnumVariantInfo(variant_name, variant_docs, fields, True))
 750                 else:
 751                     enum_variants.append(ComplexEnumVariantInfo(variant_name, variant_docs, fields, True))
 752         complex_enums[struct_name] = contains_trait
 753
 754         with open(f"{sys.argv[3]}/structs/{java_hu_type}{consts.file_ext}", "w") as out_java_enum:
 755             (out_java_addendum, out_java_enum_addendum, out_c_addendum) = consts.map_complex_enum(struct_name, enum_variants, camel_to_snake, enum_doc_comment)
 756
 757             out_java_enum.write(out_java_enum_addendum)
 758             out_java.write(out_java_addendum)
 759             write_c(out_c_addendum)
 760
 761     def map_trait(struct_name, field_var_lines, trait_fn_lines, trait_doc_comment):
 762         with open(f"{sys.argv[3]}/structs/{struct_name.replace('LDK', '')}{consts.file_ext}", "w") as out_java_trait:
 763             field_var_convs = []
 764             flattened_field_var_convs = []
 765             for var_line in field_var_lines:
 766                 if var_line.group(1) in trait_structs:
 767                     field_var_convs.append((var_line.group(1), var_line.group(2), trait_structs[var_line.group(1)]))
 768                     flattened_field_var_convs.append((var_line.group(1), var_line.group(2), ))
 769                     flattened_field_var_convs.extend(trait_structs[var_line.group(1)])
 770                 else:
 771                     mapped = type_mapping_generator.map_type(var_line.group(1) + " " + var_line.group(2), False, None, False, False)
 772                     field_var_convs.append(mapped)
 773                     flattened_field_var_convs.append(mapped)
 774             trait_structs[struct_name] = field_var_convs
 775
 776             field_fns = []
 777             for fn_docs, fn_line in trait_fn_lines:
 778                 if fn_line == "cloned":
 779                     ret_ty_info = type_mapping_generator.map_type("void", True, None, False, False)
 780                     field_fns.append(TraitMethInfo("cloned", False, ret_ty_info, [], fn_docs))
 781                 else:
 782                     (nullable_params, ret_nullable) = doc_to_params_ret_nullable(fn_docs)
 783                     if ret_nullable:
 784                         ret_ty_info = type_mapping_generator.map_nullable_type(fn_line.group(2).strip() + " ret", True, None, False, False)
 785                         ret_ty_info.nullable = True
 786                     else:
 787                         ret_ty_info = type_mapping_generator.map_type(fn_line.group(2).strip() + " ret", True, None, False, False)
 788                     is_const = fn_line.group(4) is not None
 789
 790                     arg_tys = []
 791                     for idx, arg in enumerate(fn_line.group(5).split(',')):
 792                         if arg == "":
 793                             continue
 794                         arg_ty_info = type_mapping_generator.java_c_types(arg, None)
 795                         if arg_ty_info.var_name in nullable_params:
 796                             # Types that are actually null instead of all-0s aren't yet handled on the Java side:
 797                             arg_conv_info = type_mapping_generator.map_type_with_info(arg_ty_info, True, None, False, False, True)
 798                         else:
 799                             arg_conv_info = type_mapping_generator.map_type_with_info(arg_ty_info, True, None, False, False, False)
 800                         arg_tys.append(arg_conv_info)
 801                     field_fns.append(TraitMethInfo(fn_line.group(3), is_const, ret_ty_info, arg_tys, fn_docs))
 802
 803             (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)
 804             write_c(out_c_addendum)
 805             out_java_trait.write(out_java_trait_addendum)
 806             out_java.write(out_java_addendum)
 807
 808         for fn_docs, fn_line in trait_fn_lines:
 809             if fn_line == "cloned":
 810                 continue
 811             # For now, just disable enabling the _call_log - we don't know how to inverse-map String
 812             is_log = fn_line.group(3) == "log" and struct_name == "LDKLogger"
 813             if fn_line.group(3) != "free" and fn_line.group(3) != "eq" and not is_log:
 814                 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"
 815                 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)
 816         for idx, var_line in enumerate(field_var_lines):
 817             if var_line.group(1) not in trait_structs:
 818                 write_c(var_line.group(1) + " " + struct_name + "_set_get_" + var_line.group(2) + "(" + struct_name + "* this_arg) {\n")
 819                 write_c("\tif (this_arg->set_" + var_line.group(2) + " != NULL)\n")
 820                 write_c("\t\tthis_arg->set_" + var_line.group(2) + "(this_arg);\n")
 821                 write_c("\treturn this_arg->" + var_line.group(2) + ";\n")
 822                 write_c("}\n")
 823                 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"
 824                 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)
 825
 826     def map_result(struct_name, res_ty, err_ty):
 827         result_types.add(struct_name)
 828         human_ty = struct_name.replace("LDKCResult", "Result")
 829         res_map = type_mapping_generator.map_type(res_ty + " res", True, None, False, True)
 830         err_map = type_mapping_generator.map_type(err_ty + " err", True, None, False, True)
 831         java_hu_struct = consts.map_result(struct_name, res_map, err_map)
 832         create_getter(struct_name, res_ty, "ok", ("*", "->contents.result"), ("", "->result_ok"))
 833         create_getter(struct_name, err_ty, "err", ("*", "->contents.err"), ("!", "->result_ok"))
 834         with open(f"{sys.argv[3]}/structs/{human_ty}{consts.file_ext}", "w") as out_java_struct:
 835             out_java_struct.write(java_hu_struct)
 836
 837     def create_getter(struct_name, field_decl, field_name, accessor, check_sfx):
 838         field_ty = java_c_types(field_decl + " " + field_name, None)
 839         ptr_fn_defn = field_decl + " *" + struct_name.replace("LDK", "") + "_get_" + field_name + "(" + struct_name + " *NONNULL_PTR owner)"
 840         owned_fn_defn = field_decl + " " + struct_name.replace("LDK", "") + "_get_" + field_name + "(" + struct_name + " *NONNULL_PTR owner)"
 841
 842         holds_ref = False
 843         if field_ty.rust_obj is not None and field_ty.rust_obj in opaque_structs:
 844             fn_defn = owned_fn_defn
 845             write_c("static inline " + fn_defn + "{\n")
 846             write_c("\t" + field_ty.rust_obj + " ret = " + accessor[0] + "owner" + accessor[1] + ";\n")
 847             write_c("\tret.is_owned = false;\n")
 848             write_c("\treturn ret;\n")
 849         elif field_ty.rust_obj is not None and field_ty.rust_obj.replace("LDK", "") + "_clone" in clone_fns:
 850             fn_defn = owned_fn_defn
 851             write_c("static inline " + fn_defn + "{\n")
 852             if check_sfx is not None:
 853                 write_c("CHECK(" + check_sfx[0] + "owner" + check_sfx[1] + ");\n")
 854             write_c("\treturn " + field_ty.rust_obj.replace("LDK", "") + "_clone(&" + accessor[0] + "owner" + accessor[1] + ");\n")
 855         elif field_ty.arr_len is not None or field_ty.is_native_primitive or field_ty.rust_obj in unitary_enums:
 856             fn_defn = owned_fn_defn
 857             write_c("static inline " + fn_defn + "{\n")
 858             if check_sfx is not None:
 859                 write_c("CHECK(" + check_sfx[0] + "owner" + check_sfx[1] + ");\n")
 860             write_c("\treturn " + accessor[0] + "owner" + accessor[1] + ";\n")
 861             holds_ref = True
 862         else:
 863             fn_defn = ptr_fn_defn
 864             write_c("static inline " + fn_defn + "{\n")
 865             if check_sfx is not None:
 866                 write_c("CHECK(" + check_sfx[0] + "owner" + check_sfx[1] + ");\n")
 867             write_c("\treturn &" + accessor[0] + "owner" + accessor[1] + ";\n")
 868             holds_ref = True
 869         write_c("}\n")
 870         dummy_line = fn_defn + ";\n"
 871         map_fn_with_ref_option(dummy_line, reg_fn_regex.match(dummy_line), None, None, "", holds_ref)
 872
 873     def map_tuple(struct_name, field_lines):
 874         human_ty = struct_name.replace("LDKC2Tuple", "TwoTuple").replace("LDKC3Tuple", "ThreeTuple")
 875         with open(f"{sys.argv[3]}/structs/{human_ty}{consts.file_ext}", "w") as out_java_struct:
 876             out_java_struct.write(consts.map_tuple(struct_name))
 877             ty_list = []
 878             for idx, (line, _) in enumerate(field_lines):
 879                 if idx != 0 and idx < len(field_lines) - 2:
 880                     ty_list.append(java_c_types(line.strip(';'), None))
 881             tuple_types[struct_name] = (ty_list, struct_name)
 882
 883         # Map virtual getter functions
 884         for idx, (line, _) in enumerate(field_lines):
 885             if idx != 0 and idx < len(field_lines) - 2:
 886                 field_name = chr(ord('a') + idx - 1)
 887                 assert line.endswith(" " + field_name + ";")
 888                 create_getter(struct_name, line[:-3].strip(), field_name, ("", "->" + field_name), None)
 889
 890     out_java.write(consts.bindings_header)
 891     with open(f"{sys.argv[2]}/version{consts.file_ext}", "w") as out_java_version:
 892         out_java_version.write(consts.bindings_version_file.replace('<git_version_ldk_garbagecollected>', local_git_version))
 893
 894     with open(f"{sys.argv[3]}/structs/CommonBase{consts.file_ext}", "w") as out_java_struct:
 895         out_java_struct.write(consts.common_base)
 896
 897     block_comment = None
 898     last_block_comment = None
 899     cur_block_obj = None
 900
 901     const_val_regex = re.compile("^extern const ([A-Za-z_0-9]*) ([A-Za-z_0-9]*);$")
 902
 903     line_indicates_result_regex = re.compile("^   union (LDKCResult_[A-Za-z_0-9]*Ptr) contents;$")
 904     line_indicates_vec_regex = re.compile("^   (struct |enum |union )?([A-Za-z_0-9]*) \*data;$")
 905     line_indicates_opaque_regex = re.compile("^   bool is_owned;$")
 906     line_indicates_trait_regex = re.compile("^   (struct |enum |union )?([A-Za-z_0-9]* \*?)\(\*([A-Za-z_0-9]*)\)\((const )?void \*this_arg(.*)\);$")
 907     assert(line_indicates_trait_regex.match("   uintptr_t (*send_data)(void *this_arg, LDKu8slice data, bool resume_read);"))
 908     assert(line_indicates_trait_regex.match("   struct LDKCVec_MessageSendEventZ (*get_and_clear_pending_msg_events)(const void *this_arg);"))
 909     assert(line_indicates_trait_regex.match("   struct LDKCVec_u8Z (*write)(const void *this_arg);"))
 910     line_indicates_trait_clone_regex = re.compile("^   void \(\*cloned\)\(struct ([A-Za-z0-9])* \*NONNULL_PTR new_[A-Za-z0-9]*\);$")
 911     assert(line_indicates_trait_clone_regex.match("   void (*cloned)(struct LDKSign *NONNULL_PTR new_Sign);"))
 912     line_field_var_regex = re.compile("^   struct ([A-Za-z_0-9]*) ([A-Za-z_0-9]*);$")
 913     assert(line_field_var_regex.match("   struct LDKMessageSendEventsProvider MessageSendEventsProvider;"))
 914     assert(line_field_var_regex.match("   struct LDKChannelPublicKeys pubkeys;"))
 915     struct_name_regex = re.compile("^typedef (struct|enum|union) (MUST_USE_STRUCT )?(LDK[A-Za-z_0-9]*) {$")
 916     assert(struct_name_regex.match("typedef struct LDKCVec_u8Z {"))
 917     assert(struct_name_regex.match("typedef enum LDKNetwork {"))
 918
 919     union_enum_items = {}
 920     result_ptr_struct_items = {}
 921     for line in in_h:
 922         if block_comment is not None:
 923             if line.endswith("*/\n"):
 924                 last_block_comment = block_comment.strip("\n")
 925                 block_comment = None
 926             else:
 927                 block_comment = block_comment + line.strip(" /*")
 928         elif cur_block_obj is not None:
 929             cur_block_obj  = cur_block_obj + line
 930             if line.startswith("} "):
 931                 field_lines = []
 932                 struct_name = None
 933                 vec_ty = None
 934                 obj_lines = cur_block_obj.split("\n")
 935                 is_opaque = False
 936                 result_contents = None
 937                 is_unitary_enum = False
 938                 is_union_enum = False
 939                 is_union = False
 940                 is_tuple = False
 941                 trait_fn_lines = []
 942                 field_var_lines = []
 943                 last_struct_block_comment = None
 944
 945                 for idx, struct_line in enumerate(obj_lines):
 946                     if struct_line.strip().startswith("/*"):
 947                         block_comment = struct_line.strip(" /*")
 948                     if block_comment is not None:
 949                         if struct_line.endswith("*/"):
 950                             last_struct_block_comment = block_comment.strip("\n")
 951                             block_comment = None
 952                         else:
 953                             block_comment = block_comment + "\n" + struct_line.strip(" /*").replace("…", "...")
 954                     else:
 955                         struct_name_match = struct_name_regex.match(struct_line)
 956                         if struct_name_match is not None:
 957                             struct_name = struct_name_match.group(3)
 958                             if struct_name_match.group(1) == "enum":
 959                                 if not struct_name.endswith("_Tag"):
 960                                     is_unitary_enum = True
 961                                 else:
 962                                     is_union_enum = True
 963                             elif struct_name_match.group(1) == "union":
 964                                 is_union = True
 965                         if line_indicates_opaque_regex.match(struct_line):
 966                             is_opaque = True
 967                         result_match = line_indicates_result_regex.match(struct_line)
 968                         if result_match is not None:
 969                             result_contents = result_match.group(1)
 970                         vec_ty_match = line_indicates_vec_regex.match(struct_line)
 971                         if vec_ty_match is not None and struct_name.startswith("LDKCVec_"):
 972                             vec_ty = vec_ty_match.group(2)
 973                         elif struct_name.startswith("LDKC2Tuple_") or struct_name.startswith("LDKC3Tuple_"):
 974                             is_tuple = True
 975                         trait_fn_match = line_indicates_trait_regex.match(struct_line)
 976                         if trait_fn_match is not None:
 977                             trait_fn_lines.append((last_struct_block_comment, trait_fn_match))
 978                         trait_clone_fn_match = line_indicates_trait_clone_regex.match(struct_line)
 979                         if trait_clone_fn_match is not None:
 980                             trait_fn_lines.append((last_struct_block_comment, "cloned"))
 981                         field_var_match = line_field_var_regex.match(struct_line)
 982                         if field_var_match is not None:
 983                             field_var_lines.append(field_var_match)
 984                         field_lines.append((struct_line, last_struct_block_comment))
 985                         last_struct_block_comment = None
 986
 987                 assert(struct_name is not None)
 988                 assert(len(trait_fn_lines) == 0 or not (is_opaque or is_unitary_enum or is_union_enum or is_union or result_contents is not None or vec_ty is not None))
 989                 assert(not is_opaque or not (len(trait_fn_lines) != 0 or is_unitary_enum or is_union_enum or is_union or result_contents is not None or vec_ty is not None))
 990                 assert(not is_unitary_enum or not (len(trait_fn_lines) != 0 or is_opaque or is_union_enum or is_union or result_contents is not None or vec_ty is not None))
 991                 assert(not is_union_enum or not (len(trait_fn_lines) != 0 or is_unitary_enum or is_opaque or is_union or result_contents is not None or vec_ty is not None))
 992                 assert(not is_union or not (len(trait_fn_lines) != 0 or is_unitary_enum or is_union_enum or is_opaque or result_contents is not None or vec_ty is not None))
 993                 assert(result_contents is None or not (len(trait_fn_lines) != 0 or is_unitary_enum or is_union_enum or is_opaque or is_union or vec_ty is not None))
 994                 assert(vec_ty is None or not (len(trait_fn_lines) != 0 or is_unitary_enum or is_union_enum or is_opaque or is_union or result_contents is not None))
 995
 996                 if is_opaque:
 997                     opaque_structs.add(struct_name)
 998                     with open(f"{sys.argv[3]}/structs/{struct_name.replace('LDK', '')}{consts.file_ext}", "w") as out_java_struct:
 999                         out_opaque_struct_human = consts.map_opaque_struct(struct_name, last_block_comment)
1000                         last_block_comment = None
1001                         out_java_struct.write(out_opaque_struct_human)
1002                 elif result_contents is not None:
1003                     assert result_contents in result_ptr_struct_items
1004                     res_ty, err_ty = result_ptr_struct_items[result_contents]
1005                     map_result(struct_name, res_ty, err_ty)
1006                 elif struct_name.startswith("LDKCResult_") and struct_name.endswith("ZPtr"):
1007                     for line, _ in field_lines:
1008                         if line.endswith("*result;"):
1009                             res_ty = line[:-8].strip()
1010                         elif line.endswith("*err;"):
1011                             err_ty = line[:-5].strip()
1012                     result_ptr_struct_items[struct_name] = (res_ty, err_ty)
1013                     result_types.add(struct_name[:-3])
1014                 elif is_tuple:
1015                     map_tuple(struct_name, field_lines)
1016                 elif vec_ty is not None:
1017                     ty_info = type_mapping_generator.map_type(vec_ty + " arr_elem", False, None, False, False)
1018                     if ty_info.is_native_primitive:
1019                         clone_fns.add(struct_name.replace("LDK", "") + "_clone")
1020                         write_c("static inline " + struct_name + " " + struct_name.replace("LDK", "") + "_clone(const " + struct_name + " *orig) {\n")
1021                         write_c("\t" + struct_name + " ret = { .data = MALLOC(sizeof(" + ty_info.c_ty + ") * orig->datalen, \"" + struct_name + " clone bytes\"), .datalen = orig->datalen };\n")
1022                         write_c("\tmemcpy(ret.data, orig->data, sizeof(" + ty_info.c_ty + ") * ret.datalen);\n")
1023                         write_c("\treturn ret;\n}\n")
1024                     elif (ty_info.rust_obj.replace("LDK", "") + "_clone") in clone_fns:
1025                         ty_name = struct_name.replace("LDK", "")
1026                         clone_fns.add(ty_name + "_clone")
1027                         write_c("static inline " + struct_name + " " + ty_name + "_clone(const " + struct_name + " *orig) {\n")
1028                         write_c("\t" + struct_name + " ret = { .data = MALLOC(sizeof(" + ty_info.rust_obj + ") * orig->datalen, \"" + struct_name + " clone bytes\"), .datalen = orig->datalen };\n")
1029                         write_c("\tfor (size_t i = 0; i < ret.datalen; i++) {\n")
1030                         write_c("\t\tret.data[i] = " + ty_info.rust_obj.replace("LDK", "") + "_clone(&orig->data[i]);\n")
1031                         write_c("\t}\n\treturn ret;\n}\n")
1032                 elif is_union_enum:
1033                     assert(struct_name.endswith("_Tag"))
1034                     struct_name = struct_name[:-4]
1035                     union_enum_items[struct_name] = {"field_lines": field_lines}
1036                 elif struct_name.endswith("_Body") and struct_name.split("_")[0] in union_enum_items:
1037                     enum_var_name = struct_name.split("_")
1038                     union_enum_items[enum_var_name[0]][enum_var_name[1]] = field_lines
1039                 elif struct_name in union_enum_items:
1040                     tuple_variants = {}
1041                     elem_items = -1
1042                     for line, field_block_comment in field_lines:
1043                         if line == "      struct {":
1044                             elem_items = 0
1045                         elif line == "      };":
1046                             elem_items = -1
1047                         elif elem_items > -1:
1048                             line = line.strip()
1049                             if line.startswith("struct "):
1050                                 line = line[7:]
1051                             elif line.startswith("enum "):
1052                                 line = line[5:]
1053                             split = line.split(" ")
1054                             assert len(split) == 2
1055                             tuple_variants[split[1].strip(";")] = (split[0], field_block_comment)
1056                             elem_items += 1
1057                             if elem_items > 1:
1058                                 # We don't currently support tuple variant with more than one element
1059                                 assert False
1060                     map_complex_enum(struct_name, union_enum_items[struct_name], tuple_variants, last_block_comment)
1061                     last_block_comment = None
1062                 elif is_unitary_enum:
1063                     map_unitary_enum(struct_name, field_lines, last_block_comment)
1064                     last_block_comment = None
1065                 elif len(trait_fn_lines) > 0:
1066                     map_trait(struct_name, field_var_lines, trait_fn_lines, last_block_comment)
1067                 elif struct_name == "LDKTxOut":
1068                     with open(f"{sys.argv[3]}/structs/TxOut{consts.file_ext}", "w") as out_java_struct:
1069                         out_java_struct.write(consts.hu_struct_file_prefix)
1070                         out_java_struct.write(consts.txout_defn)
1071                         out_java_struct.write(consts.hu_struct_file_suffix)
1072                         fn_line = "struct LDKCVec_u8Z TxOut_get_script_pubkey (struct LDKTxOut* thing)"
1073                         write_c(fn_line + " {")
1074                         write_c("\treturn CVec_u8Z_clone(&thing->script_pubkey);")
1075                         write_c("}")
1076                         map_fn(fn_line + "\n", re.compile("(.*) (TxOut_get_script_pubkey) \((.*)\)").match(fn_line), None, None, None)
1077                         fn_line = "uint64_t TxOut_get_value (struct LDKTxOut* thing)"
1078                         write_c(fn_line + " {")
1079                         write_c("\treturn thing->value;")
1080                         write_c("}")
1081                         map_fn(fn_line + "\n", re.compile("(.*) (TxOut_get_value) \((.*)\)").match(fn_line), None, None, None)
1082                 elif struct_name == "LDKBigEndianScalar":
1083                     with open(f"{sys.argv[3]}/structs/BigEndianScalar{consts.file_ext}", "w") as out_java_struct:
1084                         out_java_struct.write(consts.hu_struct_file_prefix)
1085                         out_java_struct.write(consts.scalar_defn)
1086                         out_java_struct.write(consts.hu_struct_file_suffix)
1087                         fn_line = "struct LDKThirtyTwoBytes BigEndianScalar_get_bytes (struct LDKBigEndianScalar* thing)"
1088                         write_c(fn_line + " {\n")
1089                         write_c("\tLDKThirtyTwoBytes ret = { .data = *thing->big_endian_bytes };\n")
1090                         write_c("\treturn ret;\n")
1091                         write_c("}\n")
1092                         map_fn(fn_line + "\n", re.compile("(.*) (BigEndianScalar_get_bytes) \((.*)\)").match(fn_line), None, None, None)
1093
1094                         # We need to be able to FREE a heap-allocated BigEndianScalar, but because
1095                         # there's nothing heap-allocated inside it the C bindings don't bother
1096                         # exposing a `_free` method. Instead, we have to manually write one here,
1097                         # though it doesn't need to do anything, the autogenerated wrapper will do
1098                         # the required FREE.
1099                         fn_line = "static void BigEndianScalar_free (struct LDKBigEndianScalar thing)"
1100                         write_c(fn_line + " {}\n")
1101                         map_fn(fn_line + "\n", re.compile("static (.*) (BigEndianScalar_free) \((.*)\)").match(fn_line), None, None, None)
1102                 else:
1103                     pass # Everything remaining is a byte[] of some form
1104                 cur_block_obj = None
1105         else:
1106             fn_ptr = fn_ptr_regex.match(line)
1107             fn_ret_arr = fn_ret_arr_regex.match(line)
1108             reg_fn = reg_fn_regex.match(line)
1109             const_val = const_val_regex.match(line)
1110
1111             if line.startswith("#include <"):
1112                 pass
1113             elif line.startswith("/*"):
1114                 if not line.endswith("*/\n"):
1115                     block_comment = line.strip(" /*")
1116             elif line.startswith("typedef enum "):
1117                 cur_block_obj = line
1118             elif line.startswith("typedef struct "):
1119                 cur_block_obj = line
1120             elif line.startswith("typedef union "):
1121                 cur_block_obj = line
1122             elif fn_ptr is not None:
1123                 map_fn(line, fn_ptr, None, None, last_block_comment)
1124                 last_block_comment = None
1125             elif fn_ret_arr is not None:
1126                 map_fn(line, fn_ret_arr, fn_ret_arr.group(4), None, last_block_comment)
1127                 last_block_comment = None
1128             elif reg_fn is not None:
1129                 map_fn(line, reg_fn, None, None, last_block_comment)
1130                 last_block_comment = None
1131             elif const_val_regex is not None:
1132                 # TODO Map const variables
1133                 pass
1134             else:
1135                 assert(line == "\n")
1136
1137     out_java.write(consts.bindings_footer())
1138     for struct_name in opaque_structs:
1139         with open(f"{sys.argv[3]}/structs/{struct_name.replace('LDK', '')}{consts.file_ext}", "a") as out_java_struct:
1140             out_java_struct.write("}\n" + consts.hu_struct_file_suffix)
1141     for struct_name in trait_structs:
1142         with open(f"{sys.argv[3]}/structs/{struct_name.replace('LDK', '')}{consts.file_ext}", "a") as out_java_struct:
1143             out_java_struct.write("}\n" + consts.hu_struct_file_suffix)
1144     for struct_name in complex_enums:
1145         with open(f"{sys.argv[3]}/structs/{struct_name.replace('LDK', '').replace('COption', 'Option')}{consts.file_ext}", "a") as out_java_struct:
1146             out_java_struct.write("}\n" + consts.hu_struct_file_suffix)
1147     for struct_name in result_types:
1148         with open(f"{sys.argv[3]}/structs/{struct_name.replace('LDKCResult', 'Result')}{consts.file_ext}", "a") as out_java_struct:
1149             out_java_struct.write("}\n" + consts.hu_struct_file_suffix)
1150     for struct_name in tuple_types:
1151         struct_hu_name = struct_name.replace("LDKC2Tuple", "TwoTuple").replace("LDKC3Tuple", "ThreeTuple")
1152         with open(f"{sys.argv[3]}/structs/{struct_hu_name}{consts.file_ext}", "a") as out_java_struct:
1153             out_java_struct.write("}\n" + consts.hu_struct_file_suffix)
1154
1155 with open(f"{sys.argv[4]}/bindings.c.body", "w") as out_c:
1156     out_c.write(consts.c_file_pfx)
1157     out_c.write(consts.init_str())
1158     out_c.write(c_file)
1159 with open(f"{sys.argv[4]}/version.c", "w") as out_c:
1160     out_c.write(consts.c_version_file.replace('<git_version_ldk_garbagecollected>', local_git_version))
1161 with open(f"{sys.argv[3]}/structs/UtilMethods{consts.file_ext}", "a") as util:
1162     util.write(consts.util_fn_sfx)
1163 consts.cleanup()