X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=genbindings.py;h=b4f9323db3b6b6eb44d77395aa81f7d97213e41c;hb=36e5154452d7583496053259e2c6b93b9baeaf8a;hp=aee1e7df24442c4e6355fa0c13cc75358cbaf23e;hpb=8fa15bfa27041fd41288bfbcf44baa3736cf33e9;p=ldk-java diff --git a/genbindings.py b/genbindings.py index aee1e7df..b4f9323d 100755 --- a/genbindings.py +++ b/genbindings.py @@ -122,6 +122,7 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.arg is_ptr = True c_ty = "jlong" java_ty = "long" + fn_ty_arg = "J" var_is_arr = var_is_arr_regex.match(fn_arg) if var_is_arr is not None or ret_arr_len is not None: @@ -182,23 +183,25 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.arg return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name, arg_conv = base_conv, arg_conv_name = ty_info.var_name + "_conv", - ret_conv = None, ret_conv_name = None) - base_conv = base_conv + "\nFREE((void*)" + ty_info.var_name + ");"; + ret_conv = ("CANT PASS TRAIT TO Java?", ""), ret_conv_name = "NO CONV POSSIBLE") + if ty_info.rust_obj != "LDKu8slice": + # Don't bother free'ing slices passed in - we often pass them Rust -> Rust + base_conv = base_conv + "\nFREE((void*)" + ty_info.var_name + ");"; if ty_info.rust_obj in opaque_structs: return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name, - arg_conv = base_conv + "\n" + ty_info.var_name + "_conv._underlying_ref = false;", + arg_conv = base_conv + "\n" + ty_info.var_name + "_conv.is_owned = true;", arg_conv_name = ty_info.var_name + "_conv", - ret_conv = None, ret_conv_name = None) + ret_conv = ("long " + ty_info.var_name + "_ref = (long)&", ";"), ret_conv_name = ty_info.var_name + "_ref") return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name, arg_conv = base_conv, arg_conv_name = ty_info.var_name + "_conv", - ret_conv = None, ret_conv_name = None) + ret_conv = ("long " + ty_info.var_name + "_ref = (long)&", ";"), ret_conv_name = ty_info.var_name + "_ref") else: assert(not is_free) return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name, arg_conv = ty_info.rust_obj + "* " + ty_info.var_name + "_conv = (" + ty_info.rust_obj + "*)" + ty_info.var_name + ";", arg_conv_name = ty_info.var_name + "_conv", - ret_conv = None, ret_conv_name = None) + ret_conv = None, ret_conv_name = None) # its a pointer, no conv needed elif ty_info.is_ptr: return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name, arg_conv = None, arg_conv_name = ty_info.var_name, ret_conv = None, ret_conv_name = None) @@ -236,7 +239,7 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.arg # any _free function. # To avoid any issues, we first assert that the incoming object is non-ref. return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name, - ret_conv = (ty_info.rust_obj + "* ret = MALLOC(sizeof(" + ty_info.rust_obj + "), \"" + ty_info.rust_obj + "\");\n*ret = ", ";\nassert(!ret->_underlying_ref);\nret->_underlying_ref = true;"), + ret_conv = (ty_info.rust_obj + "* ret = MALLOC(sizeof(" + ty_info.rust_obj + "), \"" + ty_info.rust_obj + "\");\n*ret = ", ";\nDO_ASSERT(ret->is_owned);\nret->is_owned = false;"), ret_conv_name = "(long)ret", arg_conv = None, arg_conv_name = None) else: @@ -252,8 +255,8 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.arg return ConvInfo(ty_info = ty_info, arg_name = ty_info.var_name, arg_conv = None, arg_conv_name = None, ret_conv = None, ret_conv_name = None) - def map_fn(re_match, ret_arr_len): - out_java.write("\t/// " + line) + def map_fn(line, re_match, ret_arr_len, c_call_string): + out_java.write("\t// " + line) out_java.write("\tpublic static native ") out_c.write("JNIEXPORT ") @@ -289,11 +292,16 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.arg else: out_c.write("\treturn "); - out_c.write(re_match.group(2) + "(") + if c_call_string is None: + out_c.write(re_match.group(2) + "(") + else: + out_c.write(c_call_string) for idx, info in enumerate(arg_names): if info.arg_conv_name is not None: if idx != 0: out_c.write(", ") + elif c_call_string is not None: + continue out_c.write(info.arg_conv_name) out_c.write(")") if ret_info.ret_conv is not None: @@ -306,7 +314,7 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.arg def map_trait(struct_name, field_var_lines, trait_fn_lines): out_c.write("typedef struct " + struct_name + "_JCalls {\n") out_c.write("\tatomic_size_t refcnt;\n") - out_c.write("\tJNIEnv *env;\n") + out_c.write("\tJavaVM *vm;\n") out_c.write("\tjobject o;\n") for var_line in field_var_lines: if var_line.group(1) in trait_structs: @@ -349,17 +357,19 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.arg out_java.write(");\n") out_c.write(") {\n") out_c.write("\t" + struct_name + "_JCalls *j_calls = (" + struct_name + "_JCalls*) this_arg;\n") + out_c.write("\tJNIEnv *env;\n") + out_c.write("\tDO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_8) == JNI_OK);\n") for arg_info in arg_names: if arg_info.ret_conv is not None: - out_c.write("\t" + arg_info.ret_conv[0].replace('\n', '\n\t').replace("_env", "j_calls->env")); + out_c.write("\t" + arg_info.ret_conv[0].replace('\n', '\n\t').replace("_env", "env")); out_c.write(arg_info.arg_name) - out_c.write(arg_info.ret_conv[1].replace('\n', '\n\t').replace("_env", "j_calls->env") + "\n") + out_c.write(arg_info.ret_conv[1].replace('\n', '\n\t').replace("_env", "env") + "\n") if not ret_ty_info.passed_as_ptr: - out_c.write("\treturn (*j_calls->env)->Call" + ret_ty_info.java_ty.title() + "Method(j_calls->env, j_calls->o, j_calls->" + fn_line.group(2) + "_meth") + out_c.write("\treturn (*env)->Call" + ret_ty_info.java_ty.title() + "Method(env, j_calls->o, j_calls->" + fn_line.group(2) + "_meth") else: - out_c.write("\t" + fn_line.group(1).strip() + "* ret = (" + fn_line.group(1).strip() + "*)(*j_calls->env)->CallLongMethod(j_calls->env, j_calls->o, j_calls->" + fn_line.group(2) + "_meth"); + out_c.write("\t" + fn_line.group(1).strip() + "* ret = (" + fn_line.group(1).strip() + "*)(*env)->CallLongMethod(env, j_calls->o, j_calls->" + fn_line.group(2) + "_meth"); for arg_info in arg_names: if arg_info.ret_conv is not None: @@ -377,7 +387,9 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.arg out_c.write("static void " + struct_name + "_JCalls_free(void* this_arg) {\n") out_c.write("\t" + struct_name + "_JCalls *j_calls = (" + struct_name + "_JCalls*) this_arg;\n") out_c.write("\tif (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {\n") - out_c.write("\t\t(*j_calls->env)->DeleteGlobalRef(j_calls->env, j_calls->o);\n") + out_c.write("\t\tJNIEnv *env;\n") + out_c.write("\t\tDO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_8) == JNI_OK);\n") + out_c.write("\t\t(*env)->DeleteGlobalRef(env, j_calls->o);\n") out_c.write("\t\tFREE(j_calls);\n") out_c.write("\t}\n}\n") @@ -403,15 +415,15 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.arg out_c.write(") {\n") out_c.write("\tjclass c = (*env)->GetObjectClass(env, o);\n") - out_c.write("\tassert(c != NULL);\n") + out_c.write("\tDO_ASSERT(c != NULL);\n") out_c.write("\t" + struct_name + "_JCalls *calls = MALLOC(sizeof(" + struct_name + "_JCalls), \"" + struct_name + "_JCalls\");\n") out_c.write("\tatomic_init(&calls->refcnt, 1);\n") - out_c.write("\tcalls->env = env;\n") + out_c.write("\tDO_ASSERT((*env)->GetJavaVM(env, &calls->vm) == 0);\n") out_c.write("\tcalls->o = (*env)->NewGlobalRef(env, o);\n") for (fn_line, java_meth_descr) in zip(trait_fn_lines, java_meths): if fn_line.group(2) != "free" and fn_line.group(2) != "clone": out_c.write("\tcalls->" + fn_line.group(2) + "_meth = (*env)->GetMethodID(env, c, \"" + fn_line.group(2) + "\", \"" + java_meth_descr + "\");\n") - out_c.write("\tassert(calls->" + fn_line.group(2) + "_meth != NULL);\n") + out_c.write("\tDO_ASSERT(calls->" + fn_line.group(2) + "_meth != NULL);\n") out_c.write("\n\t" + struct_name + " ret = {\n") out_c.write("\t\t.this_arg = (void*) calls,\n") for fn_line in trait_fn_lines: @@ -445,72 +457,153 @@ with open(sys.argv[1]) as in_h, open(sys.argv[2], "w") as out_java, open(sys.arg out_c.write("\treturn (long)res_ptr;\n") out_c.write("}\n") + out_java.write("\tpublic static native " + struct_name + " " + struct_name + "_get_obj_from_jcalls(long val);\n") + out_c.write("JNIEXPORT jobject JNICALL Java_org_ldk_impl_bindings_" + struct_name.replace("_", "_1") + "_1get_1obj_1from_1jcalls (JNIEnv * env, jclass _a, jlong val) {\n") + out_c.write("\treturn ((" + struct_name + "_JCalls*)val)->o;\n") + out_c.write("}\n") + for fn_line in trait_fn_lines: + # For now, just disable enabling the _call_log - we don't know how to inverse-map String + is_log = fn_line.group(2) == "log" and struct_name == "LDKLogger" + if fn_line.group(2) != "free" and fn_line.group(2) != "clone" and fn_line.group(2) != "eq" and not is_log: + dummy_line = fn_line.group(1) + struct_name + "_call_" + fn_line.group(2) + " " + struct_name + "* arg" + fn_line.group(4) + "\n" + map_fn(dummy_line, re.compile("([A-Za-z_0-9]*) *([A-Za-z_0-9]*) *(.*)").match(dummy_line), None, "(arg_conv->" + fn_line.group(2) + ")(arg_conv->this_arg") out_java.write("""package org.ldk.impl; public class bindings { - static native void init(java.lang.Class c); static { System.loadLibrary(\"lightningjni\"); init(java.lang.Enum.class); } - """) - out_c.write("#include \"org_ldk_impl_bindings.h\"\n") - out_c.write("#include \n") - out_c.write("#include \n") - out_c.write("#include \n") - out_c.write("#include \n") - out_c.write("#include \n\n") - - out_c.write("jmethodID ordinal_meth = NULL;\n") - out_c.write("JNIEXPORT void Java_org_ldk_impl_bindings_init(JNIEnv * env, jclass _b, jclass enum_class) {\n") - out_c.write("\tordinal_meth = (*env)->GetMethodID(env, enum_class, \"ordinal\", \"()I\");\n") - out_c.write("\tassert(ordinal_meth != NULL);\n") - out_c.write("}\n\n") + out_c.write("""#include \"org_ldk_impl_bindings.h\" +#include +#include +#include +#include +""") if sys.argv[4] == "false": out_c.write("#define MALLOC(a, _) malloc(a)\n") - out_c.write("#define FREE free\n\n") + out_c.write("#define FREE free\n") + out_c.write("#define DO_ASSERT(a) (void)(a)\n") else: - out_c.write("#include \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 +#define DO_ASSERT(a) do { bool _assert_val = (a); assert(_assert_val); } while(0) + +#include +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 and [u8] need to have been mapped identically"); +_Static_assert(offsetof(LDKCVec_u8Z, data) == offsetof(LDKu8slice, data), "Vec and [u8] need to have been mapped identically"); +_Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKu8slice, datalen), "Vec and [u8] need to have been mapped identically"); + +""") # XXX: Temporarily write out a manual SecretKey_new() for testing, we should auto-gen this kind of thing out_java.write("\tpublic static native long LDKSecretKey_new();\n\n") # TODO: rm me @@ -527,7 +620,8 @@ public class bindings { reg_fn_regex = re.compile("([A-Za-z_0-9\* ]* \*?)([a-zA-Z_0-9]*)\((.*)\);$") const_val_regex = re.compile("^extern const ([A-Za-z_0-9]*) ([A-Za-z_0-9]*);$") - line_indicates_opaque_regex = re.compile("^ bool _underlying_ref;$") + line_indicates_result_regex = re.compile("^ bool result_ok;$") + line_indicates_opaque_regex = re.compile("^ bool is_owned;$") line_indicates_trait_regex = re.compile("^ ([A-Za-z_0-9]* \*?)\(\*([A-Za-z_0-9]*)\)\((const )?void \*this_arg(.*)\);$") assert(line_indicates_trait_regex.match(" uintptr_t (*send_data)(void *this_arg, LDKu8slice data, bool resume_read);")) assert(line_indicates_trait_regex.match(" LDKCVec_MessageSendEventZ (*get_and_clear_pending_msg_events)(const void *this_arg);")) @@ -537,7 +631,10 @@ public class bindings { struct_name_regex = re.compile("^typedef (struct|enum|union) (MUST_USE_STRUCT )?(LDK[A-Za-z_0-9]*) {$") assert(struct_name_regex.match("typedef struct LDKCVecTempl_u8 {")) assert(struct_name_regex.match("typedef enum LDKNetwork {")) + struct_alias_regex = re.compile("^typedef (LDK[A-Za-z_0-9]*) (LDK[A-Za-z_0-9]*);$") + assert(struct_alias_regex.match("typedef LDKCResultTempl_bool__PeerHandleError LDKCResult_boolPeerHandleErrorZ;")) + result_templ_structs = set() for line in in_h: if in_block_comment: #out_java.write("\t" + line) @@ -550,6 +647,7 @@ public class bindings { struct_name = None obj_lines = cur_block_obj.split("\n") is_opaque = False + is_result = False is_unitary_enum = False is_union_enum = False is_union = False @@ -575,6 +673,8 @@ public class bindings { is_union = True if line_indicates_opaque_regex.match(struct_line): is_opaque = True + elif line_indicates_result_regex.match(struct_line): + is_result = True trait_fn_match = line_indicates_trait_regex.match(struct_line) if trait_fn_match is not None: trait_fn_lines.append(trait_fn_match) @@ -591,6 +691,14 @@ public class bindings { assert(not is_union or not (len(trait_fn_lines) != 0 or is_unitary_enum or is_union_enum or is_opaque)) if is_opaque: opaque_structs.add(struct_name) + out_java.write("\tpublic static native long " + struct_name + "_optional_none();\n") + out_c.write("JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_" + struct_name.replace("_", "_1") + "_1optional_1none (JNIEnv * env, jclass _a) {\n") + out_c.write("\t" + struct_name + " *ret = MALLOC(sizeof(" + struct_name + "), \"" + struct_name + "\");\n") + out_c.write("\tret->inner = NULL;\n") + out_c.write("\treturn (long)ret;\n") + out_c.write("}\n") + elif is_result: + result_templ_structs.add(struct_name) elif is_unitary_enum: unitary_enums.add(struct_name) out_c.write("static inline " + struct_name + " " + struct_name + "_from_java(JNIEnv *env, jclass val) {\n") @@ -610,25 +718,25 @@ public class bindings { out_c.write("\t\tcase %d: return %s;\n" % (ord_v, struct_line.strip().strip(","))) ord_v = ord_v + 1 out_c.write("\t}\n") - out_c.write("\tassert(false);\n") + out_c.write("\tabort();\n") out_c.write("}\n") ord_v = 0 out_c.write("static inline jclass " + struct_name + "_to_java(JNIEnv *env, " + struct_name + " val) {\n") out_c.write("\t// TODO: This is pretty inefficient, we really need to cache the field IDs and class\n") out_c.write("\tjclass enum_class = (*env)->FindClass(env, \"Lorg/ldk/impl/bindings$" + struct_name + ";\");\n") - out_c.write("\tassert(enum_class != NULL);\n") + out_c.write("\tDO_ASSERT(enum_class != NULL);\n") out_c.write("\tswitch (val) {\n") for idx, struct_line in enumerate(field_lines): if idx > 0 and idx < len(field_lines) - 3: variant = struct_line.strip().strip(",") out_c.write("\t\tcase " + variant + ": {\n") out_c.write("\t\t\tjfieldID field = (*env)->GetStaticFieldID(env, enum_class, \"" + variant + "\", \"Lorg/ldk/impl/bindings$" + struct_name + ";\");\n") - out_c.write("\t\t\tassert(field != NULL);\n") + out_c.write("\t\t\tDO_ASSERT(field != NULL);\n") out_c.write("\t\t\treturn (*env)->GetStaticObjectField(env, enum_class, field);\n") out_c.write("\t\t}\n") ord_v = ord_v + 1 - out_c.write("\t\tdefault: assert(false);\n") + out_c.write("\t\tdefault: abort();\n") out_c.write("\t}\n") out_c.write("}\n\n") elif len(trait_fn_lines) > 0: @@ -654,13 +762,26 @@ public class bindings { elif line.startswith("typedef union "): cur_block_obj = line elif line.startswith("typedef "): + alias_match = struct_alias_regex.match(line) + if alias_match.group(1) in result_templ_structs: + out_java.write("\tpublic static native boolean " + alias_match.group(2) + "_result_ok(long arg);\n") + out_java.write("\tpublic static native long " + alias_match.group(2) + "_get_inner(long arg);\n") + out_c.write("JNIEXPORT jboolean JNICALL Java_org_ldk_impl_bindings_" + alias_match.group(2).replace("_", "_1") + "_1result_1ok (JNIEnv * env, jclass _a, jlong arg) {\n") + out_c.write("\treturn ((" + alias_match.group(2) + "*)arg)->result_ok;\n") + out_c.write("}\n") + out_c.write("JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_" + alias_match.group(2).replace("_", "_1") + "_1get_1inner (JNIEnv * env, jclass _a, jlong arg) {\n") + out_c.write("\tif (((" + alias_match.group(2) + "*)arg)->result_ok) {\n") + out_c.write("\t\treturn (long)((" + alias_match.group(2) + "*)arg)->contents.result;\n") + out_c.write("\t} else {\n") + out_c.write("\t\treturn (long)((" + alias_match.group(2) + "*)arg)->contents.err;\n") + out_c.write("\t}\n}\n") pass elif fn_ptr is not None: - map_fn(fn_ptr, None) + map_fn(line, fn_ptr, None, None) elif fn_ret_arr is not None: - map_fn(fn_ret_arr, fn_ret_arr.group(4)) + map_fn(line, fn_ret_arr, fn_ret_arr.group(4), None) elif reg_fn is not None: - map_fn(reg_fn, None) + map_fn(line, reg_fn, None, None) elif const_val_regex is not None: # TODO Map const variables pass