var getRandomValues: Function;
imports.wasi_snapshot_preview1 = {
- "fd_write": (fd: number, iovec_array_ptr: number, iovec_array_len: number) => {
+ "fd_write": (fd: number, iovec_array_ptr: number, iovec_array_len: number, bytes_written_ptr: number) => {
// This should generally only be used to print panic messages
- console.log("FD_WRITE to " + fd + " in " + iovec_array_len + " chunks.");
const ptr_len_view = new Uint32Array(wasm.memory.buffer, iovec_array_ptr, iovec_array_len * 2);
+ var bytes_written = 0;
for (var i = 0; i < iovec_array_len; i++) {
const bytes_view = new Uint8Array(wasm.memory.buffer, ptr_len_view[i*2], ptr_len_view[i*2+1]);
- console.log(String.fromCharCode(...bytes_view));
+ console.log("[fd " + fd + "]: " + String.fromCharCode(...bytes_view));
+ bytes_written += ptr_len_view[i*2+1];
}
+ const written_view = new Uint32Array(wasm.memory.buffer, bytes_written_ptr, 1);
+ written_view[0] = bytes_written;
return 0;
},
"fd_close": (_fd: number) => {
},
"environ_sizes_get": (environ_var_count_ptr: number, environ_len_ptr: number) => {
// This is called before fd_write to format + print panic messages
- console.log("wasi_snapshot_preview1:environ_sizes_get");
const out_count_view = new Uint32Array(wasm.memory.buffer, environ_var_count_ptr, 1);
out_count_view[0] = 0;
const out_len_view = new Uint32Array(wasm.memory.buffer, environ_len_ptr, 1);
return 0;
},
"environ_get": (environ_ptr: number, environ_buf_ptr: number) => {
- // This is called before fd_write to format + print panic messages
+ // This is called before fd_write to format + print panic messages,
+ // but only if we have variables in environ_sizes_get, so shouldn't ever actually happen!
console.log("wasi_snapshot_preview1:environ_get");
return 58; // Note supported - we said there were 0 environment entries!
},
}
return actualArray;
}
-
+/* @internal */
+export function decodeUint64Array (arrayPointer: number, free = true): bigint[] {
+ const arraySize = getArrayLength(arrayPointer);
+ const actualArrayViewer = new BigUint64Array(
+ wasm.memory.buffer, // value
+ arrayPointer + 4, // offset (ignoring length bytes)
+ arraySize // uint32 count
+ );
+ // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
+ // will free the underlying memory when it becomes unreachable instead of copying here.
+ const actualArray = new Array(arraySize);
+ for (var i = 0; i < arraySize; i++) actualArray[i] = actualArrayViewer[i];
+ if (free) {
+ wasm.TS_free(arrayPointer);
+ }
+ return actualArray;
+}
export function freeWasmMemory(pointer: number) { wasm.TS_free(pointer); }
protected constructor(ptr: number, free_fn: (ptr: number) => void) {
this.ptr = ptr;
if (Number.isFinite(ptr) && ptr != 0){
- finalizer.register(this, get_freeer(ptr, free_fn));
+ finalizer.register(this, get_freeer(ptr, free_fn), this);
}
}
// In Java, protected means "any subclass can access fields on any other subclass'"
}
protected static set_null_skip_free(o: CommonBase) {
o.ptr = 0;
- finalizer.unregister(o);
+ // @ts-ignore TypeScript is wrong about the returnvalue of unregister here!
+ const did_unregister: boolean = finalizer.unregister(o);
+ if (!did_unregister)
+ throw new Error("FinalizationRegistry unregister should always unregister unless you double-free'd");
}
}
assert False
def primitive_arr_to_hu(self, mapped_ty, fixed_len, arr_name, conv_name):
- assert mapped_ty.c_ty == "uint8_t" or mapped_ty.c_ty == "int8_t"
- return "const " + conv_name + ": Uint8Array = bindings.decodeUint8Array(" + arr_name + ");"
+ if mapped_ty.c_ty == "uint8_t" or mapped_ty.c_ty == "int8_t":
+ return "const " + conv_name + ": Uint8Array = bindings.decodeUint8Array(" + arr_name + ");"
+ elif mapped_ty.c_ty == "uint64_t" or mapped_ty.c_ty == "int64_t":
+ return "const " + conv_name + ": bigint[] = bindings.decodeUint64Array(" + arr_name + ");"
+ else:
+ assert False
def var_decl_statement(self, ty_string, var_name, statement):
return "const " + var_name + ": " + ty_string + " = " + statement
hu_name = struct_name.replace("LDKC2Tuple", "TwoTuple").replace("LDKC3Tuple", "ThreeTuple").replace("LDK", "")
out_opaque_struct_human = f"{self.hu_struct_file_prefix}"
+ constructor_body = "super(ptr, bindings." + struct_name.replace("LDK","") + "_free);"
+ extra_docs = ""
+ extra_body = ""
if struct_name.startswith("LDKLocked") or struct_name.startswith("LDKReadOnly"):
- out_opaque_struct_human += "/** XXX: DO NOT USE THIS - it remains locked until the GC runs (if that ever happens */"
+ extra_docs = "\n * This type represents a lock and MUST BE MANUALLY FREE'd!"
+ constructor_body = 'super(ptr, () => { throw new Error("Locks must be manually freed with free()"); });'
+ extra_body = f"""
+ /** Releases this lock */
+ public free() {{
+ bindings.{struct_name.replace("LDK","")}_free(this.ptr);
+ CommonBase.set_null_skip_free(this);
+ }}"""
formatted_doc_comment = struct_doc_comment.replace("\n", "\n * ")
out_opaque_struct_human += f"""
-/**
+/**{extra_docs}
* {formatted_doc_comment}
*/
export class {hu_name} extends CommonBase {implementations}{{
/* @internal */
public constructor(_dummy: object, ptr: number) {{
- super(ptr, bindings.{struct_name.replace("LDK","")}_free);
- }}
+ {constructor_body}
+ }}{extra_body}
"""
self.obj_defined([hu_name], "structs")
projects / ldk-java / blobdiff