rust_obj = None
arr_access = None
java_hu_ty = None
- if fn_arg.startswith("LDKThirtyTwoBytes"):
+ if fn_arg.startswith("LDKPaymentPreimage") or fn_arg.startswith("LDKPaymentSecret") or fn_arg.startswith("LDKPaymentHash"):
+ if fn_arg.startswith("LDKPaymentPreimage"):
+ fn_arg = "uint8_t (*" + fn_arg[19:] + ")[32]"
+ elif fn_arg.startswith("LDKPaymentSecret"):
+ fn_arg = "uint8_t (*" + fn_arg[17:] + ")[32]"
+ elif fn_arg.startswith("LDKPaymentHash"):
+ fn_arg = "uint8_t (*" + fn_arg[15:] + ")[32]"
+ assert var_is_arr_regex.match(fn_arg[8:])
+ rust_obj = "LDKThirtyTwoBytes"
+ arr_access = "data"
+ elif fn_arg.startswith("LDKThirtyTwoBytes"):
fn_arg = "uint8_t (*" + fn_arg[18:] + ")[32]"
assert var_is_arr_regex.match(fn_arg[8:])
rust_obj = "LDKThirtyTwoBytes"
arr_ty = "uint8_t"
fn_arg = fn_arg[7:].strip()
is_primitive = True
- elif fn_arg.startswith("LDKu5"):
+ elif fn_arg.startswith("LDKu5") or fn_arg.startswith("LDKWitnessVersion"):
java_ty = consts.c_type_map['uint8_t'][0]
- java_hu_ty = "UInt5"
- rust_obj = "LDKu5"
+ if fn_arg.startswith("LDKu5"):
+ java_hu_ty = "UInt5"
+ rust_obj = "LDKu5"
+ fn_arg = fn_arg[6:].strip()
+ else:
+ java_hu_ty = "WitnessVersion"
+ rust_obj = "LDKWitnessVersion"
+ fn_arg = fn_arg[18:].strip()
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]
arr_ty = "uint64_t"
fn_arg = fn_arg[8:].strip()
else:
- java_ty = consts.ptr_native_ty
- c_ty = "intptr_t"
+ java_ty = consts.usize_native_ty
+ c_ty = consts.usize_c_ty
arr_ty = "uintptr_t"
rust_obj = "uintptr_t"
fn_arg = fn_arg[9:].strip()
fn_arg = fn_arg[6:].strip()
arr_access = "chars"
arr_len = "len"
+ elif fn_arg.startswith("LDKError ") or fn_arg == "LDKError":
+ java_ty = consts.c_type_map['uint32_t'][0]
+ java_hu_ty = "UnqualifiedError"
+ rust_obj = "LDKError"
+ c_ty = "int32_t"
+ arr_ty = "uint32_t"
+ fn_ty_arg = "I"
+ fn_arg = fn_arg[8:].strip()
else:
ma = var_ty_regex.match(fn_arg)
arr_ty = ma.group(1).strip()
# Define some manual clones...
clone_fns.add("ThirtyTwoBytes_clone")
-write_c("static inline struct LDKThirtyTwoBytes ThirtyTwoBytes_clone(const struct LDKThirtyTwoBytes *orig) { struct LDKThirtyTwoBytes ret; memcpy(ret.data, orig->data, 32); return ret; }\n")
+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")
+
+
+write_c("static inline void* untag_ptr(uint64_t ptr) {\n")
+write_c("\tif (ptr < 4096) return (void*)ptr;\n")
+write_c("\tif (sizeof(void*) == 4) {\n")
+write_c("\t\t// For 32-bit systems, store pointers as 64-bit ints and use the 31st bit\n")
+write_c("\t\treturn (void*)(uintptr_t)ptr;\n")
+write_c("\t} else {\n")
+write_c("\t\t// For 64-bit systems, assume the top byte is used for tagging, then\n")
+write_c("\t\t// use bit 9 ^ bit 10.\n")
+write_c("\t\tuint64_t tenth_bit = (((uintptr_t)ptr) & (1ULL << 54)) >> 54;\n")
+write_c("\t\tuintptr_t p = (ptr & ~(1ULL << 55)) | (tenth_bit << 55);\n")
+write_c("#ifdef LDK_DEBUG_BUILD\n")
+write_c("\t\t// On debug builds we also use the 11th bit as a debug flag\n")
+write_c("\t\tuintptr_t eleventh_bit = (((uintptr_t)ptr) & (1ULL << 53)) >> 53;\n")
+write_c("\t\tCHECK(tenth_bit != eleventh_bit);\n")
+write_c("\t\tp ^= 1ULL << 53;\n")
+write_c("#endif\n")
+write_c("\t\treturn (void*)p;\n")
+write_c("\t}\n")
+write_c("}\n")
+
+write_c("static inline bool ptr_is_owned(uint64_t ptr) {\n")
+write_c("\tif(ptr < 4096) return true;\n")
+write_c("\tif (sizeof(void*) == 4) {\n")
+write_c("\t\treturn ptr & (1ULL << 32);\n")
+write_c("\t} else {\n")
+write_c("\t\tuintptr_t ninth_bit = (((uintptr_t)ptr) & (1ULL << 55)) >> 55;\n")
+write_c("\t\tuintptr_t tenth_bit = (((uintptr_t)ptr) & (1ULL << 54)) >> 54;\n")
+write_c("#ifdef LDK_DEBUG_BUILD\n")
+write_c("\t\t// On debug builds we also use the 11th bit as a debug flag\n")
+write_c("\t\tuintptr_t eleventh_bit = (((uintptr_t)ptr) & (1ULL << 53)) >> 53;\n")
+write_c("\t\tCHECK(tenth_bit != eleventh_bit);\n")
+write_c("#endif\n")
+write_c("\t\treturn (ninth_bit ^ tenth_bit) ? true : false;\n")
+write_c("\t}\n")
+write_c("}\n")
+
+write_c("static inline uint64_t tag_ptr(const void* ptr, bool is_owned) {\n")
+write_c("\tif ((uintptr_t)ptr < 4096) return (uint64_t)ptr;\n")
+write_c("\tif (sizeof(void*) == 4) {\n")
+write_c("\t\treturn (((uint64_t)ptr) | ((is_owned ? 1ULL : 0) << 32));\n")
+write_c("\t} else {\n")
+write_c("\t\tCHECK(sizeof(uintptr_t) == 8);\n")
+write_c("\t\tuintptr_t tenth_bit = (((uintptr_t)ptr) & (1ULL << 54)) >> 54;\n")
+write_c("\t\tuintptr_t t = (((uintptr_t)ptr) | (((is_owned ? 1ULL : 0ULL) ^ tenth_bit) << 55));\n")
+write_c("#ifdef LDK_DEBUG_BUILD\n")
+write_c("\t\tuintptr_t ninth_bit = (((uintptr_t)ptr) & (1ULL << 55)) >> 55;\n")
+write_c("\t\tuintptr_t eleventh_bit = (((uintptr_t)ptr) & (1ULL << 53)) >> 53;\n")
+write_c("\t\tCHECK(ninth_bit == tenth_bit);\n")
+write_c("\t\tCHECK(ninth_bit == eleventh_bit);\n")
+write_c("\t\tt ^= 1ULL << 53;\n")
+write_c("#endif\n")
+write_c("\t\tCHECK(ptr_is_owned(t) == is_owned);\n")
+write_c("\t\tCHECK(untag_ptr(t) == ptr);\n")
+#write_c("\t\tCHECK(untag_ptr((uintptr_t)untag_ptr(t)) == ptr);\n")
+write_c("\t\treturn t;\n")
+write_c("\t}\n")
+write_c("}\n\n")
java_c_types_none_allowed = False # C structs created by cbindgen are declared in dependency order
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)"
+ meth_line = "uint64_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(return_type_info.ret_conv[1].replace("\n", "\n\t"))
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)
+ map_fn(meth_line + ";\n", re.compile("(uint64_t) ([A-Za-z_0-9]*)\((.*)\)").match(meth_line), None, None, None)
argument_types = []
default_constructor_args = {}
takes_self_ptr = True
elif arg_ty.var_name in params_nullable:
argument_conversion_info = type_mapping_generator.map_type_with_info(arg_ty, False, None, is_free, True, True)
- if argument_conversion_info.arg_conv is not None and "Warning" in argument_conversion_info.arg_conv:
+ if argument_conversion_info.arg_conv is not None and "WARNING" in argument_conversion_info.arg_conv:
arg_ty_info = java_c_types(argument, None)
print("WARNING: Remapping argument " + arg_ty_info.var_name + " of function " + method_name + " to a reference")
print(" The argument appears to require a move, or not clonable, and is nullable.")
arg_ty_info.requires_clone = False
argument_conversion_info = type_mapping_generator.map_type_with_info(arg_ty_info, False, None, is_free, True, True)
assert argument_conversion_info.nullable
- assert argument_conversion_info.arg_conv is not None and "Warning" not in argument_conversion_info.arg_conv
+ assert argument_conversion_info.arg_conv is not None and "WARNING" not in argument_conversion_info.arg_conv
else:
argument_conversion_info = type_mapping_generator.map_type_with_info(arg_ty, False, None, is_free, True, False)
- if argument_conversion_info.arg_conv is not None and "Warning" in argument_conversion_info.arg_conv:
+ if argument_conversion_info.arg_conv is not None and "WARNING" in argument_conversion_info.arg_conv:
if argument_conversion_info.rust_obj in constructor_fns:
assert not is_free
for explode_arg in constructor_fns[argument_conversion_info.rust_obj].split(','):
assert return_type_info.c_ty == "void"
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")
if argument_types[0].ty_info.passed_as_ptr and not argument_types[0].ty_info.rust_obj in opaque_structs:
- write_c("\tif ((" + argument_types[0].ty_info.var_name + " & 1) != 0) return;\n")
+ write_c("\tif (!ptr_is_owned(" + argument_types[0].ty_info.var_name + ")) return;\n")
for info in argument_types:
if info.arg_conv is not None:
elif camel_to_snake(variant_name) in inline_enum_variants:
# TODO: If we ever have a rust enum Variant(Option<Struct>) we need to pipe
# docs through to there, and then potentially mark the field nullable.
- mapped = type_mapping_generator.map_type(inline_enum_variants[camel_to_snake(variant_name)] + " " + camel_to_snake(variant_name), False, None, False, True)
+ (variant_info, variant_field_docs) = inline_enum_variants[camel_to_snake(variant_name)]
+ variant_ty_text = variant_info + " " + camel_to_snake(variant_name)
+ variant_ty_info = type_mapping_generator.java_c_types(variant_ty_text, None)
+ if variant_field_docs is not None and doc_to_field_nullable(variant_field_docs):
+ mapped = type_mapping_generator.map_type_with_info(variant_ty_info, False, None, False, True, True)
+ else:
+ mapped = type_mapping_generator.map_type_with_info(variant_ty_info, False, None, False, True, False)
contains_trait |= mapped.ty_info.contains_trait
fields.append((mapped, None))
enum_variants.append(ComplexEnumVariantInfo(variant_name, variant_docs, fields, True))
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:
+ if field_ty.rust_obj is not None and field_ty.rust_obj in opaque_structs:
+ fn_defn = owned_fn_defn
+ write_c("static inline " + fn_defn + "{\n")
+ write_c("\t" + field_ty.rust_obj + " ret = " + accessor[0] + "owner" + accessor[1] + ";\n")
+ write_c("\tret.is_owned = false;\n")
+ write_c("\treturn ret;\n")
+ elif field_ty.rust_obj is not None and field_ty.rust_obj.replace("LDK", "") + "_clone" in clone_fns:
fn_defn = owned_fn_defn
write_c("static inline " + fn_defn + "{\n")
if check_sfx is not None:
write_c("\tmemcpy(ret.data, orig->data, sizeof(" + ty_info.c_ty + ") * ret.datalen);\n")
write_c("\treturn ret;\n}\n")
elif (ty_info.rust_obj.replace("LDK", "") + "_clone") in clone_fns:
- ty_name = "CVec_" + ty_info.rust_obj.replace("LDK", "") + "Z";
+ ty_name = struct_name.replace("LDK", "")
clone_fns.add(ty_name + "_clone")
write_c("static inline " + struct_name + " " + ty_name + "_clone(const " + struct_name + " *orig) {\n")
write_c("\t" + struct_name + " ret = { .data = MALLOC(sizeof(" + ty_info.rust_obj + ") * orig->datalen, \"" + struct_name + " clone bytes\"), .datalen = orig->datalen };\n")
elif struct_name in union_enum_items:
tuple_variants = {}
elem_items = -1
- for line, _ in field_lines:
+ for line, field_block_comment in field_lines:
if line == " struct {":
elem_items = 0
elif line == " };":
line = line[5:]
split = line.split(" ")
assert len(split) == 2
- tuple_variants[split[1].strip(";")] = split[0]
+ tuple_variants[split[1].strip(";")] = (split[0], field_block_comment)
elem_items += 1
if elem_items > 1:
# We don't currently support tuple variant with more than one element