sys.exit(1)
class TypeInfo:
- def __init__(self, rust_obj, java_ty, java_fn_ty_arg, c_ty, passed_as_ptr, is_ptr, var_name, arr_len, arr_access):
+ def __init__(self, rust_obj, java_ty, java_fn_ty_arg, java_hu_ty, c_ty, passed_as_ptr, is_ptr, var_name, arr_len, arr_access):
self.rust_obj = rust_obj
self.java_ty = java_ty
+ self.java_hu_ty = java_hu_ty
self.java_fn_ty_arg = java_fn_ty_arg
self.c_ty = c_ty
self.passed_as_ptr = passed_as_ptr
self.arr_access = arr_access
class ConvInfo:
- def __init__(self, ty_info, arg_name, arg_conv, arg_conv_name, arg_conv_cleanup, ret_conv, ret_conv_name):
+ def __init__(self, ty_info, arg_name, arg_conv, arg_conv_name, arg_conv_cleanup, ret_conv, ret_conv_name, to_hu_conv, from_hu_conv):
assert(ty_info.c_ty is not None)
assert(ty_info.java_ty is not None)
assert(arg_name is not None)
self.rust_obj = ty_info.rust_obj
self.c_ty = ty_info.c_ty
self.java_ty = ty_info.java_ty
+ self.java_hu_ty = ty_info.java_hu_ty
self.java_fn_ty_arg = ty_info.java_fn_ty_arg
self.arg_name = arg_name
self.arg_conv = arg_conv
self.arg_conv_cleanup = arg_conv_cleanup
self.ret_conv = ret_conv
self.ret_conv_name = ret_conv_name
+ self.to_hu_conv = to_hu_conv
+ self.from_hu_conv = from_hu_conv
def print_ty(self):
out_c.write(self.c_ty)
return (ret + lastchar.lower()).strip("_")
unitary_enums = set()
+opaque_structs = set()
+trait_structs = set()
+
var_is_arr_regex = re.compile("\(\*([A-za-z0-9_]*)\)\[([a-z0-9]*)\]")
var_ty_regex = re.compile("([A-za-z_0-9]*)(.*)")
def java_c_types(fn_arg, ret_arr_len):
take_by_ptr = False
rust_obj = None
arr_access = None
+ java_hu_ty = None
if fn_arg.startswith("LDKThirtyTwoBytes"):
fn_arg = "uint8_t (*" + fn_arg[18:] + ")[32]"
assert var_is_arr_regex.match(fn_arg[8:])
assert var_is_arr_regex.match(fn_arg[8:])
rust_obj = "LDKu8slice"
arr_access = "data"
- if fn_arg.startswith("LDKCVecTempl_u8"):
- fn_arg = "uint8_t (*" + fn_arg[11:] + ")[datalen]"
- assert var_is_arr_regex.match(fn_arg[8:])
- rust_obj = "LDKCVecTempl_u8"
+ if fn_arg.startswith("LDKCVecTempl_u8") or fn_arg.startswith("LDKCVec_u8Z"):
+ if fn_arg.startswith("LDKCVecTempl_u8"):
+ fn_arg = "uint8_t (*" + fn_arg[16:] + ")[datalen]"
+ rust_obj = "LDKCVecTempl_u8"
+ assert var_is_arr_regex.match(fn_arg[8:])
+ else:
+ fn_arg = "uint8_t (*" + fn_arg[12:] + ")[datalen]"
+ rust_obj = "LDKCVec_u8Z"
+ assert var_is_arr_regex.match(fn_arg[8:])
arr_access = "data"
if fn_arg.startswith("void"):
take_by_ptr = True
else:
java_ty = "long"
+ java_hu_ty = ma.group(1).strip().replace("LDK", "")
c_ty = "jlong"
fn_ty_arg = "J"
fn_arg = ma.group(2).strip()
c_ty = c_ty + "Array"
if var_is_arr is not None:
if var_is_arr.group(1) == "":
- return TypeInfo(rust_obj=rust_obj, java_ty=java_ty, java_fn_ty_arg="[" + fn_ty_arg, c_ty=c_ty,
+ return TypeInfo(rust_obj=rust_obj, java_ty=java_ty, java_hu_ty=java_ty, java_fn_ty_arg="[" + fn_ty_arg, c_ty=c_ty,
passed_as_ptr=False, is_ptr=False, var_name="arg", arr_len=var_is_arr.group(2), arr_access=arr_access)
- return TypeInfo(rust_obj=rust_obj, java_ty=java_ty, java_fn_ty_arg="[" + fn_ty_arg, c_ty=c_ty,
+ return TypeInfo(rust_obj=rust_obj, java_ty=java_ty, java_hu_ty=java_ty, java_fn_ty_arg="[" + fn_ty_arg, c_ty=c_ty,
passed_as_ptr=False, is_ptr=False, var_name=var_is_arr.group(1), arr_len=var_is_arr.group(2), arr_access=arr_access)
- return TypeInfo(rust_obj=rust_obj, java_ty=java_ty, java_fn_ty_arg=fn_ty_arg, c_ty=c_ty, passed_as_ptr=is_ptr or take_by_ptr,
+
+ if java_hu_ty is None:
+ java_hu_ty = java_ty
+ return TypeInfo(rust_obj=rust_obj, java_ty=java_ty, java_hu_ty=java_hu_ty, java_fn_ty_arg=fn_ty_arg, c_ty=c_ty, passed_as_ptr=is_ptr or take_by_ptr,
is_ptr=is_ptr, var_name=fn_arg, arr_len=None, arr_access=None)
fn_ptr_regex = re.compile("^extern const ([A-Za-z_0-9\* ]*) \(\*(.*)\)\((.*)\);$")
clone_fns.add(reg_fn.group(2))
else:
rty = java_c_types(reg_fn.group(1), None)
- if rty.rust_obj is not None and reg_fn.group(2) == rty.rust_obj.replace("LDK", "") + "_new":
+ if rty.rust_obj is not None and reg_fn.group(2) == rty.java_hu_ty + "_new":
constructor_fns[rty.rust_obj] = reg_fn.group(3)
continue
arr_fn = fn_ret_arr_regex.match(line)
continue
with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.argv[4], "w") as out_c:
- opaque_structs = set()
- trait_structs = set()
-
def map_type(fn_arg, print_void, ret_arr_len, is_free):
ty_info = java_c_types(fn_arg, ret_arr_len)
if not print_void:
return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
arg_conv = None, arg_conv_name = None, arg_conv_cleanup = None,
- ret_conv = None, ret_conv_name = None)
-
+ ret_conv = None, ret_conv_name = None, to_hu_conv = None, from_hu_conv = None)
if ty_info.c_ty.endswith("Array"):
arr_len = ty_info.arr_len
if arr_len is not None:
ret_conv = (ret_conv[0] + "*", ");")
return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
arg_conv = arg_conv, arg_conv_name = arr_name + "_ref", arg_conv_cleanup = arg_conv_cleanup,
- ret_conv = ret_conv, ret_conv_name = arr_name + "_arr")
+ ret_conv = ret_conv, ret_conv_name = arr_name + "_arr", to_hu_conv = None, from_hu_conv = None)
elif ty_info.var_name != "":
# If we have a parameter name, print it (noting that it may indicate its a pointer)
if ty_info.rust_obj is not None:
opaque_arg_conv = opaque_arg_conv + ty_info.var_name + "_conv.inner = (void*)(" + ty_info.var_name + " & (~1));\n"
opaque_arg_conv = opaque_arg_conv + ty_info.var_name + "_conv.is_owned = (" + ty_info.var_name + " & 1) || (" + ty_info.var_name + " == 0);"
if not ty_info.is_ptr and not is_free:
- if (ty_info.rust_obj.replace("LDK", "") + "_clone") in clone_fns:
+ if (ty_info.java_hu_ty + "_clone") in clone_fns:
# TODO: This is a bit too naive, even with the checks above, we really need to know if rust wants a ref or not, not just if its pass as a ptr.
opaque_arg_conv = opaque_arg_conv + "\nif (" + ty_info.var_name + "_conv.inner != NULL)\n"
- opaque_arg_conv = opaque_arg_conv + "\t" + ty_info.var_name + "_conv = " + ty_info.rust_obj.replace("LDK", "") + "_clone(&" + ty_info.var_name + "_conv);"
+ opaque_arg_conv = opaque_arg_conv + "\t" + ty_info.var_name + "_conv = " + ty_info.java_hu_ty + "_clone(&" + ty_info.var_name + "_conv);"
elif ty_info.passed_as_ptr:
opaque_arg_conv = opaque_arg_conv + "\n// Warning: we may need a move here but can't clone!"
if not ty_info.is_ptr:
arg_conv_name = ty_info.var_name + "_conv",
arg_conv_cleanup = None,
ret_conv = ("jclass " + ty_info.var_name + "_conv = " + ty_info.rust_obj + "_to_java(_env, ", ");"),
- ret_conv_name = ty_info.var_name + "_conv")
+ ret_conv_name = ty_info.var_name + "_conv", to_hu_conv = None, from_hu_conv = None)
if ty_info.rust_obj in opaque_structs:
ret_conv_suf = ";\nCHECK((((long)" + ty_info.var_name + "_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.\n"
ret_conv_suf = ret_conv_suf + "CHECK((((long)&" + ty_info.var_name + "_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.\n"
return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
arg_conv = opaque_arg_conv, arg_conv_name = ty_info.var_name + "_conv", arg_conv_cleanup = None,
ret_conv = (ty_info.rust_obj + " " + ty_info.var_name + "_var = ", ret_conv_suf),
- ret_conv_name = ty_info.var_name + "_ref")
+ ret_conv_name = ty_info.var_name + "_ref", to_hu_conv = ("new " + ty_info.java_hu_ty + "(null, ", ")"),
+ from_hu_conv = (ty_info.var_name + " == null ? 0 : " + ty_info.var_name + ".ptr & ~1", "this.ptrs_to.add(" + ty_info.var_name + ")"))
base_conv = ty_info.rust_obj + " " + ty_info.var_name + "_conv = *(" + ty_info.rust_obj + "*)" + ty_info.var_name + ";";
if ty_info.rust_obj in trait_structs:
if not is_free:
base_conv = base_conv + "\n" + "FREE((void*)" + ty_info.var_name + ");"
return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
arg_conv = base_conv, arg_conv_name = ty_info.var_name + "_conv", arg_conv_cleanup = None,
- ret_conv = ("CANT PASS TRAIT TO Java?", ""), ret_conv_name = "NO CONV POSSIBLE")
+ ret_conv = ("CANT PASS TRAIT TO Java?", ""), ret_conv_name = "NO CONV POSSIBLE",
+ to_hu_conv = ("DUMMY", ""), from_hu_conv = (ty_info.var_name + " == null ? 0 : " + ty_info.var_name + ".ptr", "this.ptrs_to.add(" + ty_info.var_name + ")"))
if ty_info.rust_obj != "LDKu8slice":
# Don't bother free'ing slices passed in - Rust doesn't auto-free the
# underlying unlike Vecs, and it gives Java more freedom.
base_conv = base_conv + "\nFREE((void*)" + ty_info.var_name + ");";
return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
arg_conv = base_conv, arg_conv_name = ty_info.var_name + "_conv", arg_conv_cleanup = None,
- ret_conv = ("long " + ty_info.var_name + "_ref = (long)&", ";"), ret_conv_name = ty_info.var_name + "_ref")
+ ret_conv = ("long " + ty_info.var_name + "_ref = (long)&", ";"), ret_conv_name = ty_info.var_name + "_ref",
+ to_hu_conv = ("TODO 1", ""), from_hu_conv = None)
else:
assert(not is_free)
if ty_info.rust_obj in opaque_structs:
return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
arg_conv = opaque_arg_conv, arg_conv_name = "&" + ty_info.var_name + "_conv", arg_conv_cleanup = None,
- ret_conv = None, ret_conv_name = None) # its a pointer, no conv needed
+ ret_conv = None, ret_conv_name = None, to_hu_conv = ("TODO 2", ""),
+ from_hu_conv = (ty_info.var_name + " == null ? 0 : " + ty_info.var_name + ".ptr & ~1", "this.ptrs_to.add(" + ty_info.var_name + ")")) # its a pointer, no conv needed
+ elif ty_info.rust_obj in trait_structs:
+ return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
+ arg_conv = ty_info.rust_obj + "* " + ty_info.var_name + "_conv = (" + ty_info.rust_obj + "*)" + ty_info.var_name + ";",
+ arg_conv_name = ty_info.var_name + "_conv", arg_conv_cleanup = None,
+ ret_conv = None, ret_conv_name = None, to_hu_conv = ("TODO 2.5", ""),
+ from_hu_conv = (ty_info.var_name + " == null ? 0 : " + ty_info.var_name + ".ptr", "this.ptrs_to.add(" + ty_info.var_name + ")")) # its a pointer, no conv needed
return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
arg_conv = ty_info.rust_obj + "* " + ty_info.var_name + "_conv = (" + ty_info.rust_obj + "*)" + ty_info.var_name + ";",
arg_conv_name = ty_info.var_name + "_conv", arg_conv_cleanup = None,
- ret_conv = None, ret_conv_name = None) # its a pointer, no conv needed
+ ret_conv = None, ret_conv_name = None, to_hu_conv = ("TODO 3", ""), from_hu_conv = None) # its a pointer, no conv needed
elif ty_info.is_ptr:
return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
- arg_conv = None, arg_conv_name = ty_info.var_name, arg_conv_cleanup = None, ret_conv = None, ret_conv_name = None)
+ arg_conv = None, arg_conv_name = ty_info.var_name, arg_conv_cleanup = None,
+ ret_conv = None, ret_conv_name = None, to_hu_conv = ("TODO 4", ""), from_hu_conv = None)
elif ty_info.java_ty == "String":
return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
arg_conv = None, arg_conv_name = None, arg_conv_cleanup = None,
- ret_conv = ("jstring " + ty_info.var_name + "_conv = (*_env)->NewStringUTF(_env, ", ");"), ret_conv_name = ty_info.var_name + "_conv")
+ ret_conv = ("jstring " + ty_info.var_name + "_conv = (*_env)->NewStringUTF(_env, ", ");"), ret_conv_name = ty_info.var_name + "_conv",
+ to_hu_conv = ("TODO 5", ""), from_hu_conv = None)
else:
return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
- arg_conv = None, arg_conv_name = ty_info.var_name, arg_conv_cleanup = None, ret_conv = None, ret_conv_name = None)
+ arg_conv = None, arg_conv_name = ty_info.var_name, arg_conv_cleanup = None,
+ ret_conv = None, ret_conv_name = None, to_hu_conv = ("TODO 6", ""), from_hu_conv = None)
elif not print_void:
# We don't have a parameter name, and want one, just call it arg
if ty_info.rust_obj is not None:
return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
arg_conv = ty_info.rust_obj + " arg_conv = *(" + ty_info.rust_obj + "*)arg;\nFREE((void*)arg);",
arg_conv_name = "arg_conv", arg_conv_cleanup = None,
- ret_conv = None, ret_conv_name = None)
+ ret_conv = None, ret_conv_name = None, to_hu_conv = ("TODO 7", ""), from_hu_conv = None)
else:
assert(not is_free)
return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
- arg_conv = None, arg_conv_name = "arg", arg_conv_cleanup = None, ret_conv = None, ret_conv_name = None)
+ arg_conv = None, arg_conv_name = "arg", arg_conv_cleanup = None,
+ ret_conv = None, ret_conv_name = None, to_hu_conv = ("TODO 8", ""), from_hu_conv = None)
else:
# We don't have a parameter name, and don't want one (cause we're returning)
if ty_info.rust_obj is not None:
return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
arg_conv = ty_info.rust_obj + " ret = " + ty_info.rust_obj + "_from_java(_env, " + ty_info.var_name + ");",
arg_conv_name = "ret", arg_conv_cleanup = None,
- ret_conv = ("jclass ret = " + ty_info.rust_obj + "_to_java(_env, ", ");"), ret_conv_name = "ret")
+ ret_conv = ("jclass ret = " + ty_info.rust_obj + "_to_java(_env, ", ");"), ret_conv_name = "ret",
+ to_hu_conv = ("TODO 9", ""), from_hu_conv = None)
if ty_info.rust_obj in opaque_structs:
# If we're returning a newly-allocated struct, we don't want Rust to ever
# free, instead relying on the Java GC to lose the ref. We undo this in
return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
ret_conv = (ty_info.rust_obj + " ret = ", ";"),
ret_conv_name = "((long)ret.inner) | (ret.is_owned ? 1 : 0)",
- arg_conv = None, arg_conv_name = None, arg_conv_cleanup = None)
+ arg_conv = None, arg_conv_name = None, arg_conv_cleanup = None,
+ to_hu_conv = ("new " + ty_info.java_hu_ty + "(null, ", ")"), from_hu_conv = None)
+ elif ty_info.rust_obj in trait_structs:
+ return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
+ ret_conv = (ty_info.rust_obj + "* ret = MALLOC(sizeof(" + ty_info.rust_obj + "), \"" + ty_info.rust_obj + "\");\n*ret = ", ";"),
+ ret_conv_name = "(long)ret",
+ arg_conv = None, arg_conv_name = None, arg_conv_cleanup = None,
+ to_hu_conv = ("new " + ty_info.java_hu_ty + "(null, ", ");\nret.ptrs_to.add(this)"), from_hu_conv = None)
else:
return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
ret_conv = (ty_info.rust_obj + "* ret = MALLOC(sizeof(" + ty_info.rust_obj + "), \"" + ty_info.rust_obj + "\");\n*ret = ", ";"),
ret_conv_name = "(long)ret",
- arg_conv = None, arg_conv_name = None, arg_conv_cleanup = None)
+ arg_conv = None, arg_conv_name = None, arg_conv_cleanup = None,
+ to_hu_conv = ("TODO b", ""), from_hu_conv = None)
+ elif ty_info.rust_obj in trait_structs:
+ return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
+ ret_conv = ("long ret = (long)", ";"), ret_conv_name = "ret",
+ arg_conv = None, arg_conv_name = None, arg_conv_cleanup = None,
+ to_hu_conv = ("new " + ty_info.java_hu_ty + "(null, ", ");\nret.ptrs_to.add(this)"), from_hu_conv = None)
else:
return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
ret_conv = ("long ret = (long)", ";"), ret_conv_name = "ret",
- arg_conv = None, arg_conv_name = None, arg_conv_cleanup = None)
+ arg_conv = None, arg_conv_name = None, arg_conv_cleanup = None,
+ to_hu_conv = ("TODO c", ""), from_hu_conv = None)
else:
return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name,
- arg_conv = None, arg_conv_name = None, arg_conv_cleanup = None, ret_conv = None, ret_conv_name = None)
+ arg_conv = None, arg_conv_name = None, arg_conv_cleanup = None,
+ ret_conv = None, ret_conv_name = None,
+ to_hu_conv = None, from_hu_conv = None)
def map_fn(line, re_match, ret_arr_len, c_call_string):
out_java.write("\t// " + line)
meth_n = re_match.group(2)[len(struct_meth) + 1:]
if ret_info.rust_obj == "LDK" + struct_meth:
out_java_struct.write(struct_meth + "(")
- elif ret_info.rust_obj in opaque_structs or ret_info.rust_obj in trait_structs:
- out_java_struct.write(ret_info.rust_obj.replace("LDK", "") + " " + meth_n + "(")
else:
- out_java_struct.write(ret_info.java_ty + " " + meth_n + "(")
+ out_java_struct.write(ret_info.java_hu_ty + " " + meth_n + "(")
for idx, arg in enumerate(arg_names):
if idx != 0:
if not takes_self or idx > 1:
if explode_idx != 0:
out_java_struct.write(", ")
assert explode_arg.rust_obj in opaque_structs or explode_arg.rust_obj in trait_structs
- out_java_struct.write(explode_arg.rust_obj.replace("LDK", "") + " " + arg.arg_name + "_" + explode_arg.arg_name)
- elif arg.passed_as_ptr:
- if arg.rust_obj in opaque_structs or arg.rust_obj in trait_structs:
- out_java_struct.write(arg.rust_obj.replace("LDK", "") + " " + arg.arg_name)
- else:
- out_java_struct.write(arg.rust_obj + " " + arg.arg_name)
+ out_java_struct.write(explode_arg.java_hu_ty + " " + arg.arg_name + "_" + explode_arg.arg_name)
else:
- out_java_struct.write(arg.java_ty + " " + arg.arg_name)
+ out_java_struct.write(arg.java_hu_ty + " " + arg.arg_name)
out_java.write(");\n")
elif ret_info.java_ty != "void" and not ret_info.passed_as_ptr:
out_java_struct.write(ret_info.java_ty + " ret = ")
elif ret_info.java_ty != "void":
- out_java_struct.write(ret_info.rust_obj.replace("LDK", "") + " ret = ")
- if ret_info.rust_obj in opaque_structs or ret_info.rust_obj in trait_structs:
- out_java_struct.write("new " + ret_info.rust_obj.replace("LDK", "") + "(null, ")
+ out_java_struct.write(ret_info.java_hu_ty + " ret = ")
+ if ret_info.to_hu_conv is not None:
+ out_java_struct.write(ret_info.to_hu_conv[0])
out_java_struct.write("bindings." + re_match.group(2) + "(")
for idx, info in enumerate(arg_names):
if idx != 0:
if info.arg_name == "this_arg":
out_java_struct.write("this.ptr")
elif info.arg_name in default_constructor_args:
- out_java_struct.write("bindings." + info.rust_obj.replace("LDK", "") + "_new(")
+ out_java_struct.write("bindings." + info.java_hu_ty + "_new(")
for explode_idx, explode_arg in enumerate(default_constructor_args[info.arg_name]):
if explode_idx != 0:
out_java_struct.write(", ")
- assert explode_arg.passed_as_ptr and explode_arg.rust_obj in trait_structs
expl_arg_name = info.arg_name + "_" + explode_arg.arg_name
- out_java_struct.write(expl_arg_name + " == null ? 0 : " + expl_arg_name + ".ptr")
+ out_java_struct.write(explode_arg.from_hu_conv[0].replace(explode_arg.arg_name, expl_arg_name))
out_java_struct.write(")")
- elif info.passed_as_ptr and info.rust_obj in opaque_structs:
- out_java_struct.write(info.arg_name + " == null ? 0 : " + info.arg_name + ".ptr & ~1")
- elif info.passed_as_ptr and info.rust_obj in trait_structs:
- out_java_struct.write(info.arg_name + " == null ? 0 : " + info.arg_name + ".ptr")
+ elif info.from_hu_conv is not None:
+ out_java_struct.write(info.from_hu_conv[0])
else:
out_java_struct.write(info.arg_name)
out_java_struct.write(")")
- if ret_info.rust_obj == "LDK" + struct_meth:
- out_java_struct.write(");\n")
- elif ret_info.rust_obj in opaque_structs:
- out_java_struct.write(");\n")
- elif ret_info.rust_obj in trait_structs:
- out_java_struct.write(");\n\t\tret.ptrs_to.add(this);\n")
+ if ret_info.to_hu_conv is not None:
+ out_java_struct.write(ret_info.to_hu_conv[1].replace("\n", "\n\t\t") + ";\n")
else:
out_java_struct.write(";\n")
pass
elif info.arg_name in default_constructor_args:
for explode_arg in default_constructor_args[info.arg_name]:
- out_java_struct.write("\t\tthis.ptrs_to.add(" + info.arg_name + "_" + explode_arg.arg_name + ");\n")
- elif info.passed_as_ptr and (info.rust_obj in opaque_structs or info.rust_obj in trait_structs):
- out_java_struct.write("\t\tthis.ptrs_to.add(" + info.arg_name + ");\n")
+ expl_arg_name = info.arg_name + "_" + explode_arg.arg_name
+ out_java_struct.write("\t\t" + explode_arg.from_hu_conv[1].replace(explode_arg.arg_name, expl_arg_name) + ";\n")
+ elif info.from_hu_conv is not None and info.from_hu_conv[1] != "":
+ out_java_struct.write("\t\t" + info.from_hu_conv[1] + ";\n")
if ret_info.java_ty != "void" and ret_info.rust_obj != "LDK" + struct_meth:
out_java_struct.write("\t\treturn ret;\n")
out_c.write("\t" + struct_name + "_" + var_name + "_meth = (*env)->GetMethodID(env, " + struct_name + "_" + var_name + "_class, \"<init>\", \"(" + init_meth_jty_strs[var_name] + ")V\");\n")
out_c.write("\tCHECK(" + struct_name + "_" + var_name + "_meth != NULL);\n")
out_c.write("}\n")
- out_c.write("JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_" + struct_name.replace("_", "_1") + "_1ref_1from_1ptr (JNIEnv * env, jclass _c, jlong ptr) {\n")
+ out_c.write("JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_" + struct_name.replace("_", "_1") + "_1ref_1from_1ptr (JNIEnv * _env, jclass _c, jlong ptr) {\n")
out_c.write("\t" + struct_name + " *obj = (" + struct_name + "*)ptr;\n")
out_c.write("\tswitch(obj->tag) {\n")
for idx, struct_line in enumerate(tag_field_lines):
if idx != 0 and idx < len(enum_var_lines) - 2:
field_map = map_type(field.strip(' ;'), False, None, False)
if field_map.ret_conv is not None:
- out_c.write("\t\t\t" + field_map.ret_conv[0].replace("\n", "\n\t\t\t").replace("_env", "env"))
+ out_c.write("\t\t\t" + field_map.ret_conv[0].replace("\n", "\n\t\t\t"))
out_c.write("obj->" + camel_to_snake(var_name) + "." + field_map.arg_name)
out_c.write(field_map.ret_conv[1].replace("\n", "\n\t\t\t") + "\n")
c_params_text = c_params_text + ", " + field_map.ret_conv_name
else:
c_params_text = c_params_text + ", obj->" + camel_to_snake(var_name) + "." + field_map.arg_name
- out_c.write("\t\t\treturn (*env)->NewObject(env, " + struct_name + "_" + var_name + "_class, " + struct_name + "_" + var_name + "_meth" + c_params_text + ");\n")
+ out_c.write("\t\t\treturn (*_env)->NewObject(_env, " + struct_name + "_" + var_name + "_class, " + struct_name + "_" + var_name + "_meth" + c_params_text + ");\n")
out_c.write("\t\t}\n")
out_c.write("\t\tdefault: abort();\n")
out_c.write("\t}\n}\n")
out_java_trait.write("import org.ldk.enums.*;\n\n")
out_java_trait.write("public class " + struct_name.replace("LDK","") + " extends CommonBase {\n")
out_java_trait.write("\t" + struct_name.replace("LDK", "") + "(Object _dummy, long ptr) { super(ptr); }\n")
- out_java_trait.write("\tpublic " + struct_name.replace("LDK", "") + "(bindings." + struct_name + " arg")
+ out_java_trait.write("\tpublic " + struct_name.replace("LDK", "") + "(bindings." + struct_name + " arg") # XXX: Should be priv
for var_line in field_var_lines:
if var_line.group(1) in trait_structs:
out_java_trait.write(", bindings." + var_line.group(1) + " " + var_line.group(2))
for fn_line in trait_fn_lines:
java_meth_descr = "("
if fn_line.group(2) != "free" and fn_line.group(2) != "clone":
- ret_ty_info = java_c_types(fn_line.group(1), None)
+ ret_ty_info = map_type(fn_line.group(1), True, None, False)
out_java.write("\t\t " + ret_ty_info.java_ty + " " + fn_line.group(2) + "(")
is_const = fn_line.group(3) is not None
out_java.write(");\n")
out_c.write(") {\n")
out_c.write("\t" + struct_name + "_JCalls *j_calls = (" + struct_name + "_JCalls*) this_arg;\n")
- out_c.write("\tJNIEnv *env;\n")
- out_c.write("\tDO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_8) == JNI_OK);\n")
+ out_c.write("\tJNIEnv *_env;\n")
+ out_c.write("\tDO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&_env, JNI_VERSION_1_8) == JNI_OK);\n")
for arg_info in arg_names:
if arg_info.ret_conv is not None:
- out_c.write("\t" + arg_info.ret_conv[0].replace('\n', '\n\t').replace("_env", "env"));
+ out_c.write("\t" + arg_info.ret_conv[0].replace('\n', '\n\t'));
out_c.write(arg_info.arg_name)
- out_c.write(arg_info.ret_conv[1].replace('\n', '\n\t').replace("_env", "env") + "\n")
+ out_c.write(arg_info.ret_conv[1].replace('\n', '\n\t') + "\n")
- out_c.write("\tjobject obj = (*env)->NewLocalRef(env, j_calls->o);\n\tCHECK(obj != NULL);\n")
+ out_c.write("\tjobject obj = (*_env)->NewLocalRef(_env, j_calls->o);\n\tCHECK(obj != NULL);\n")
if ret_ty_info.c_ty.endswith("Array"):
assert(ret_ty_info.c_ty == "jbyteArray")
- out_c.write("\tjbyteArray jret = (*env)->CallObjectMethod(env, obj, j_calls->" + fn_line.group(2) + "_meth")
+ out_c.write("\tjbyteArray ret = (*_env)->CallObjectMethod(_env, obj, j_calls->" + fn_line.group(2) + "_meth")
elif not ret_ty_info.passed_as_ptr:
- out_c.write("\treturn (*env)->Call" + ret_ty_info.java_ty.title() + "Method(env, obj, j_calls->" + fn_line.group(2) + "_meth")
+ out_c.write("\treturn (*_env)->Call" + ret_ty_info.java_ty.title() + "Method(_env, obj, j_calls->" + fn_line.group(2) + "_meth")
else:
- out_c.write("\t" + fn_line.group(1).strip() + "* ret = (" + fn_line.group(1).strip() + "*)(*env)->CallLongMethod(env, obj, j_calls->" + fn_line.group(2) + "_meth");
+ out_c.write("\t" + fn_line.group(1).strip() + "* ret = (" + fn_line.group(1).strip() + "*)(*_env)->CallLongMethod(_env, obj, j_calls->" + fn_line.group(2) + "_meth");
for arg_info in arg_names:
if arg_info.ret_conv is not None:
else:
out_c.write(", " + arg_info.arg_name)
out_c.write(");\n");
- if ret_ty_info.c_ty.endswith("Array"):
- out_c.write("\t" + ret_ty_info.rust_obj + " ret;\n")
- out_c.write("\tCHECK((*env)->GetArrayLength(env, jret) == " + ret_ty_info.arr_len + ");\n")
- out_c.write("\t(*env)->GetByteArrayRegion(env, jret, 0, " + ret_ty_info.arr_len + ", ret." + ret_ty_info.arr_access + ");\n")
- out_c.write("\treturn ret;\n")
+ if ret_ty_info.arg_conv is not None:
+ out_c.write("\t" + ret_ty_info.arg_conv.replace("\n", "\n\t").replace("arg", "ret") + "\n\treturn " + ret_ty_info.arg_conv_name.replace("arg", "ret") + ";\n")
if ret_ty_info.passed_as_ptr:
out_c.write("\t" + fn_line.group(1).strip() + " res = *ret;\n")
out_c.write("\n\tret->" + e + " = " + ty_info.arg_conv_name + ";\n")
else:
out_c.write("\tret->" + e + " = " + e + ";\n")
- assert ty_info.arg_conv_cleanup is None
+ if ty_info.arg_conv_cleanup is not None:
+ out_c.write("\t//TODO: Really need to call " + ty_info.arg_conv_cleanup + " here\n")
out_c.write("\treturn (long)ret;\n")
out_c.write("}\n")
elif vec_ty is not None:
projects / ldk-java / blobdiff