X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=typescript_strings.py;h=4cdea4285b43bec3ee4d00b8ec7b3a81838364a3;hb=0ad910f3687d1d30d31c47e9210952ef090558e3;hp=f889519b76dbd9509235d35ce04513447eba4ec6;hpb=5526ec4b1668591b452f0fb19a8f33cacc6eebfd;p=ldk-java diff --git a/typescript_strings.py b/typescript_strings.py index f889519b..4cdea428 100644 --- a/typescript_strings.py +++ b/typescript_strings.py @@ -14,6 +14,8 @@ class Consts: def __init__(self, DEBUG: bool, target: Target, outdir: str, **kwargs): self.outdir = outdir self.struct_file_suffixes = {} + self.function_ptr_counter = 0 + self.function_ptrs = {} self.c_type_map = dict( uint8_t = ['number', 'Uint8Array'], uint16_t = ['number', 'Uint16Array'], @@ -76,13 +78,10 @@ public static native long new_empty_slice_vec(); self.bindings_footer = "" - self.util_fn_pfx = "" - self.util_fn_sfx = "" - self.common_base = """ function freer(f: () => void) { f() } const finalizer = new FinalizationRegistry(freer); -function get_freeer(ptr: number, free_fn: (number) => void) { +function get_freeer(ptr: number, free_fn: (ptr: number) => void) { return () => { free_fn(ptr); } @@ -113,6 +112,24 @@ export default class CommonBase { } """ + self.txout_defn = """export class TxOut extends CommonBase { + /** The script_pubkey in this output */ + public script_pubkey: Uint8Array; + /** The value, in satoshis, of this output */ + public value: number; + + /* @internal */ + public constructor(_dummy: object, ptr: number) { + super(ptr, bindings.TxOut_free); + this.script_pubkey = bindings.TxOut_get_script_pubkey(ptr); + this.value = bindings.TxOut_get_value(ptr); + } + public constructor_new(value: number, script_pubkey: Uint8Array): TxOut { + return new TxOut(null, bindings.TxOut_new(script_pubkey, value)); + } +}""" + self.obj_defined(["TxOut"], "structs") + self.c_file_pfx = """#include "js-wasm.h" #include #include @@ -309,6 +326,8 @@ import * as bindings from '../bindings.mjs' import * as InternalUtils from '../InternalUtils.mjs' """ + self.util_fn_pfx = self.hu_struct_file_prefix + "\nexport class UtilMethods extends CommonBase {\n" + self.util_fn_sfx = "}" self.c_fn_ty_pfx = "" self.file_ext = ".mts" self.ptr_c_ty = "uint32_t" @@ -405,13 +424,13 @@ imports.wasi_snapshot_preview1 = { }, }; -var wasm = null; +var wasm: any = null; let isWasmInitialized: boolean = false; """ if target == Target.NODEJS: res += """import * as fs from 'fs'; -export async function initializeWasm(path) { +export async function initializeWasm(path: string) { const source = fs.readFileSync(path); const { instance: wasmInstance } = await WebAssembly.instantiate(source, imports); wasm = wasmInstance.exports; @@ -420,7 +439,7 @@ export async function initializeWasm(path) { """ else: res += """ -export async function initializeWasm(uri) { +export async function initializeWasm(uri: string) { const stream = fetch(uri); const { instance: wasmInstance } = await WebAssembly.instantiateStreaming(stream, imports); wasm = wasmInstance.exports; @@ -438,7 +457,7 @@ const nextMultipleOfFour = (value: number) => { return Math.ceil(value / 4) * 4; } -const encodeUint8Array = (inputArray) => { +const encodeUint8Array = (inputArray: Uint8Array) => { const cArrayPointer = wasm.TS_malloc(inputArray.length + 4); const arrayLengthView = new Uint32Array(wasm.memory.buffer, cArrayPointer, 1); arrayLengthView[0] = inputArray.length; @@ -447,7 +466,7 @@ const encodeUint8Array = (inputArray) => { return cArrayPointer; } -const encodeUint32Array = (inputArray) => { +const encodeUint32Array = (inputArray: Uint32Array) => { const cArrayPointer = wasm.TS_malloc((inputArray.length + 1) * 4); const arrayMemoryView = new Uint32Array(wasm.memory.buffer, cArrayPointer, inputArray.length); arrayMemoryView.set(inputArray, 1); @@ -455,7 +474,7 @@ const encodeUint32Array = (inputArray) => { return cArrayPointer; } -const getArrayLength = (arrayPointer) => { +const getArrayLength = (arrayPointer: number) => { const arraySizeViewer = new Uint32Array( wasm.memory.buffer, // value arrayPointer, // offset @@ -463,7 +482,7 @@ const getArrayLength = (arrayPointer) => { ); return arraySizeViewer[0]; } -const decodeUint8Array = (arrayPointer, free = true) => { +const decodeUint8Array = (arrayPointer: number, free = true) => { const arraySize = getArrayLength(arrayPointer); const actualArrayViewer = new Uint8Array( wasm.memory.buffer, // value @@ -478,7 +497,7 @@ const decodeUint8Array = (arrayPointer, free = true) => { } return actualArray; } -const decodeUint32Array = (arrayPointer, free = true) => { +const decodeUint32Array = (arrayPointer: number, free = true) => { const arraySize = getArrayLength(arrayPointer); const actualArrayViewer = new Uint32Array( wasm.memory.buffer, // value @@ -494,7 +513,7 @@ const decodeUint32Array = (arrayPointer, free = true) => { return actualArray; } -const encodeString = (string) => { +const encodeString = (string: string) => { // make malloc count divisible by 4 const memoryNeed = nextMultipleOfFour(string.length + 1); const stringPointer = wasm.TS_malloc(memoryNeed); @@ -510,7 +529,7 @@ const encodeString = (string) => { return stringPointer; } -const decodeString = (stringPointer, free = true) => { +const decodeString = (stringPointer: number, free = true) => { const memoryView = new Uint8Array(wasm.memory.buffer, stringPointer); let cursor = 0; let result = ''; @@ -531,6 +550,9 @@ const decodeString = (stringPointer, free = true) => { def init_str(self): return "" + def constr_hu_array(self, ty_info, arr_len): + return "new Array(" + arr_len + ").fill(null)" + def var_decl_statement(self, ty_string, var_name, statement): return "const " + var_name + ": " + ty_string + " = " + statement @@ -606,25 +628,39 @@ const decodeString = (stringPointer, free = true) => { def native_c_map_trait(self, struct_name, field_var_conversions, flattened_field_var_conversions, field_function_lines, trait_doc_comment): out_typescript_bindings = "\n\n\n// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START\n\n" - constructor_arguments = "" super_instantiator = "" + bindings_instantiator = "" pointer_to_adder = "" impl_constructor_arguments = "" for var in flattened_field_var_conversions: if isinstance(var, ConvInfo): - constructor_arguments += f", {first_to_lower(var.arg_name)}?: {var.java_hu_ty}" impl_constructor_arguments += f", {var.arg_name}: {var.java_hu_ty}" + super_instantiator += first_to_lower(var.arg_name) + ", " if var.from_hu_conv is not None: - super_instantiator += ", " + var.from_hu_conv[0] + bindings_instantiator += ", " + var.from_hu_conv[0] if var.from_hu_conv[1] != "": pointer_to_adder += "\t\t\t" + var.from_hu_conv[1] + ";\n" else: - super_instantiator += ", " + first_to_lower(var.arg_name) + bindings_instantiator += ", " + first_to_lower(var.arg_name) + else: + bindings_instantiator += ", " + first_to_lower(var[1]) + ".bindings_instance" + super_instantiator += first_to_lower(var[1]) + "_impl, " + pointer_to_adder += "\t\timpl_holder.held.ptrs_to.push(" + first_to_lower(var[1]) + ");\n" + impl_constructor_arguments += f", {first_to_lower(var[1])}_impl: {var[0].replace('LDK', '')}Interface" + + super_constructor_statements = "" + trait_constructor_arguments = "" + for var in field_var_conversions: + if isinstance(var, ConvInfo): + trait_constructor_arguments += ", " + var.arg_name else: - constructor_arguments += f", {first_to_lower(var[1])}?: bindings.{var[0]}" - super_instantiator += ", " + first_to_lower(var[1]) - pointer_to_adder += "\t\t\tthis.ptrs_to.push(" + first_to_lower(var[1]) + ");\n" - impl_constructor_arguments += f", {first_to_lower(var[1])}_impl: {var[0].replace('LDK', '')}.{var[0].replace('LDK', '')}Interface" + super_constructor_statements += "\t\tconst " + first_to_lower(var[1]) + " = " + var[1] + ".new_impl(" + super_instantiator + ");\n" + trait_constructor_arguments += ", " + first_to_lower(var[1]) + ".bindings_instance" + for suparg in var[2]: + if isinstance(suparg, ConvInfo): + trait_constructor_arguments += ", " + suparg.arg_name + else: + trait_constructor_arguments += ", " + suparg[1] # BUILD INTERFACE METHODS out_java_interface = "" @@ -681,24 +717,6 @@ const decodeString = (stringPointer, free = true) => { out_interface_implementation_overrides += "\t\t\t\treturn ret;\n" out_interface_implementation_overrides += f"\t\t\t}},\n" - trait_constructor_arguments = "" - for var in field_var_conversions: - if isinstance(var, ConvInfo): - trait_constructor_arguments += ", " + var.arg_name - else: - trait_constructor_arguments += ", " + var[1] + ".new_impl(" + var[1] + "_impl" - for suparg in var[2]: - if isinstance(suparg, ConvInfo): - trait_constructor_arguments += ", " + suparg.arg_name - else: - trait_constructor_arguments += ", " + suparg[1] - trait_constructor_arguments += ").bindings_instance" - for suparg in var[2]: - if isinstance(suparg, ConvInfo): - trait_constructor_arguments += ", " + suparg.arg_name - else: - trait_constructor_arguments += ", " + suparg[1] - out_typescript_human = f""" {self.hu_struct_file_prefix} @@ -710,33 +728,33 @@ class {struct_name}Holder {{ }} export class {struct_name.replace("LDK","")} extends CommonBase {{ - private bindings_instance?: bindings.{struct_name}; + /* @internal */ + public bindings_instance?: bindings.{struct_name}; - constructor(ptr?: number, arg?: bindings.{struct_name}{constructor_arguments}) {{ - if (Number.isFinite(ptr)) {{ - super(ptr, bindings.{struct_name.replace("LDK","")}_free); - this.bindings_instance = null; - }} else {{ - // TODO: private constructor instantiation - super(bindings.{struct_name}_new(arg{super_instantiator}), bindings.{struct_name.replace("LDK","")}_free); - this.ptrs_to.push(arg); -{pointer_to_adder} }} + /* @internal */ + constructor(_dummy: object, ptr: number) {{ + super(ptr, bindings.{struct_name.replace("LDK","")}_free); + this.bindings_instance = null; }} static new_impl(arg: {struct_name.replace("LDK", "")}Interface{impl_constructor_arguments}): {struct_name.replace("LDK", "")} {{ const impl_holder: {struct_name}Holder = new {struct_name}Holder(); let structImplementation = {{ {out_interface_implementation_overrides} }} as bindings.{struct_name}; - impl_holder.held = new {struct_name.replace("LDK", "")} (null, structImplementation{trait_constructor_arguments}); - return impl_holder.held; +{super_constructor_statements} const ptr: number = bindings.{struct_name}_new(structImplementation{bindings_instantiator}); + + impl_holder.held = new {struct_name.replace("LDK", "")}(null, ptr); + impl_holder.held.bindings_instance = structImplementation; +{pointer_to_adder} return impl_holder.held; }} """ + self.obj_defined([struct_name.replace("LDK", ""), struct_name.replace("LDK", "") + "Interface"], "structs") - out_typescript_bindings += "\t\texport interface " + struct_name + " {\n" + out_typescript_bindings += "export interface " + struct_name + " {\n" java_meths = [] for fn_line in field_function_lines: if fn_line.fn_name != "free" and fn_line.fn_name != "cloned": - out_typescript_bindings += f"\t\t\t{fn_line.fn_name} (" + out_typescript_bindings += f"\t{fn_line.fn_name} (" for idx, arg_conv_info in enumerate(fn_line.args_ty): if idx >= 1: @@ -745,9 +763,9 @@ export class {struct_name.replace("LDK","")} extends CommonBase {{ out_typescript_bindings += f"): {fn_line.ret_ty_info.java_ty};\n" - out_typescript_bindings = out_typescript_bindings + "\t\t}\n\n" + out_typescript_bindings += "}\n\n" - out_typescript_bindings += f"\t\texport function {struct_name}_new(impl: {struct_name}" + out_typescript_bindings += f"export function {struct_name}_new(impl: {struct_name}" for var in flattened_field_var_conversions: if isinstance(var, ConvInfo): out_typescript_bindings += f", {var.arg_name}: {var.java_ty}" @@ -933,11 +951,11 @@ export class {struct_name.replace("LDK","")} extends CommonBase {{ java_hu_class += f"\t\tconst raw_val: bindings.{struct_name} = bindings." + struct_name + "_ref_from_ptr(ptr);\n" java_hu_subclasses = "" - out_java += "\texport class " + struct_name + " {\n" - out_java += "\t\tprotected constructor() {}\n" + out_java += "export class " + struct_name + " {\n" + out_java += "\tprotected constructor() {}\n" java_subclasses = "" for var in variant_list: - java_subclasses += "\texport class " + struct_name + "_" + var.var_name + " extends " + struct_name + " {\n" + java_subclasses += "export class " + struct_name + "_" + var.var_name + " extends " + struct_name + " {\n" java_hu_subclasses = java_hu_subclasses + "export class " + java_hu_type + "_" + var.var_name + " extends " + java_hu_type + " {\n" java_hu_class += "\t\tif (raw_val instanceof bindings." + struct_name + "_" + var.var_name + ") {\n" java_hu_class += "\t\t\treturn new " + java_hu_type + "_" + var.var_name + "(ptr, raw_val);\n" @@ -954,14 +972,14 @@ export class {struct_name.replace("LDK","")} extends CommonBase {{ if idx > 0: init_meth_params += ", " init_meth_params += "public " + field_ty.arg_name + ": " + field_ty.java_ty - java_subclasses += "\t\tconstructor(" + init_meth_params + ") { super(); }\n" - java_subclasses += "\t}\n" + java_subclasses += "\tconstructor(" + init_meth_params + ") { super(); }\n" + java_subclasses += "}\n" java_hu_class += "\t\t}\n" java_hu_subclasses += "\t/* @internal */\n" java_hu_subclasses += "\tpublic constructor(ptr: number, obj: bindings." + struct_name + "_" + var.var_name + ") {\n\t\tsuper(null, ptr);\n" java_hu_subclasses = java_hu_subclasses + hu_conv_body java_hu_subclasses = java_hu_subclasses + "\t}\n}\n" - out_java += ("\t}\n") + out_java += "}\n" out_java += java_subclasses java_hu_class += "\t\tthrow new Error('oops, this should be unreachable'); // Unreachable without extending the (internal) bindings interface\n\t}\n\n" out_java += self.fn_call_body(struct_name + "_ref_from_ptr", "uint32_t", "number", "ptr: number", "ptr") @@ -998,12 +1016,12 @@ export class {struct_name.replace("LDK","")} extends CommonBase {{ def map_opaque_struct(self, struct_name, struct_doc_comment): implementations = "" method_header = "" - if struct_name.startswith("LDKLocked"): - return "NOT IMPLEMENTED" hu_name = struct_name.replace("LDKC2Tuple", "TwoTuple").replace("LDKC3Tuple", "ThreeTuple").replace("LDK", "") - out_opaque_struct_human = f"""{self.hu_struct_file_prefix} - + out_opaque_struct_human = f"{self.hu_struct_file_prefix}" + if struct_name.startswith("LDKLocked"): + out_opaque_struct_human += "/** XXX: DO NOT USE THIS - it remains locked until the GC runs (if that ever happens */" + out_opaque_struct_human += f""" export class {hu_name} extends CommonBase {implementations}{{ /* @internal */ public constructor(_dummy: object, ptr: number) {{ @@ -1085,13 +1103,13 @@ export class {human_ty} extends CommonBase {{ converter = self.wasm_decoding_map[return_c_ty] return_statement = f"return {converter}(nativeResponseValue);" - return f"""\texport function {method_name}({method_argument_string}): {return_java_ty} {{ - if(!isWasmInitialized) {{ - throw new Error("initializeWasm() must be awaited first!"); - }} - const nativeResponseValue = wasm.TS_{method_name}({native_call_argument_string}); - {return_statement} + return f"""export function {method_name}({method_argument_string}): {return_java_ty} {{ + if(!isWasmInitialized) {{ + throw new Error("initializeWasm() must be awaited first!"); }} + const nativeResponseValue = wasm.TS_{method_name}({native_call_argument_string}); + {return_statement} +}} """ def map_function(self, argument_types, c_call_string, method_name, meth_n, return_type_info, struct_meth, default_constructor_args, takes_self, takes_self_as_ref, args_known, type_mapping_generator, doc_comment): out_java = ""