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:
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)
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
projects / ldk-java / blobdiff