2 def __init__(self, DEBUG):
4 export default class CommonBase {
6 ptrs_to: object[] = new Array(); // new LinkedList(); TODO: build linked list implementation
7 protected constructor(ptr: number) { this.ptr = ptr; }
8 public _test_only_get_ptr(): number { return this.ptr; }
12 self.c_file_pfx = """#include <rust_types.h>
13 #include <stdatomic.h>
14 #include <lightning.h>
16 // These should be provided...somehow...
17 void *memset(void *s, int c, size_t n);
18 void *memcpy(void *dest, const void *src, size_t n);
19 int memcmp(const void *s1, const void *s2, size_t n);
21 void __attribute__((noreturn)) abort(void);
22 void assert(scalar expression);
26 self.c_file_pfx = self.c_file_pfx + """
27 void *malloc(size_t size);
30 #define MALLOC(a, _) malloc(a)
31 #define FREE(p) if ((long)(p) > 1024) { free(p); }
32 #define DO_ASSERT(a) (void)(a)
36 self.c_file_pfx = self.c_file_pfx + """
37 // Always run a, then assert it is true:
38 #define DO_ASSERT(a) do { bool _assert_val = (a); assert(_assert_val); } while(0)
39 // Assert a is true or do nothing
40 #define CHECK(a) DO_ASSERT(a)
42 // Running a leak check across all the allocations and frees of the JDK is a mess,
43 // so instead we implement our own naive leak checker here, relying on the -wrap
44 // linker option to wrap malloc/calloc/realloc/free, tracking everyhing allocated
45 // and free'd in Rust or C across the generated bindings shared library.
48 typedef struct allocation {
49 struct allocation* next;
51 const char* struct_name;
53 static allocation* allocation_ll = NULL;
55 void* __real_malloc(size_t len);
56 void* __real_calloc(size_t nmemb, size_t len);
57 static void new_allocation(void* res, const char* struct_name) {
58 allocation* new_alloc = __real_malloc(sizeof(allocation));
60 new_alloc->struct_name = struct_name;
61 new_alloc->next = allocation_ll;
62 allocation_ll = new_alloc;
64 static void* MALLOC(size_t len, const char* struct_name) {
65 void* res = __real_malloc(len);
66 new_allocation(res, struct_name);
69 void __real_free(void* ptr);
70 static void alloc_freed(void* ptr) {
72 allocation* it = allocation_ll;
73 while (it->ptr != ptr) {
74 p = it; it = it->next;
76 //XXX: fprintf(stderr, "Tried to free unknown pointer %p\\n", ptr);
77 return; // addrsan should catch malloc-unknown and print more info than we have
80 if (p) { p->next = it->next; } else { allocation_ll = it->next; }
81 DO_ASSERT(it->ptr == ptr);
84 static void FREE(void* ptr) {
85 if ((long)ptr < 1024) return; // Rust loves to create pointers to the NULL page for dummys
90 void* __wrap_malloc(size_t len) {
91 void* res = __real_malloc(len);
92 new_allocation(res, "malloc call");
95 void* __wrap_calloc(size_t nmemb, size_t len) {
96 void* res = __real_calloc(nmemb, len);
97 new_allocation(res, "calloc call");
100 void __wrap_free(void* ptr) {
101 if (ptr == NULL) return;
106 void* __real_realloc(void* ptr, size_t newlen);
107 void* __wrap_realloc(void* ptr, size_t len) {
108 if (ptr != NULL) alloc_freed(ptr);
109 void* res = __real_realloc(ptr, len);
110 new_allocation(res, "realloc call");
113 void __wrap_reallocarray(void* ptr, size_t new_sz) {
114 // Rust doesn't seem to use reallocarray currently
118 void __attribute__((destructor)) check_leaks() {
119 for (allocation* a = allocation_ll; a != NULL; a = a->next) {
120 //XXX: fprintf(stderr, "%s %p remains\\n", a->struct_name, a->ptr);
122 DO_ASSERT(allocation_ll == NULL);
125 self.c_file_pfx = self.c_file_pfx + """
126 // We assume that CVec_u8Z and u8slice are the same size and layout (and thus pointers to the two can be mixed)
127 _Static_assert(sizeof(LDKCVec_u8Z) == sizeof(LDKu8slice), "Vec<u8> and [u8] need to have been mapped identically");
128 _Static_assert(offsetof(LDKCVec_u8Z, data) == offsetof(LDKu8slice, data), "Vec<u8> and [u8] need to have been mapped identically");
129 _Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKu8slice, datalen), "Vec<u8> and [u8] need to have been mapped identically");
131 _Static_assert(sizeof(void*) == 4, "Pointers mut be 32 bits");
133 typedef struct int64_tArray {uint32_t len;int64_t *ptr;} int64_tArray;
134 typedef struct uint32_tArray {uint32_t len;int32_t *ptr;} uint32_tArray;
135 typedef struct int8_tArray {uint32_t len;int8_t *ptr;} int8_tArray;
137 typedef bool jboolean;
141 self.hu_struct_file_prefix = f"""
142 import CommonBase from './CommonBase';
143 import * as bindings from '../bindings' // TODO: figure out location
146 self.c_fn_ty_pfx = ""
147 self.c_fn_name_pfx = ""
148 self.c_fn_args_pfx = "void* ctx_TODO"
149 self.file_ext = ".ts"
150 self.ptr_c_ty = "uint32_t"
151 self.ptr_native_ty = "uint32_t"
152 self.result_c_ty = "uint32_t"
153 self.ptr_arr = "uint32_tArray"
154 self.get_native_arr_len_call = ("", ".len")
155 self.get_native_arr_ptr_call = ("", ".ptr")
157 def release_native_arr_ptr_call(self, arr_var, arr_ptr_var):
159 def create_native_arr_call(self, arr_len, ty_info):
160 if ty_info.c_ty == "int8_tArray":
161 return "{ .len = " + arr_len + ", .ptr = MALLOC(" + arr_len + ", \"Native " + ty_info.c_ty + " Bytes\") }"
162 elif ty_info.c_ty == "int64_tArray":
163 return "{ .len = " + arr_len + ", .ptr = MALLOC(" + arr_len + " * sizeof(int64_t), \"Native " + ty_info.c_ty + " Bytes\") }"
164 elif ty_info.c_ty == "uint32_tArray":
165 return "{ .len = " + arr_len + ", .ptr = MALLOC(" + arr_len + " * sizeof(int32_t), \"Native " + ty_info.c_ty + " Bytes\") }"
167 print("Need to create arr!", ty_info.c_ty)
169 def set_native_arr_contents(self, arr_name, arr_len, ty_info):
170 if ty_info.c_ty == "int8_tArray":
171 return ("memcpy(" + arr_name + ".ptr, ", ", " + arr_len + ")")
174 def get_native_arr_contents(self, arr_name, dest_name, arr_len, ty_info, copy):
175 if ty_info.c_ty == "int8_tArray":
177 return "memcpy(" + dest_name + ", " + arr_name + ".ptr, " + arr_len + ")"
179 return arr_name + ".ptr"
181 return "(" + ty_info.subty.c_ty + "*) " + arr_name + ".ptr"
182 def get_native_arr_elem(self, arr_name, idxc, ty_info):
183 assert False # Only called if above is None
184 def cleanup_native_arr_ref_contents(self, arr_name, dest_name, arr_len, ty_info):
185 if ty_info.c_ty == "int8_tArray":
190 def init_str(self, c_array_class_caches):
193 def native_c_unitary_enum_map(self, struct_name, variants):
194 out_c = "static inline " + struct_name + " " + struct_name + "_from_js(int32_t ord) {\n"
195 out_c = out_c + "\tswitch (ord) {\n"
198 out_typescript_enum_fields = ""
201 out_c = out_c + "\t\tcase %d: return %s;\n" % (ord_v, var)
203 out_typescript_enum_fields += f"{var},\n\t\t\t\t"
204 out_c = out_c + "\t}\n"
205 out_c = out_c + "\tabort();\n"
206 out_c = out_c + "}\n"
208 out_c = out_c + "static inline int32_t " + struct_name + "_to_js(" + struct_name + " val) {\n"
209 out_c = out_c + "\tswitch (val) {\n"
212 out_c = out_c + "\t\tcase " + var + ": return %d;\n" % ord_v
214 out_c = out_c + "\t\tdefault: abort();\n"
215 out_c = out_c + "\t}\n"
216 out_c = out_c + "}\n"
218 out_typescript_enum = f"""
219 export enum {struct_name} {{
220 {out_typescript_enum_fields}
224 return (out_c, out_typescript_enum, "")
226 def c_unitary_enum_to_native_call(self, ty_info):
227 return (ty_info.rust_obj + "_to_js(", ")")
228 def native_unitary_enum_to_c_call(self, ty_info):
229 return (ty_info.rust_obj + "_from_js(", ")")
231 def c_complex_enum_pass_ty(self, struct_name):
234 def c_constr_native_complex_enum(self, struct_name, variant, c_params):
235 ret = "0 /* " + struct_name + " - " + variant + " */"
236 for param in c_params:
237 ret = ret + "; (void) " + param
240 def native_c_map_trait(self, struct_name, field_var_convs, field_fn_lines):
243 def map_complex_enum(self, struct_name, variant_list, camel_to_snake):
244 java_hu_type = struct_name.replace("LDK", "")
250 out_java_enum += (self.hu_struct_file_prefix)
251 out_java_enum += ("export default class " + java_hu_type + " extends CommonBase {\n")
252 out_java_enum += ("\tprotected constructor(_dummy: object, ptr: number) { super(ptr); }\n")
253 out_java_enum += ("\tprotected finalize() {\n")
254 out_java_enum += ("\t\tsuper.finalize();\n")
255 out_java_enum += ("\t\tif (this.ptr != 0) { bindings." + java_hu_type + "_free(this.ptr); }\n")
256 out_java_enum += ("\t}\n")
257 out_java_enum += f"\tstatic constr_from_ptr(ptr: number): {java_hu_type} {{\n"
258 out_java_enum += (f"\t\tconst raw_val: bindings.{struct_name} = bindings." + struct_name + "_ref_from_ptr(ptr);\n")
259 java_hu_subclasses = ""
261 out_java += ("\tpublic static class " + struct_name + " {\n")
262 out_java += ("\t\tprivate " + struct_name + "() {}\n")
263 for var in variant_list:
264 out_java += ("\t\texport class " + var.var_name + " extends " + struct_name + " {\n")
265 java_hu_subclasses = java_hu_subclasses + "export class " + var.var_name + " extends " + java_hu_type + " {\n"
266 out_java_enum += ("\t\tif (raw_val instanceof bindings." + struct_name + "." + var.var_name + ") {\n")
267 out_java_enum += ("\t\t\treturn new " + var.var_name + "(this.ptr, raw_val);\n")
268 init_meth_params = ""
271 for idx, field_ty in enumerate(var.fields):
272 out_java += ("\t\t\tpublic " + field_ty.java_ty + " " + field_ty.arg_name + ";\n")
273 java_hu_subclasses = java_hu_subclasses + "\tpublic " + field_ty.arg_name + f": {field_ty.java_hu_ty};\n"
274 if field_ty.to_hu_conv is not None:
275 hu_conv_body = hu_conv_body + "\t\tconst " + field_ty.arg_name + f": {field_ty.java_ty} = obj." + field_ty.arg_name + ";\n"
276 hu_conv_body = hu_conv_body + "\t\t" + field_ty.to_hu_conv.replace("\n", "\n\t\t\t") + "\n"
277 hu_conv_body = hu_conv_body + "\t\tthis." + field_ty.arg_name + " = " + field_ty.to_hu_conv_name + ";\n"
279 hu_conv_body = hu_conv_body + "\t\tthis." + field_ty.arg_name + " = obj." + field_ty.arg_name + ";\n"
281 init_meth_params = init_meth_params + ", "
282 init_meth_params = init_meth_params + field_ty.java_ty + " " + field_ty.arg_name
283 init_meth_body = init_meth_body + "this." + field_ty.arg_name + " = " + field_ty.arg_name + "; "
284 out_java += ("\t\t\t" + var.var_name + "(" + init_meth_params + ") { ")
285 out_java += (init_meth_body)
287 out_java += ("\t\t}\n")
288 out_java_enum += ("\t\t}\n")
289 java_hu_subclasses = java_hu_subclasses + "\tprivate constructor(ptr: number, obj: bindings." + struct_name + "." + var.var_name + ") {\n\t\tsuper(null, ptr);\n"
290 java_hu_subclasses = java_hu_subclasses + hu_conv_body
291 java_hu_subclasses = java_hu_subclasses + "\t}\n}\n"
292 out_java += ("\t\tstatic native void init();\n")
293 out_java += ("\t}\n")
294 out_java_enum += ("\t\tthrow new Error('oops, this should be unreachable'); // Unreachable without extending the (internal) bindings interface\n\t}\n\n")
295 out_java += ("\tstatic { " + struct_name + ".init(); }\n")
296 out_java += ("\tpublic static native " + struct_name + " " + struct_name + "_ref_from_ptr(long ptr);\n");
298 out_c += (self.c_fn_ty_pfx + self.c_complex_enum_pass_ty(struct_name) + " " + self.c_fn_name_pfx + struct_name.replace("_", "_1") + "_1ref_1from_1ptr (" + self.c_fn_args_pfx + ", " + self.ptr_c_ty + " ptr) {\n")
299 out_c += ("\t" + struct_name + " *obj = (" + struct_name + "*)ptr;\n")
300 out_c += ("\tswitch(obj->tag) {\n")
301 for var in variant_list:
302 out_c += ("\t\tcase " + struct_name + "_" + var.var_name + ": {\n")
304 for idx, field_map in enumerate(var.fields):
305 if field_map.ret_conv is not None:
306 out_c += ("\t\t\t" + field_map.ret_conv[0].replace("\n", "\n\t\t\t"))
307 out_c += ("obj->" + camel_to_snake(var.var_name) + "." + field_map.arg_name)
308 out_c += (field_map.ret_conv[1].replace("\n", "\n\t\t\t") + "\n")
309 c_params.append(field_map.ret_conv_name)
311 c_params.append("obj->" + camel_to_snake(var.var_name) + "." + field_map.arg_name)
312 out_c += ("\t\t\treturn " + self.c_constr_native_complex_enum(struct_name, var.var_name, c_params) + ";\n")
314 out_c += ("\t\tdefault: abort();\n")
315 out_c += ("\t}\n}\n")
316 out_java_enum += ("}\n")
317 out_java_enum += (java_hu_subclasses)
318 return (out_java, out_java_enum, out_c)