- out_c.write("#include <threads.h>\n")
- out_c.write("static mtx_t allocation_mtx;\n\n")
- out_c.write("void __attribute__((constructor)) init_mtx() {\n")
- out_c.write("\tassert(mtx_init(&allocation_mtx, mtx_plain) == thrd_success);\n")
- out_c.write("}\n\n")
- out_c.write("typedef struct allocation {\n")
- out_c.write("\tstruct allocation* next;\n")
- out_c.write("\tvoid* ptr;\n")
- out_c.write("\tconst char* struct_name;\n")
- out_c.write("} allocation;\n")
- out_c.write("static allocation* allocation_ll = NULL;\n\n")
- out_c.write("void* MALLOC(size_t len, const char* struct_name) {\n")
- out_c.write("\tvoid* res = malloc(len);\n")
- out_c.write("\tallocation* new_alloc = malloc(sizeof(allocation));\n")
- out_c.write("\tnew_alloc->ptr = res;\n")
- out_c.write("\tnew_alloc->struct_name = struct_name;\n")
- out_c.write("\tassert(mtx_lock(&allocation_mtx) == thrd_success);\n")
- out_c.write("\tnew_alloc->next = allocation_ll;\n")
- out_c.write("\tallocation_ll = new_alloc;\n")
- out_c.write("\tassert(mtx_unlock(&allocation_mtx) == thrd_success);\n")
- out_c.write("\treturn res;\n")
- out_c.write("}\n\n")
- out_c.write("void FREE(void* ptr) {\n")
- out_c.write("\tallocation* p = NULL;\n")
- out_c.write("\tassert(mtx_lock(&allocation_mtx) == thrd_success);\n")
- out_c.write("\tallocation* it = allocation_ll;\n")
- out_c.write("\twhile (it->ptr != ptr) { p = it; it = it->next; }\n")
- out_c.write("\tif (p) { p->next = it->next; } else { allocation_ll = it->next; }\n")
- out_c.write("\tassert(mtx_unlock(&allocation_mtx) == thrd_success);\n")
- out_c.write("\tassert(it->ptr == ptr);\n")
- out_c.write("\tfree(it);\n")
- out_c.write("\tfree(ptr);\n")
- out_c.write("}\n\n")
- out_c.write("void __attribute__((destructor)) check_leaks() {\n")
- out_c.write("\tfor (allocation* a = allocation_ll; a != NULL; a = a->next) { fprintf(stderr, \"%s %p remains\\n\", a->struct_name, a->ptr); }\n")
- out_c.write("\tassert(allocation_ll == NULL);\n")
- out_c.write("}\n\n")
+ out_c.write("""#include <assert.h>
+#define DO_ASSERT(a) do { bool _assert_val = (a); assert(_assert_val); } while(0)
+
+#include <threads.h>
+static mtx_t allocation_mtx;
+
+void __attribute__((constructor)) init_mtx() {
+ DO_ASSERT(mtx_init(&allocation_mtx, mtx_plain) == thrd_success);
+}
+
+typedef struct allocation {
+ struct allocation* next;
+ void* ptr;
+ const char* struct_name;
+} allocation;
+static allocation* allocation_ll = NULL;
+
+void* MALLOC(size_t len, const char* struct_name) {
+ void* res = malloc(len);
+ allocation* new_alloc = malloc(sizeof(allocation));
+ new_alloc->ptr = res;
+ new_alloc->struct_name = struct_name;
+ DO_ASSERT(mtx_lock(&allocation_mtx) == thrd_success);
+ new_alloc->next = allocation_ll;
+ allocation_ll = new_alloc;
+ DO_ASSERT(mtx_unlock(&allocation_mtx) == thrd_success);
+ return res;
+}
+
+void FREE(void* ptr) {
+ allocation* p = NULL;
+ DO_ASSERT(mtx_lock(&allocation_mtx) == thrd_success);
+ allocation* it = allocation_ll;
+ while (it->ptr != ptr) { p = it; it = it->next; }
+ if (p) { p->next = it->next; } else { allocation_ll = it->next; }
+ DO_ASSERT(mtx_unlock(&allocation_mtx) == thrd_success);
+ DO_ASSERT(it->ptr == ptr);
+ free(it);
+ free(ptr);
+}
+
+void __attribute__((destructor)) check_leaks() {
+ for (allocation* a = allocation_ll; a != NULL; a = a->next) { fprintf(stderr, "%s %p remains\\n", a->struct_name, a->ptr); }
+ DO_ASSERT(allocation_ll == NULL);
+}
+""")
+
+ out_java.write("""
+ static native void init(java.lang.Class c);
+
+ public static native boolean deref_bool(long ptr);
+ public static native long deref_long(long ptr);
+ public static native void free_heap_ptr(long ptr);
+ public static native byte[] get_u8_slice_bytes(long slice_ptr);
+ public static native long bytes_to_u8_vec(byte[] bytes);
+ public static native long vec_slice_len(long vec);
+ public static native long new_empty_slice_vec();
+
+""")
+ out_c.write("""
+jmethodID ordinal_meth = NULL;
+JNIEXPORT void Java_org_ldk_impl_bindings_init(JNIEnv * env, jclass _b, jclass enum_class) {
+ ordinal_meth = (*env)->GetMethodID(env, enum_class, "ordinal", "()I");
+ DO_ASSERT(ordinal_meth != NULL);
+}
+
+JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_deref_1bool (JNIEnv * env, jclass _a, jlong ptr) {
+ return *((bool*)ptr);
+}
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_deref_1long (JNIEnv * env, jclass _a, jlong ptr) {
+ return *((long*)ptr);
+}
+JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_free_1heap_1ptr (JNIEnv * env, jclass _a, jlong ptr) {
+ FREE((void*)ptr);
+}
+JNIEXPORT jbyteArray JNICALL Java_org_ldk_impl_bindings_get_1u8_1slice_1bytes (JNIEnv * _env, jclass _b, jlong slice_ptr) {
+ LDKu8slice *slice = (LDKu8slice*)slice_ptr;
+ jbyteArray ret_arr = (*_env)->NewByteArray(_env, slice->datalen);
+ (*_env)->SetByteArrayRegion(_env, ret_arr, 0, slice->datalen, slice->data);
+ return ret_arr;
+}
+JNIEXPORT long JNICALL Java_org_ldk_impl_bindings_bytes_1to_1u8_1vec (JNIEnv * _env, jclass _b, jbyteArray bytes) {
+ LDKCVec_u8Z *vec = (LDKCVec_u8Z*)MALLOC(sizeof(LDKCVec_u8Z), "LDKCVec_u8");
+ vec->datalen = (*_env)->GetArrayLength(_env, bytes);
+ vec->data = (uint8_t*)malloc(vec->datalen); // May be freed by rust, so don't track allocation
+ (*_env)->GetByteArrayRegion (_env, bytes, 0, vec->datalen, vec->data);
+ return (long)vec;
+}
+JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_vec_1slice_1len (JNIEnv * env, jclass _a, jlong ptr) {
+ // Check offsets of a few Vec types are all consistent as we're meant to be generic across types
+ _Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKCVec_SignatureZ, datalen), "Vec<*> needs to be mapped identically");
+ _Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKCVec_MessageSendEventZ, datalen), "Vec<*> needs to be mapped identically");
+ _Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKCVec_EventZ, datalen), "Vec<*> needs to be mapped identically");
+ _Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKCVec_C2Tuple_usizeTransactionZZ, datalen), "Vec<*> needs to be mapped identically");
+ LDKCVec_u8Z *vec = (LDKCVec_u8Z*)ptr;
+ return (long)vec->datalen;
+}
+JNIEXPORT long JNICALL Java_org_ldk_impl_bindings_new_1empty_1slice_1vec (JNIEnv * _env, jclass _b) {
+ // Check sizes of a few Vec types are all consistent as we're meant to be generic across types
+ _Static_assert(sizeof(LDKCVec_u8Z) == sizeof(LDKCVec_SignatureZ), "Vec<*> needs to be mapped identically");
+ _Static_assert(sizeof(LDKCVec_u8Z) == sizeof(LDKCVec_MessageSendEventZ), "Vec<*> needs to be mapped identically");
+ _Static_assert(sizeof(LDKCVec_u8Z) == sizeof(LDKCVec_EventZ), "Vec<*> needs to be mapped identically");
+ _Static_assert(sizeof(LDKCVec_u8Z) == sizeof(LDKCVec_C2Tuple_usizeTransactionZZ), "Vec<*> needs to be mapped identically");
+ LDKCVec_u8Z *vec = (LDKCVec_u8Z*)MALLOC(sizeof(LDKCVec_u8Z), "Empty LDKCVec");
+ vec->data = NULL;
+ vec->datalen = 0;
+ return (long)vec;
+}
+
+// We assume that CVec_u8Z and u8slice are the same size and layout (and thus pointers to the two can be mixed)
+_Static_assert(sizeof(LDKCVec_u8Z) == sizeof(LDKu8slice), "Vec<u8> and [u8] need to have been mapped identically");
+_Static_assert(offsetof(LDKCVec_u8Z, data) == offsetof(LDKu8slice, data), "Vec<u8> and [u8] need to have been mapped identically");
+_Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKu8slice, datalen), "Vec<u8> and [u8] need to have been mapped identically");
+
+""")