X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=typescript_strings.py;h=ad5b1d8c5c4434183693094d1f2bd323b1d2c050;hb=ad38ab057a477dad34445ca97828a5c0cfb6b1bd;hp=449a8ea1bfee020cf473bf9846ed978da10489de;hpb=941cd1b9d1e9fdfb126869a3e150f546fc6edcda;p=ldk-java diff --git a/typescript_strings.py b/typescript_strings.py index 449a8ea1..ad5b1d8c 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'], @@ -79,7 +81,7 @@ public static native long new_empty_slice_vec(); 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); } @@ -391,18 +393,11 @@ import * as InternalUtils from '../InternalUtils.mjs' const imports: any = {}; imports.env = {}; -imports.env.tableBase = 0; -imports.env.table = new WebAssembly.Table({initial: 4, element: 'anyfunc'}); - +var js_objs: Array> = []; +var js_invoke: Function; imports.env["abort"] = function () { console.error("ABORT"); }; -imports.env["js_invoke_function"] = function(fn: number, arg1: number, arg2: number, arg3: number, arg4: number, arg5: number, arg6: number, arg7: number, arg8: number, arg9: number, arg10: number) { - console.log('function called from wasm:', fn, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); -}; -imports.env["js_free_function_ptr"] = function(fn: number) { - console.log("function ptr free'd from wasm:", fn); -}; imports.wasi_snapshot_preview1 = { "fd_write" : () => { @@ -422,14 +417,15 @@ 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); + imports.env["js_invoke_function"] = js_invoke; const { instance: wasmInstance } = await WebAssembly.instantiate(source, imports); wasm = wasmInstance.exports; isWasmInitialized = true; @@ -437,8 +433,9 @@ export async function initializeWasm(path) { """ else: res += """ -export async function initializeWasm(uri) { +export async function initializeWasm(uri: string) { const stream = fetch(uri); + imports.env["js_invoke_function"] = js_invoke; const { instance: wasmInstance } = await WebAssembly.instantiateStreaming(stream, imports); wasm = wasmInstance.exports; isWasmInitialized = true; @@ -455,7 +452,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; @@ -464,7 +461,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); @@ -472,7 +469,7 @@ const encodeUint32Array = (inputArray) => { return cArrayPointer; } -const getArrayLength = (arrayPointer) => { +const getArrayLength = (arrayPointer: number) => { const arraySizeViewer = new Uint32Array( wasm.memory.buffer, // value arrayPointer, // offset @@ -480,7 +477,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 @@ -495,7 +492,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 @@ -511,7 +508,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); @@ -527,7 +524,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 = ''; @@ -748,11 +745,11 @@ export class {struct_name.replace("LDK","")} extends CommonBase {{ """ 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: @@ -761,9 +758,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}" @@ -771,15 +768,24 @@ export class {struct_name.replace("LDK","")} extends CommonBase {{ out_typescript_bindings += f", {var[1]}: {var[0]}" out_typescript_bindings += f"""): number {{ - throw new Error('unimplemented'); // TODO: bind to WASM - }} + if(!isWasmInitialized) {{ + throw new Error("initializeWasm() must be awaited first!"); + }} + var new_obj_idx = js_objs.length; + for (var i = 0; i < js_objs.length; i++) {{ + if (js_objs[i] == null || js_objs[i] == undefined) {{ new_obj_idx = i; break; }} + }} + js_objs[i] = new WeakRef(impl); + return wasm.TS_{struct_name}_new(i); +}} """ out_typescript_bindings += '\n// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END\n\n\n' # Now that we've written out our java code (and created java_meths), generate C out_c = "typedef struct " + struct_name + "_JCalls {\n" - out_c = out_c + "\tatomic_size_t refcnt;\n" + out_c += "\tatomic_size_t refcnt;\n" + out_c += "\tuint32_t instance_ptr;\n" for var in flattened_field_var_conversions: if isinstance(var, ConvInfo): # We're a regular ol' field @@ -787,9 +793,6 @@ export class {struct_name.replace("LDK","")} extends CommonBase {{ else: # We're a supertrait out_c = out_c + "\t" + var[0] + "_JCalls* " + var[1] + ";\n" - for fn in field_function_lines: - if fn.fn_name != "free" and fn.fn_name != "cloned": - out_c = out_c + "\tuint32_t " + fn.fn_name + "_meth;\n" out_c = out_c + "} " + struct_name + "_JCalls;\n" for fn_line in field_function_lines: @@ -797,9 +800,6 @@ export class {struct_name.replace("LDK","")} extends CommonBase {{ out_c = out_c + "static void " + struct_name + "_JCalls_free(void* this_arg) {\n" out_c = out_c + "\t" + struct_name + "_JCalls *j_calls = (" + struct_name + "_JCalls*) this_arg;\n" out_c = out_c + "\tif (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {\n" - for fn in field_function_lines: - if fn.fn_name != "free" and fn.fn_name != "cloned": - out_c = out_c + "\t\tjs_free_function_ptr(j_calls->" + fn.fn_name + "_meth);\n" out_c = out_c + "\t\tFREE(j_calls);\n" out_c = out_c + "\t}\n}\n" @@ -826,15 +826,18 @@ export class {struct_name.replace("LDK","")} extends CommonBase {{ if fn_line.ret_ty_info.c_ty.endswith("Array"): out_c += "\t" + fn_line.ret_ty_info.c_ty + " ret = (" + fn_line.ret_ty_info.c_ty + ")" - out_c += "js_invoke_function_" + str(len(fn_line.args_ty)) + "(j_calls->" + fn_line.fn_name + "_meth" + out_c += "js_invoke_function_" + str(len(fn_line.args_ty)) + "(j_calls->instance_ptr, " + str(self.function_ptr_counter) elif fn_line.ret_ty_info.java_ty == "void": - out_c = out_c + "\tjs_invoke_function_" + str(len(fn_line.args_ty)) + "(j_calls->" + fn_line.fn_name + "_meth" + out_c = out_c + "\tjs_invoke_function_" + str(len(fn_line.args_ty)) + "(j_calls->instance_ptr, " + str(self.function_ptr_counter) elif fn_line.ret_ty_info.java_ty == "String": - out_c = out_c + "\tjstring ret = (jstring)js_invoke_function_" + str(len(fn_line.args_ty)) + "(j_calls->" + fn_line.fn_name + "_meth" + out_c = out_c + "\tjstring ret = (jstring)js_invoke_function_" + str(len(fn_line.args_ty)) + "(j_calls->instance_ptr, " + str(self.function_ptr_counter) elif not fn_line.ret_ty_info.passed_as_ptr: - out_c = out_c + "\treturn js_invoke_function_" + str(len(fn_line.args_ty)) + "(j_calls->" + fn_line.fn_name + "_meth" + out_c = out_c + "\treturn js_invoke_function_" + str(len(fn_line.args_ty)) + "(j_calls->instance_ptr, " + str(self.function_ptr_counter) else: - out_c = out_c + "\tuint32_t ret = js_invoke_function_" + str(len(fn_line.args_ty)) + "(j_calls->" + fn_line.fn_name + "_meth" + out_c = out_c + "\tuint32_t ret = js_invoke_function_" + str(len(fn_line.args_ty)) + "(j_calls->instance_ptr, " + str(self.function_ptr_counter) + + self.function_ptrs[self.function_ptr_counter] = (struct_name, fn_line.fn_name) + self.function_ptr_counter += 1 for idx, arg_info in enumerate(fn_line.args_ty): if arg_info.ret_conv is not None: @@ -856,17 +859,17 @@ export class {struct_name.replace("LDK","")} extends CommonBase {{ out_c = out_c + "\tatomic_fetch_add_explicit(&j_calls->" + var[1] + "->refcnt, 1, memory_order_release);\n" out_c = out_c + "}\n" - out_c = out_c + "static inline " + struct_name + " " + struct_name + "_init (/*TODO: JS Object Reference */void* o" + out_c = out_c + "static inline " + struct_name + " " + struct_name + "_init (JSValue o" for var in flattened_field_var_conversions: if isinstance(var, ConvInfo): out_c = out_c + ", " + var.c_ty + " " + var.arg_name else: - out_c = out_c + ", /*TODO: JS Object Reference */void* " + var[1] + out_c = out_c + ", JSValue " + var[1] out_c = out_c + ") {\n" out_c = out_c + "\t" + struct_name + "_JCalls *calls = MALLOC(sizeof(" + struct_name + "_JCalls), \"" + struct_name + "_JCalls\");\n" out_c = out_c + "\tatomic_init(&calls->refcnt, 1);\n" - out_c = out_c + "\t//TODO: Assign calls->o from o\n" + out_c = out_c + "\tcalls->instance_ptr = o;\n" for (fn_name, java_meth_descr) in java_meths: if fn_name != "free" and fn_name != "cloned": @@ -908,12 +911,12 @@ export class {struct_name.replace("LDK","")} extends CommonBase {{ out_c = out_c + "\treturn ret;\n" out_c = out_c + "}\n" - out_c = out_c + self.c_fn_ty_pfx + "long " + self.c_fn_name_define_pfx(struct_name + "_new", True) + "/*TODO: JS Object Reference */void* o" + out_c = out_c + self.c_fn_ty_pfx + "long " + self.c_fn_name_define_pfx(struct_name + "_new", True) + "JSValue o" for var in flattened_field_var_conversions: if isinstance(var, ConvInfo): out_c = out_c + ", " + var.c_ty + " " + var.arg_name else: - out_c = out_c + ", /*TODO: JS Object Reference */ void* " + var[1] + out_c = out_c + ", JSValue " + var[1] out_c = out_c + ") {\n" out_c = out_c + "\t" + struct_name + " *res_ptr = MALLOC(sizeof(" + struct_name + "), \"" + struct_name + "\");\n" out_c = out_c + "\t*res_ptr = " + struct_name + "_init(o" @@ -1101,13 +1104,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 = "" @@ -1265,3 +1268,34 @@ export class {human_ty} extends CommonBase {{ for struct in self.struct_file_suffixes: with open(self.outdir + "/structs/" + struct + self.file_ext, "a") as src: src.write(self.struct_file_suffixes[struct]) + + with open(self.outdir + "/bindings.mts", "a") as bindings: + bindings.write(""" + +js_invoke = function(obj_ptr: number, fn_id: number, arg1: number, arg2: number, arg3: number, arg4: number, arg5: number, arg6: number, arg7: number, arg8: number, arg9: number, arg10: number) { + const weak: WeakRef = js_objs[obj_ptr]; + if (weak == null || weak == undefined) { + console.error("Got function call on unknown/free'd JS object!"); + throw new Error("Got function call on unknown/free'd JS object!"); + } + const obj: object = weak.deref(); + if (obj == null || obj == undefined) { + console.error("Got function call on GC'd JS object!"); + throw new Error("Got function call on GC'd JS object!"); + } + var fn; +""") + bindings.write("\tswitch (fn_id) {\n") + for f in self.function_ptrs: + bindings.write(f"\t\tcase {str(f)}: fn = Object.getOwnPropertyDescriptor(obj, \"{self.function_ptrs[f][1]}\"); break;\n") + + bindings.write("""\t\tdefault: + console.error("Got unknown function call from C!"); + throw new Error("Got unknown function call from C!"); + } + if (fn == null || fn == undefined) { + console.error("Got function call on incorrect JS object!"); + throw new Error("Got function call on incorrect JS object!"); + } + return fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); +}""")