arr_ty = "uint64_t"
fn_arg = fn_arg[8:].strip()
else:
- java_ty = consts.ptr_native_ty
- c_ty = consts.ptr_c_ty
+ 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()
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(uintptr_t ptr) {\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\treturn (void*)(ptr & ~1);\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}\n")
write_c("}\n")
-write_c("static inline bool ptr_is_owned(uintptr_t ptr) {\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 & 1) ? true : false;\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("\t}\n")
write_c("}\n")
-write_c("static inline uintptr_t tag_ptr(const void* ptr, bool is_owned) {\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 ((uintptr_t)ptr) | (is_owned ? 1 : 0);\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")
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].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 = False
takes_self_ptr = False
- args_known = True
for argument_index, argument in enumerate(method_arguments):
arg_ty = type_mapping_generator.java_c_types(argument, None)
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(','):
+ for explode_idx, explode_arg in enumerate(constructor_fns[argument_conversion_info.rust_obj].split(',')):
explode_arg_conv = type_mapping_generator.map_type(explode_arg, False, None, False, True)
+ if explode_idx == 0 and explode_arg_conv.c_ty == "void":
+ continue # (void) is C lingo for "no arguments)
if explode_arg_conv.c_ty == "void":
- # We actually want to handle this case, but for now its only used in NetGraphMsgHandler::new()
- # which ends up resulting in a redundant constructor - both without arguments for the NetworkGraph.
- args_known = False
- pass
+ assert False
if not argument_conversion_info.arg_name in default_constructor_args:
default_constructor_args[argument_conversion_info.arg_name] = []
default_constructor_args[argument_conversion_info.arg_name].append(explode_arg_conv)
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("TxOut") and not method_name.startswith("BigEndianScalar") and
not method_name.startswith("_") and
method_name != "check_platform" and method_name != "Result_read" and
not expected_struct in unitary_enums and
arg.from_hu_conv = (arg.from_hu_conv[0], "")
out_java.write("\t// " + line)
+ args_known = True # We no longer ever set this to false
(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)
out_java.write(out_java_delta)
else:
(nullable_params, ret_nullable) = doc_to_params_ret_nullable(fn_docs)
if ret_nullable:
- assert False # This isn't yet handled on the Java side
- ret_ty_info.nullable = True
ret_ty_info = type_mapping_generator.map_nullable_type(fn_line.group(2).strip() + " ret", True, None, False, False)
+ ret_ty_info.nullable = True
else:
ret_ty_info = type_mapping_generator.map_type(fn_line.group(2).strip() + " ret", True, None, False, False)
is_const = fn_line.group(4) is not None
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("\treturn thing->value;")
write_c("}")
map_fn(fn_line + "\n", re.compile("(.*) (TxOut_get_value) \((.*)\)").match(fn_line), None, None, None)
+ elif struct_name == "LDKBigEndianScalar":
+ with open(f"{sys.argv[3]}/structs/BigEndianScalar{consts.file_ext}", "w") as out_java_struct:
+ out_java_struct.write(consts.hu_struct_file_prefix)
+ out_java_struct.write(consts.scalar_defn)
+ fn_line = "struct LDKThirtyTwoBytes BigEndianScalar_get_bytes (struct LDKBigEndianScalar* thing)"
+ write_c(fn_line + " {\n")
+ write_c("\tLDKThirtyTwoBytes ret = { .data = *thing->big_endian_bytes };\n")
+ write_c("\treturn ret;\n")
+ write_c("}\n")
+ map_fn(fn_line + "\n", re.compile("(.*) (BigEndianScalar_get_bytes) \((.*)\)").match(fn_line), None, None, None)
+
+ # We need to be able to FREE a heap-allocated BigEndianScalar, but because
+ # there's nothing heap-allocated inside it the C bindings don't bother
+ # exposing a `_free` method. Instead, we have to manually write one here,
+ # though it doesn't need to do anything, the autogenerated wrapper will do
+ # the required FREE.
+ fn_line = "static void BigEndianScalar_free (struct LDKBigEndianScalar thing)"
+ write_c(fn_line + " {}\n")
+ map_fn(fn_line + "\n", re.compile("static (.*) (BigEndianScalar_free) \((.*)\)").match(fn_line), None, None, None)
else:
- pass # Everything remaining is a byte[] or some form
+ pass # Everything remaining is a byte[] of some form
cur_block_obj = None
else:
fn_ptr = fn_ptr_regex.match(line)
projects / ldk-java / blobdiff