unitary_enums = set()
complex_enums = set()
opaque_structs = set()
-trait_structs = set()
+trait_structs = {}
result_types = set()
tuple_types = {}
assert var_is_arr_regex.match(fn_arg[8:])
rust_obj = "LDKThirtyTwoBytes"
arr_access = "data"
+ elif fn_arg.startswith("LDKTxid"):
+ fn_arg = "uint8_t (*" + fn_arg[8:] + ")[32]"
+ assert var_is_arr_regex.match(fn_arg[8:])
+ rust_obj = "LDKThirtyTwoBytes"
+ arr_access = "data"
elif fn_arg.startswith("LDKPublicKey"):
fn_arg = "uint8_t (*" + fn_arg[13:] + ")[33]"
assert var_is_arr_regex.match(fn_arg[8:])
assert var_is_arr_regex.match(fn_arg[8:])
rust_obj = "LDKSignature"
arr_access = "compact_form"
+ elif fn_arg.startswith("LDKRecoverableSignature"):
+ fn_arg = "uint8_t (*" + fn_arg[25:] + ")[68]"
+ assert var_is_arr_regex.match(fn_arg[8:])
+ rust_obj = "LDKRecoverableSignature"
+ arr_access = "serialized_form"
elif fn_arg.startswith("LDKThreeBytes"):
fn_arg = "uint8_t (*" + fn_arg[14:] + ")[3]"
assert var_is_arr_regex.match(fn_arg[8:])
assert var_is_arr_regex.match(fn_arg[8:])
rust_obj = "LDKSixteenBytes"
arr_access = "data"
+ elif fn_arg.startswith("LDKTwentyBytes"):
+ fn_arg = "uint8_t (*" + fn_arg[15:] + ")[20]"
+ 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]"
assert var_is_arr_regex.match(fn_arg[8:])
rust_obj = "LDKCVec_u8Z"
assert var_is_arr_regex.match(fn_arg[8:])
arr_access = "data"
- elif fn_arg.startswith("LDKTransaction"):
+ elif fn_arg.startswith("LDKTransaction ") or fn_arg == "LDKTransaction":
fn_arg = "uint8_t (*" + fn_arg[15:] + ")[datalen]"
rust_obj = "LDKTransaction"
assert var_is_arr_regex.match(fn_arg[8:])
fn_ty_arg = "B"
fn_arg = fn_arg[7:].strip()
is_primitive = True
+ elif fn_arg.startswith("LDKu5"):
+ java_ty = consts.c_type_map['uint8_t'][0]
+ java_hu_ty = "UInt5"
+ rust_obj = "LDKu5"
+ c_ty = "int8_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]
else:
c_ty = consts.ptr_c_ty
java_ty = consts.ptr_native_ty
- java_hu_ty = ma.group(1).strip().replace("LDKCResult", "Result").replace("LDK", "")
+ java_hu_ty = ma.group(1).strip().replace("LDKCOption", "Option").replace("LDKCResult", "Result").replace("LDK", "")
fn_ty_arg = "J"
fn_arg = ma.group(2).strip()
rust_obj = ma.group(1).strip()
method_arguments = method_comma_separated_arguments.split(',')
is_free = method_name.endswith("_free")
- struct_meth = method_name.split("_")[0]
+ if method_name.startswith("COption") or method_name.startswith("CResult"):
+ struct_meth = method_name.rsplit("Z", 1)[0][1:] + "Z"
+ else:
+ struct_meth = method_name.split("_")[0]
- return_type_info = type_mapping_generator.map_type(method_return_type, True, ret_arr_len, False, False)
+ return_type_info = type_mapping_generator.map_type(method_return_type.strip() + " ret", True, ret_arr_len, False, False)
argument_types = []
default_constructor_args = {}
write_c(out_c_delta)
out_java_struct = None
- if ("LDK" + struct_meth in opaque_structs or "LDK" + struct_meth in trait_structs) and not is_free:
+ expected_struct = "LDK" + struct_meth
+ expected_cstruct = "LDKC" + struct_meth
+ if (expected_struct in opaque_structs or expected_struct in trait_structs
+ or expected_struct in complex_enums or expected_cstruct in complex_enums
+ or expected_cstruct in result_types) and not is_free:
out_java_struct = open(f"{sys.argv[3]}/structs/{struct_meth}{consts.file_ext}", "a")
- elif method_name.startswith("C2Tuple_") and method_name.endswith("_read"):
- struct_meth = method_name.rsplit("_", 1)[0]
+ elif (method_name.startswith("C2Tuple_") and method_name.endswith("_read")) or \
+ (return_type_info.rust_obj is not None and "Result" in return_type_info.rust_obj and "from" in method_name):
out_java_struct = open(f"{sys.argv[3]}/structs/UtilMethods{consts.file_ext}", "a")
if out_java_struct is not None:
out_java_struct.write(out_java_struct_delta)
out_java_enum.write(native_file_out)
out_java.write(native_out)
- def map_complex_enum(struct_name, union_enum_items, enum_doc_comment):
- java_hu_type = struct_name.replace("LDK", "")
+ def map_complex_enum(struct_name, union_enum_items, inline_enum_variants, enum_doc_comment):
+ java_hu_type = struct_name.replace("LDK", "").replace("COption", "Option")
complex_enums.add(struct_name)
enum_variants = []
for idx, field in enumerate(enum_var_lines):
if idx != 0 and idx < len(enum_var_lines) - 2:
fields.append(type_mapping_generator.map_type(field.strip(' ;'), False, None, False, True))
- else:
- # TODO: Assert line format
- pass
+ enum_variants.append(ComplexEnumVariantInfo(variant_name, fields, False))
+ elif camel_to_snake(variant_name) in inline_enum_variants:
+ fields.append(type_mapping_generator.map_type(inline_enum_variants[camel_to_snake(variant_name)] + " " + camel_to_snake(variant_name), False, None, False, True))
+ enum_variants.append(ComplexEnumVariantInfo(variant_name, fields, True))
else:
- # TODO: Assert line format
- pass
- enum_variants.append(ComplexEnumVariantInfo(variant_name, fields))
+ enum_variants.append(ComplexEnumVariantInfo(variant_name, fields, True))
with open(f"{sys.argv[3]}/structs/{java_hu_type}{consts.file_ext}", "w") as out_java_enum:
(out_java_addendum, out_java_enum_addendum, out_c_addendum) = consts.map_complex_enum(struct_name, enum_variants, camel_to_snake, enum_doc_comment)
def map_trait(struct_name, field_var_lines, trait_fn_lines, trait_doc_comment):
with open(f"{sys.argv[3]}/structs/{struct_name.replace('LDK', '')}{consts.file_ext}", "w") as out_java_trait:
field_var_convs = []
+ flattened_field_var_convs = []
for var_line in field_var_lines:
if var_line.group(1) in trait_structs:
- field_var_convs.append((var_line.group(1), var_line.group(2)))
+ field_var_convs.append((var_line.group(1), var_line.group(2), trait_structs[var_line.group(1)]))
+ flattened_field_var_convs.append((var_line.group(1), var_line.group(2), ))
+ flattened_field_var_convs.extend(trait_structs[var_line.group(1)])
else:
- field_var_convs.append(
- type_mapping_generator.map_type(var_line.group(1) + " " + var_line.group(2), False, None, False, False))
+ mapped = type_mapping_generator.map_type(var_line.group(1) + " " + var_line.group(2), False, None, False, False)
+ field_var_convs.append(mapped)
+ flattened_field_var_convs.append(mapped)
+ trait_structs[struct_name] = field_var_convs
field_fns = []
for fn_docs, fn_line in trait_fn_lines:
- ret_ty_info = type_mapping_generator.map_type(fn_line.group(2), True, None, False, False)
+ ret_ty_info = type_mapping_generator.map_type(fn_line.group(2).strip() + " ret", True, None, False, False)
is_const = fn_line.group(4) is not None
arg_tys = []
arg_tys.append(arg_conv_info)
field_fns.append(TraitMethInfo(fn_line.group(3), is_const, ret_ty_info, arg_tys, fn_docs))
- (out_java_addendum, out_java_trait_addendum, out_c_addendum) = consts.native_c_map_trait(struct_name, field_var_convs, field_fns, trait_doc_comment)
+ (out_java_addendum, out_java_trait_addendum, out_c_addendum) = consts.native_c_map_trait(struct_name, field_var_convs, flattened_field_var_convs, field_fns, trait_doc_comment)
write_c(out_c_addendum)
out_java_trait.write(out_java_trait_addendum)
out_java.write(out_java_addendum)
else:
out_java_struct.write("\t\t\tthis.res = bindings." + struct_name + "_get_ok(ptr);\n")
out_java_struct.write("\t\t}\n")
- if struct_name.startswith("LDKCResult_None"):
- out_java_struct.write("\t\tpublic " + human_ty + "_OK() {\n\t\t\tthis(null, bindings.C" + human_ty + "_ok());\n")
- else:
- out_java_struct.write("\t\tpublic " + human_ty + "_OK(" + res_map.java_hu_ty + " res) {\n")
- if res_map.from_hu_conv is not None:
- out_java_struct.write("\t\t\tthis(null, bindings.C" + human_ty + "_ok(" + res_map.from_hu_conv[0] + "));\n")
- if res_map.from_hu_conv[1] != "":
- out_java_struct.write("\t\t\t" + res_map.from_hu_conv[1].replace("\n", "\n\t\t\t") + ";\n")
- else:
- out_java_struct.write("\t\t\tthis(null, bindings.C" + human_ty + "_ok(res));\n")
- out_java_struct.write("\t\t}\n\t}\n\n")
+ out_java_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")
out_java_struct.write("\t\t\tthis.err = bindings." + struct_name + "_get_err(ptr);\n")
out_java_struct.write("\t\t}\n")
- if struct_name.endswith("NoneZ"):
- out_java_struct.write("\t\tpublic " + human_ty + "_Err() {\n\t\t\tthis(null, bindings.C" + human_ty + "_err());\n")
- else:
- out_java_struct.write("\t\tpublic " + human_ty + "_Err(" + err_map.java_hu_ty + " err) {\n")
- if err_map.from_hu_conv is not None:
- out_java_struct.write("\t\t\tthis(null, bindings.C" + human_ty + "_err(" + err_map.from_hu_conv[0] + "));\n")
- if err_map.from_hu_conv[1] != "":
- out_java_struct.write("\t\t\t" + err_map.from_hu_conv[1].replace("\n", "\n\t\t\t") + ";\n")
- else:
- out_java_struct.write("\t\t\tthis(null, bindings.C" + human_ty + "_err(err));\n")
- out_java_struct.write("\t\t}\n\t}\n}\n")
+ out_java_struct.write("\t}\n\n")
def map_tuple(struct_name, field_lines):
out_java.write("\tpublic static native long " + struct_name + "_new(")
enum_var_name = struct_name.split("_")
union_enum_items[enum_var_name[0]][enum_var_name[1]] = field_lines
elif struct_name in union_enum_items:
- map_complex_enum(struct_name, union_enum_items[struct_name], last_block_comment)
+ tuple_variants = {}
+ elem_items = -1
+ for line in field_lines:
+ if line == " struct {":
+ elem_items = 0
+ elif line == " };":
+ elem_items = -1
+ elif elem_items > -1:
+ line = line.strip()
+ if line.startswith("struct "):
+ line = line[7:]
+ split = line.split(" ")
+ assert len(split) == 2
+ tuple_variants[split[1].strip(";")] = split[0]
+ elem_items += 1
+ if elem_items > 1:
+ # We don't currently support tuple variant with more than one element
+ assert False
+ map_complex_enum(struct_name, union_enum_items[struct_name], tuple_variants, last_block_comment)
last_block_comment = None
elif is_unitary_enum:
map_unitary_enum(struct_name, field_lines, last_block_comment)
last_block_comment = None
elif len(trait_fn_lines) > 0:
- trait_structs.add(struct_name)
map_trait(struct_name, field_var_lines, trait_fn_lines, last_block_comment)
elif struct_name == "LDKTxOut":
with open(f"{sys.argv[3]}/structs/TxOut{consts.file_ext}", "w") as out_java_struct:
for struct_name in trait_structs:
with open(f"{sys.argv[3]}/structs/{struct_name.replace('LDK', '')}{consts.file_ext}", "a") as out_java_struct:
out_java_struct.write("}\n")
+ for struct_name in complex_enums:
+ with open(f"{sys.argv[3]}/structs/{struct_name.replace('LDK', '').replace('COption', 'Option')}{consts.file_ext}", "a") as out_java_struct:
+ out_java_struct.write("}\n")
+ for struct_name in result_types:
+ with open(f"{sys.argv[3]}/structs/{struct_name.replace('LDKCResult', 'Result')}{consts.file_ext}", "a") as out_java_struct:
+ out_java_struct.write("}\n")
with open(sys.argv[4], "w") as out_c:
out_c.write(consts.c_file_pfx)