#!/usr/bin/env python3
import os, sys, re, subprocess
-if len(sys.argv) < 7:
- print("USAGE: /path/to/lightning.h /path/to/bindings/output /path/to/bindings/ /path/to/bindings/output.c debug lang")
+if len(sys.argv) < 8:
+ print("USAGE: /path/to/lightning.h /path/to/bindings/output /path/to/bindings/ /path/to/bindings/output.c debug lang target-tuple")
sys.exit(1)
if sys.argv[5] == "false":
target = java_strings.Target.JAVA
if sys.argv[6] == "android":
target = java_strings.Target.ANDROID
+ if "apple" in sys.argv[8]:
+ target = java_strings.Target.MACOS
elif sys.argv[6] == "typescript":
import typescript_strings
from typescript_strings import Consts
target = typescript_strings.Target.NODEJS
if len(sys.argv) == 8 and sys.argv[7] == 'browser':
target = typescript_strings.Target.BROWSER
+elif sys.argv[6].startswith("c_sharp"):
+ import csharp_strings
+ from csharp_strings import Consts
+ if sys.argv[6] == "c_sharp-win":
+ target = csharp_strings.Target.WINDOWS
+ elif sys.argv[6] == "c_sharp-darwin":
+ target = csharp_strings.Target.PTHREAD
+ elif sys.argv[6] == "c_sharp-linux":
+ target = csharp_strings.Target.LINUX
+ else:
+ assert False
+elif sys.argv[6] == "python":
+ import python_strings
+ from python_strings import Consts
+ target = python_strings.Target.PYTHON
else:
- print("Only java or typescript can be set for lang")
+ print("Only java, typescript, python, or c_sharp can be set for lang")
sys.exit(1)
-
consts = Consts(DEBUG, target=target, outdir=sys.argv[4])
local_git_version = os.getenv("LDK_GARBAGECOLLECTED_GIT_OVERRIDE")
rust_obj = None
arr_access = None
java_hu_ty = None
- 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"):
+ if 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_access = "data"
+ elif fn_arg.startswith("LDKThirtyTwoU16s"):
+ fn_arg = "uint16_t (*" + fn_arg[17:] + ")[32]"
+ assert var_is_arr_regex.match(fn_arg[9:])
+ rust_obj = "LDKThirtyTwoU16s"
+ arr_access = "data"
elif fn_arg.startswith("LDKU128"):
if fn_arg == "LDKU128":
fn_arg = "LDKU128 arg"
assert var_is_arr_regex.match(fn_arg[8:])
rust_obj = "LDKU128"
arr_access = "le_bytes"
- elif fn_arg.startswith("LDKTxid"):
- fn_arg = "uint8_t (*" + fn_arg[8:] + ")[32]"
- assert var_is_arr_regex.match(fn_arg[8:])
- rust_obj = "LDKThirtyTwoBytes"
- arr_access = "data"
elif fn_arg.startswith("LDKPublicKey"):
fn_arg = "uint8_t (*" + fn_arg[13:] + ")[33]"
assert var_is_arr_regex.match(fn_arg[8:])
assert var_is_arr_regex.match(fn_arg[8:])
rust_obj = "LDKSecretKey"
arr_access = "bytes"
- elif fn_arg.startswith("LDKSignature"):
- fn_arg = "uint8_t (*" + fn_arg[13:] + ")[64]"
+ elif fn_arg.startswith("LDKECDSASignature"):
+ fn_arg = "uint8_t (*" + fn_arg[18:] + ")[64]"
+ assert var_is_arr_regex.match(fn_arg[8:])
+ rust_obj = "LDKECDSASignature"
+ arr_access = "compact_form"
+ elif fn_arg.startswith("LDKSchnorrSignature"):
+ fn_arg = "uint8_t (*" + fn_arg[20:] + ")[64]"
assert var_is_arr_regex.match(fn_arg[8:])
- rust_obj = "LDKSignature"
+ rust_obj = "LDKSchnorrSignature"
arr_access = "compact_form"
elif fn_arg.startswith("LDKRecoverableSignature"):
fn_arg = "uint8_t (*" + fn_arg[24:] + ")[68]"
rust_obj = "LDKTransaction"
assert var_is_arr_regex.match(fn_arg[8:])
arr_access = "data"
+ elif fn_arg.startswith("LDKTransactionOutputs "):
+ fn_arg = "C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ"
+ rust_obj = "C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ"
+ elif fn_arg.startswith("LDKWitness ") or fn_arg == "LDKWitness":
+ if len(fn_arg) > 12 and fn_arg[11] == "*":
+ fn_arg = "uint8_t (" + fn_arg[11:] + ")[datalen]"
+ else:
+ fn_arg = "uint8_t (*" + fn_arg[11:] + ")[datalen]"
+ rust_obj = "LDKWitness"
+ assert var_is_arr_regex.match(fn_arg[8:])
+ arr_access = "data"
elif fn_arg.startswith("LDKCVec_"):
is_ptr = False
if "*" in fn_arg:
fn_arg = fn_arg[4:].strip()
is_primitive = True
elif fn_arg.startswith("bool"):
- java_ty = "boolean"
+ java_ty = consts.c_type_map['bool'][0]
c_ty = "jboolean"
fn_ty_arg = "Z"
arr_ty = "bool"
arr_ty = "uint8_t"
fn_arg = fn_arg[7:].strip()
is_primitive = True
- elif fn_arg.startswith("LDKu5") or fn_arg.startswith("LDKWitnessVersion"):
+ elif fn_arg.startswith("LDKU5") or fn_arg.startswith("LDKWitnessVersion"):
java_ty = consts.c_type_map['uint8_t'][0]
- if fn_arg.startswith("LDKu5"):
+ if fn_arg.startswith("LDKU5"):
java_hu_ty = "UInt5"
- rust_obj = "LDKu5"
+ rust_obj = "LDKU5"
fn_arg = fn_arg[6:].strip()
else:
java_hu_ty = "WitnessVersion"
fn_ty_arg = "I"
fn_arg = fn_arg[8:].strip()
is_primitive = True
+ elif fn_arg.startswith("int64_t"):
+ mapped_type = consts.c_type_map['int64_t']
+ java_ty = mapped_type[0]
+ c_ty = "int64_t"
+ arr_ty = "int64_t"
+ fn_ty_arg = "J"
+ fn_arg = fn_arg[7:].strip()
+ is_primitive = True
+ elif fn_arg.startswith("double"):
+ mapped_type = consts.c_type_map['double']
+ java_ty = mapped_type[0]
+ c_ty = "double"
+ arr_ty = "double"
+ fn_ty_arg = "D"
+ fn_arg = fn_arg[6:].strip()
+ is_primitive = True
elif fn_arg.startswith("uint64_t") or fn_arg.startswith("uintptr_t"):
# TODO: uintptr_t is arch-dependent :(
mapped_type = consts.c_type_map['uint64_t']
arr_ty = "LDKStr"
fn_ty_arg = "Ljava/lang/String;"
fn_arg = fn_arg[6:].strip()
- elif fn_arg.startswith("LDKStr"):
+ elif fn_arg.startswith("LDKStr") or fn_arg.startswith("LDKAddress"):
rust_obj = "LDKStr"
arr_ty = "LDKStr"
java_ty = consts.java_type_map["String"]
java_hu_ty = consts.java_hu_type_map["String"]
c_ty = "jstring"
fn_ty_arg = "Ljava/lang/String;"
- fn_arg = fn_arg[6:].strip()
+ if fn_arg.startswith("LDKAddress"):
+ fn_arg = fn_arg[10:].strip()
+ else:
+ fn_arg = fn_arg[6:].strip()
arr_access = "chars"
arr_len = "len"
elif fn_arg.startswith("LDKError ") or fn_arg == "LDKError":
assert ma.group(1).strip().startswith("LDK")
java_ty = ma.group(1).strip()[3:]
java_hu_ty = java_ty
- c_ty = consts.result_c_ty
+ c_ty = consts.unitary_enum_c_ty
fn_ty_arg = "Lorg/ldk/enums/" + java_ty + ";"
fn_arg = ma.group(2).strip()
rust_obj = ma.group(1).strip()
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:
+ # LDKWitness is mapped as an array, so no need to implement clone
+ if expected_struct == "LDKWitness":
+ return
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"))
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("BigEndianScalar") and
+ not method_name.startswith("TxOut") and not method_name.startswith("TxIn") and
+ not method_name.startswith("BigEndianScalar") and not method_name.startswith("WitnessProgram") and
not method_name.startswith("_") and
method_name != "check_platform" and method_name != "Result_read" and
not expected_struct in unitary_enums and
for var_line in field_var_lines:
if var_line.group(1) in trait_structs:
field_var_convs.append((var_line.group(1), var_line.group(2), trait_structs[var_line.group(1)]))
- flattened_field_var_convs.append((var_line.group(1), var_line.group(2), ))
- flattened_field_var_convs.extend(trait_structs[var_line.group(1)])
+ flattened_field_var_convs.append((var_line.group(1), var_line.group(2), var_line.group(2)))
+ for field_var in trait_structs[var_line.group(1)]:
+ if isinstance(field_var, ConvInfo):
+ flattened_field_var_convs.append(field_var)
+ else:
+ path = var_line.group(2)
+ if len(field_var) > 2:
+ path = var_line.group(2) + "." + field_var[2]
+ flattened_field_var_convs.append((field_var[0], field_var[1], path))
else:
mapped = type_mapping_generator.map_type(var_line.group(1) + " " + var_line.group(2), False, None, False, False)
field_var_convs.append(mapped)
flattened_field_var_convs.append(mapped)
- trait_structs[struct_name] = field_var_convs
+ trait_structs[struct_name] = flattened_field_var_convs
field_fns = []
for fn_docs, fn_line in trait_fn_lines:
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)
out_java_struct.write(consts.txout_defn)
- fn_line = "struct LDKCVec_u8Z TxOut_get_script_pubkey (struct LDKTxOut* thing)"
- write_c(fn_line + " {")
- write_c("\treturn CVec_u8Z_clone(&thing->script_pubkey);")
- write_c("}")
- map_fn(fn_line + "\n", re.compile("(.*) (TxOut_get_script_pubkey) \((.*)\)").match(fn_line), None, None, None)
- fn_line = "uint64_t TxOut_get_value (struct LDKTxOut* thing)"
- write_c(fn_line + " {")
- write_c("\treturn thing->value;")
- write_c("}")
- map_fn(fn_line + "\n", re.compile("(.*) (TxOut_get_value) \((.*)\)").match(fn_line), None, None, None)
+ out_java_struct.write(consts.hu_struct_file_suffix)
+ elif struct_name == "LDKTxIn":
+ with open(f"{sys.argv[3]}/structs/TxIn{consts.file_ext}", "w") as out_java_struct:
+ out_java_struct.write(consts.hu_struct_file_prefix)
+ out_java_struct.write(consts.txin_defn)
+ out_java_struct.write(consts.hu_struct_file_suffix)
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)
+ out_java_struct.write(consts.hu_struct_file_suffix)
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")
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)
+ elif struct_name == "LDKWitnessProgram":
+ with open(f"{sys.argv[3]}/structs/WitnessProgram{consts.file_ext}", "w") as out_java_struct:
+ out_java_struct.write(consts.hu_struct_file_prefix)
+ out_java_struct.write(consts.witness_program_defn)
+ out_java_struct.write(consts.hu_struct_file_suffix)
else:
pass # Everything remaining is a byte[] of some form
cur_block_obj = None
else:
assert(line == "\n")
- out_java.write(consts.bindings_footer)
+ out_java.write(consts.bindings_footer())
for struct_name in opaque_structs:
with open(f"{sys.argv[3]}/structs/{struct_name.replace('LDK', '')}{consts.file_ext}", "a") as out_java_struct:
- out_java_struct.write("}\n")
+ out_java_struct.write("}\n" + consts.hu_struct_file_suffix)
for struct_name in trait_structs:
with open(f"{sys.argv[3]}/structs/{struct_name.replace('LDK', '')}{consts.file_ext}", "a") as out_java_struct:
- out_java_struct.write("}\n")
+ out_java_struct.write("}\n" + consts.hu_struct_file_suffix)
for struct_name in complex_enums:
with open(f"{sys.argv[3]}/structs/{struct_name.replace('LDK', '').replace('COption', 'Option')}{consts.file_ext}", "a") as out_java_struct:
- out_java_struct.write("}\n")
+ out_java_struct.write("}\n" + consts.hu_struct_file_suffix)
for struct_name in result_types:
with open(f"{sys.argv[3]}/structs/{struct_name.replace('LDKCResult', 'Result')}{consts.file_ext}", "a") as out_java_struct:
- out_java_struct.write("}\n")
+ out_java_struct.write("}\n" + consts.hu_struct_file_suffix)
for struct_name in tuple_types:
struct_hu_name = struct_name.replace("LDKC2Tuple", "TwoTuple").replace("LDKC3Tuple", "ThreeTuple")
with open(f"{sys.argv[3]}/structs/{struct_hu_name}{consts.file_ext}", "a") as out_java_struct:
- out_java_struct.write("}\n")
+ out_java_struct.write("}\n" + consts.hu_struct_file_suffix)
with open(f"{sys.argv[4]}/bindings.c.body", "w") as out_c:
out_c.write(consts.c_file_pfx)
projects / ldk-java / blobdiff