sys.exit(1)
target = None
-if sys.argv[6] == "java":
+if sys.argv[6] == "java" or sys.argv[6] == "android":
+ import java_strings
from java_strings import Consts
+ target = java_strings.Target.JAVA
+ if sys.argv[6] == "android":
+ target = java_strings.Target.ANDROID
elif sys.argv[6] == "typescript":
import typescript_strings
from typescript_strings import Consts
c_ty = "int64_t"
fn_arg = fn_arg[8:].strip()
else:
- c_ty = "intptr_t"
+ c_ty = "int64_t"
+ rust_obj = "uintptr_t"
fn_arg = fn_arg[9:].strip()
is_primitive = True
elif is_const and fn_arg.startswith("char *"):
c_ty = consts.ptr_c_ty
java_ty = consts.ptr_native_ty
fn_ty_arg = "J"
- is_primitive = False
var_is_arr = var_is_arr_regex.match(fn_arg)
if var_is_arr is not None or ret_arr_len is not None:
clone_fns.add(reg_fn.group(2))
else:
rty = java_c_types(reg_fn.group(1), None)
- if rty is not None and rty.rust_obj is not None and reg_fn.group(2) == rty.java_hu_ty + "_new":
+ if rty is not None and not rty.is_native_primitive 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)
with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java:
# Map a top-level function
- def map_fn(line, re_match, ret_arr_len, c_call_string):
+ def map_fn(line, re_match, ret_arr_len, c_call_string, doc_comment):
method_return_type = re_match.group(1)
method_name = re_match.group(2)
method_comma_separated_arguments = re_match.group(3)
argument_types.append(argument_conversion_info)
out_java.write("\t// " + line)
- (out_java_delta, out_c_delta, out_java_struct_delta) = consts.map_function(argument_types, c_call_string, method_name, return_type_info, struct_meth, default_constructor_args, takes_self, args_known, type_mapping_generator)
+ (out_java_delta, out_c_delta, out_java_struct_delta) = \
+ consts.map_function(argument_types, c_call_string, method_name, return_type_info, struct_meth, default_constructor_args, takes_self, args_known, type_mapping_generator, doc_comment)
out_java.write(out_java_delta)
if is_free:
else:
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:
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]
+ 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)
- def map_unitary_enum(struct_name, field_lines):
+ def map_unitary_enum(struct_name, field_lines, enum_doc_comment):
with open(f"{sys.argv[3]}/enums/{struct_name}{consts.file_ext}", "w") as out_java_enum:
unitary_enums.add(struct_name)
for idx, struct_line in enumerate(field_lines):
assert(struct_line == "} %s;" % struct_name)
elif idx == len(field_lines) - 1:
assert(struct_line == "")
- (c_out, native_file_out, native_out) = consts.native_c_unitary_enum_map(struct_name, [x.strip().strip(",") for x in field_lines[1:-3]])
+ (c_out, native_file_out, native_out) = consts.native_c_unitary_enum_map(struct_name, [x.strip().strip(",") for x in field_lines[1:-3]], enum_doc_comment)
write_c(c_out)
out_java_enum.write(native_file_out)
out_java.write(native_out)
- def map_complex_enum(struct_name, union_enum_items):
+ def map_complex_enum(struct_name, union_enum_items, enum_doc_comment):
java_hu_type = struct_name.replace("LDK", "")
complex_enums.add(struct_name)
enum_variants.append(ComplexEnumVariantInfo(variant_name, fields))
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)
+ (out_java_addendum, out_java_enum_addendum, out_c_addendum) = consts.map_complex_enum(struct_name, enum_variants, camel_to_snake, enum_doc_comment)
out_java_enum.write(out_java_enum_addendum)
out_java.write(out_java_addendum)
write_c(out_c_addendum)
- def map_trait(struct_name, field_var_lines, trait_fn_lines):
+ 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 = []
for var_line in field_var_lines:
type_mapping_generator.map_type(var_line.group(1) + " " + var_line.group(2), False, None, False, False))
field_fns = []
- for fn_line in trait_fn_lines:
+ 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)
is_const = fn_line.group(4) is not None
continue
arg_conv_info = type_mapping_generator.map_type(arg, True, None, False, False)
arg_tys.append(arg_conv_info)
- field_fns.append(TraitMethInfo(fn_line.group(3), is_const, ret_ty_info, arg_tys))
+ 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)
+ (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)
write_c(out_c_addendum)
out_java_trait.write(out_java_trait_addendum)
out_java.write(out_java_addendum)
- for fn_line in trait_fn_lines:
+ for fn_docs, fn_line in trait_fn_lines:
# For now, just disable enabling the _call_log - we don't know how to inverse-map String
is_log = fn_line.group(3) == "log" and struct_name == "LDKLogger"
if fn_line.group(3) != "free" and fn_line.group(3) != "clone" and fn_line.group(3) != "eq" and not is_log:
dummy_line = fn_line.group(2) + struct_name.replace("LDK", "") + "_" + fn_line.group(3) + " " + struct_name + "* this_arg" + fn_line.group(5) + "\n"
- 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")
+ 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)
for idx, var_line in enumerate(field_var_lines):
if var_line.group(1) not in trait_structs:
write_c(var_line.group(1) + " " + struct_name + "_set_get_" + var_line.group(2) + "(" + struct_name + "* this_arg) {\n")
write_c("\treturn this_arg->" + var_line.group(2) + ";\n")
write_c("}\n")
dummy_line = var_line.group(1) + " " + struct_name.replace("LDK", "") + "_get_" + var_line.group(2) + " " + struct_name + "* this_arg" + fn_line.group(5) + "\n"
- 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")
+ 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)
def map_result(struct_name, res_ty, err_ty):
result_types.add(struct_name)
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] + ";\n")
+ 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")
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] + ";\n")
+ 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")
with open(f"{sys.argv[3]}/structs/CommonBase{consts.file_ext}", "w") as out_java_struct:
out_java_struct.write(consts.common_base)
- in_block_comment = False
+ block_comment = None
+ last_block_comment = None
cur_block_obj = None
const_val_regex = re.compile("^extern const ([A-Za-z_0-9]*) ([A-Za-z_0-9]*);$")
union_enum_items = {}
result_ptr_struct_items = {}
for line in in_h:
- if in_block_comment:
+ if block_comment is not None:
if line.endswith("*/\n"):
- in_block_comment = False
+ last_block_comment = block_comment.strip("\n")
+ block_comment = None
+ else:
+ block_comment = block_comment + line.strip(" /*")
elif cur_block_obj is not None:
cur_block_obj = cur_block_obj + line
if line.startswith("} "):
for idx, struct_line in enumerate(obj_lines):
if struct_line.strip().startswith("/*"):
- in_block_comment = True
- if in_block_comment:
+ block_comment = struct_line.strip(" /*")
+ if block_comment is not None:
if struct_line.endswith("*/"):
- in_block_comment = False
+ last_struct_block_comment = block_comment.strip("\n")
+ block_comment = None
+ else:
+ block_comment = block_comment + "\n" + struct_line.strip(" /*")
else:
struct_name_match = struct_name_regex.match(struct_line)
if struct_name_match is not None:
is_tuple = True
trait_fn_match = line_indicates_trait_regex.match(struct_line)
if trait_fn_match is not None:
- trait_fn_lines.append(trait_fn_match)
+ trait_fn_lines.append((last_struct_block_comment, trait_fn_match))
field_var_match = line_field_var_regex.match(struct_line)
if field_var_match is not None:
field_var_lines.append(field_var_match)
if is_opaque:
opaque_structs.add(struct_name)
with open(f"{sys.argv[3]}/structs/{struct_name.replace('LDK', '')}{consts.file_ext}", "w") as out_java_struct:
- out_opaque_struct_human = consts.map_opaque_struct(struct_name)
+ out_opaque_struct_human = consts.map_opaque_struct(struct_name, last_block_comment)
+ last_block_comment = None
out_java_struct.write(out_opaque_struct_human)
elif result_contents is not None:
assert result_contents in result_ptr_struct_items
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])
+ map_complex_enum(struct_name, union_enum_items[struct_name], last_block_comment)
+ last_block_comment = None
elif is_unitary_enum:
- map_unitary_enum(struct_name, field_lines)
+ 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)
+ 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:
out_java_struct.write(consts.hu_struct_file_prefix)
if line.startswith("#include <"):
pass
elif line.startswith("/*"):
- #out_java.write("\t" + line)
if not line.endswith("*/\n"):
- in_block_comment = True
+ block_comment = line.strip(" /*")
elif line.startswith("typedef enum "):
cur_block_obj = line
elif line.startswith("typedef struct "):
elif line.startswith("typedef union "):
cur_block_obj = line
elif fn_ptr is not None:
- map_fn(line, fn_ptr, None, None)
+ map_fn(line, fn_ptr, None, None, last_block_comment)
+ last_block_comment = None
elif fn_ret_arr is not None:
- map_fn(line, fn_ret_arr, fn_ret_arr.group(4), None)
+ map_fn(line, fn_ret_arr, fn_ret_arr.group(4), None, last_block_comment)
+ last_block_comment = None
elif reg_fn is not None:
- map_fn(line, reg_fn, None, None)
+ map_fn(line, reg_fn, None, None, last_block_comment)
+ last_block_comment = None
elif const_val_regex is not None:
# TODO Map const variables
pass
out_c.write(consts.c_file_pfx)
out_c.write(consts.init_str())
out_c.write(c_file)
+with open(f"{sys.argv[3]}/structs/UtilMethods{consts.file_ext}", "a") as util:
+ util.write(consts.util_fn_sfx)
projects / ldk-java / blobdiff