X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=java_strings.py;h=d2054a172237019f84284beceab2b31834dca60e;hb=f92e8f580983b5842a12198355eb778c1ac9e241;hp=eda4086cd92b2f4c08048bccb764a0316971ab9a;hpb=7af4c6356726774cac8b1cda57ec4828ef8c95b5;p=ldk-java diff --git a/java_strings.py b/java_strings.py index eda4086c..d2054a17 100644 --- a/java_strings.py +++ b/java_strings.py @@ -1,5 +1,6 @@ from bindingstypes import * from enum import Enum +import sys class Target(Enum): JAVA = 1, @@ -23,6 +24,13 @@ class Consts: self.bindings_header = """package org.ldk.impl; import org.ldk.enums.*; +import org.ldk.impl.version; +import java.io.File; +import java.io.InputStream; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.StandardCopyOption; public class bindings { public static class VecOrSliceDef { @@ -34,12 +42,41 @@ public class bindings { } } static { - System.loadLibrary(\"lightningjni\"); + try { + // Try to load natively first, this works on Android and in testing. + System.loadLibrary(\"lightningjni\"); + } catch (UnsatisfiedLinkError system_load_err) { + // Otherwise try to load from the library jar. + File tmpdir = new File(System.getProperty("java.io.tmpdir"), "ldk-java-nativelib"); + tmpdir.mkdir(); // If it fails to create, assume it was there already + tmpdir.deleteOnExit(); + String libname = "liblightningjni_" + System.getProperty("os.name").replaceAll(" ", "") + + "-" + System.getProperty("os.arch").replaceAll(" ", "") + ".nativelib"; + try (InputStream is = bindings.class.getResourceAsStream("/" + libname)) { + Path libpath = new File(tmpdir.toPath().toString(), "liblightningjni.so").toPath(); + Files.copy(is, libpath, StandardCopyOption.REPLACE_EXISTING); + Runtime.getRuntime().load(libpath.toString()); + } catch (Exception e) { + System.err.println("Failed to load LDK native library."); + System.err.println("System LDK native library load failed with: " + system_load_err); + System.err.println("Resource-based LDK native library load failed with: " + e); + throw new IllegalArgumentException(e); + } + } init(java.lang.Enum.class, VecOrSliceDef.class); init_class_cache(); + if (!get_lib_version_string().equals(version.get_ldk_java_bindings_version())) + throw new IllegalArgumentException("Compiled LDK library and LDK class failes do not match"); + // Fetching the LDK versions from C also checks that the header and binaries match + get_ldk_c_bindings_version(); + get_ldk_version(); } static native void init(java.lang.Class c, java.lang.Class slicedef); static native void init_class_cache(); + static native String get_lib_version_string(); + + public static native String get_ldk_c_bindings_version(); + public static native String get_ldk_version(); public static native boolean deref_bool(long ptr); public static native long deref_long(long ptr); @@ -54,12 +91,20 @@ public class bindings { public static native long new_empty_slice_vec(); """ + self.bindings_version_file = """package org.ldk.impl; + +public class version { + public static String get_ldk_java_bindings_version() { + return ""; + } +}""" self.bindings_footer = "}\n" self.util_fn_pfx = """package org.ldk.structs; import org.ldk.impl.bindings; import java.util.Arrays; +import javax.annotation.Nullable; import org.ldk.enums.*; public class UtilMethods { @@ -70,13 +115,14 @@ import java.util.LinkedList; class CommonBase { long ptr; LinkedList ptrs_to = new LinkedList(); - protected CommonBase(long ptr) { this.ptr = ptr; } - public long _test_only_get_ptr() { return this.ptr; } + protected CommonBase(long ptr) { assert ptr > 1024; this.ptr = ptr; } } """ - self.c_file_pfx = """#include \"org_ldk_impl_bindings.h\" -#include + self.c_file_pfx = """#include +// On OSX jlong (ie long long) is not equivalent to int64_t, so we override here +#define int64_t jlong +#include \"org_ldk_impl_bindings.h\" #include #include #include @@ -113,19 +159,32 @@ void __attribute__((constructor)) spawn_stderr_redirection() { else: self.c_file_pfx = self.c_file_pfx + "#define DEBUG_PRINT(...) fprintf(stderr, __VA_ARGS__)\n" - if not DEBUG: + if not DEBUG or sys.platform == "darwin": self.c_file_pfx = self.c_file_pfx + """#define MALLOC(a, _) malloc(a) -#define FREE(p) if ((long)(p) > 1024) { free(p); } -#define DO_ASSERT(a) (void)(a) +#define FREE(p) if ((uint64_t)(p) > 1024) { free(p); } +""" + if not DEBUG: + self.c_file_pfx += """#define DO_ASSERT(a) (void)(a) #define CHECK(a) """ - else: + if DEBUG: self.c_file_pfx = self.c_file_pfx + """#include // Always run a, then assert it is true: #define DO_ASSERT(a) do { bool _assert_val = (a); assert(_assert_val); } while(0) // Assert a is true or do nothing #define CHECK(a) DO_ASSERT(a) +void __attribute__((constructor)) debug_log_version() { + if (check_get_ldk_version() == NULL) + DEBUG_PRINT("LDK version did not match the header we built against\\n"); + if (check_get_ldk_bindings_version() == NULL) + DEBUG_PRINT("LDK C Bindings version did not match the header we built against\\n"); + DEBUG_PRINT("Loaded LDK-Java Bindings with LDK %s and LDK-C-Bindings %s\\n", check_get_ldk_version(), check_get_ldk_bindings_version()); +} +""" + + if sys.platform != "darwin": + self.c_file_pfx += """ // Running a leak check across all the allocations and frees of the JDK is a mess, // so instead we implement our own naive leak checker here, relying on the -wrap // linker option to wrap malloc/calloc/realloc/free, tracking everyhing allocated @@ -133,8 +192,8 @@ void __attribute__((constructor)) spawn_stderr_redirection() { #include """ - if self.target == Target.ANDROID: - self.c_file_pfx = self.c_file_pfx + """ + if self.target == Target.ANDROID: + self.c_file_pfx = self.c_file_pfx + """ #include #include @@ -175,14 +234,15 @@ void backtrace_symbols_fd(void ** buffer, int count, int _fd) { } } """ - else: - self.c_file_pfx = self.c_file_pfx + "#include \n" - self.c_file_pfx = self.c_file_pfx + """ + else: + self.c_file_pfx = self.c_file_pfx + "#include \n" + self.c_file_pfx = self.c_file_pfx + """ #include -static mtx_t allocation_mtx; +#include +static pthread_mutex_t allocation_mtx; void __attribute__((constructor)) init_mtx() { - DO_ASSERT(mtx_init(&allocation_mtx, mtx_plain) == thrd_success); + DO_ASSERT(!pthread_mutex_init(&allocation_mtx, NULL)); } #define BT_MAX 128 @@ -204,10 +264,10 @@ static void new_allocation(void* res, const char* struct_name, size_t len) { new_alloc->struct_name = struct_name; new_alloc->bt_len = backtrace(new_alloc->bt, BT_MAX); new_alloc->alloc_len = len; - DO_ASSERT(mtx_lock(&allocation_mtx) == thrd_success); + DO_ASSERT(!pthread_mutex_lock(&allocation_mtx)); new_alloc->next = allocation_ll; allocation_ll = new_alloc; - DO_ASSERT(mtx_unlock(&allocation_mtx) == thrd_success); + DO_ASSERT(!pthread_mutex_unlock(&allocation_mtx)); } static void* MALLOC(size_t len, const char* struct_name) { void* res = __real_malloc(len); @@ -217,7 +277,7 @@ static void* MALLOC(size_t len, const char* struct_name) { void __real_free(void* ptr); static void alloc_freed(void* ptr) { allocation* p = NULL; - DO_ASSERT(mtx_lock(&allocation_mtx) == thrd_success); + DO_ASSERT(!pthread_mutex_lock(&allocation_mtx)); allocation* it = allocation_ll; while (it->ptr != ptr) { p = it; it = it->next; @@ -227,17 +287,17 @@ static void alloc_freed(void* ptr) { int bt_len = backtrace(bt, BT_MAX); backtrace_symbols_fd(bt, bt_len, STDERR_FILENO); DEBUG_PRINT("\\n\\n"); - DO_ASSERT(mtx_unlock(&allocation_mtx) == thrd_success); + DO_ASSERT(!pthread_mutex_unlock(&allocation_mtx)); return; // addrsan should catch malloc-unknown and print more info than we have } } if (p) { p->next = it->next; } else { allocation_ll = it->next; } - DO_ASSERT(mtx_unlock(&allocation_mtx) == thrd_success); + DO_ASSERT(!pthread_mutex_unlock(&allocation_mtx)); DO_ASSERT(it->ptr == ptr); __real_free(it); } static void FREE(void* ptr) { - if ((long)ptr < 1024) return; // Rust loves to create pointers to the NULL page for dummys + if ((uint64_t)ptr < 1024) return; // Rust loves to create pointers to the NULL page for dummys alloc_freed(ptr); __real_free(ptr); } @@ -326,14 +386,14 @@ JNIEXPORT int64_t impl_bindings_bytes_1to_1u8_1vec (JNIEnv * env, jclass _b, jby vec->datalen = (*env)->GetArrayLength(env, bytes); vec->data = (uint8_t*)MALLOC(vec->datalen, "LDKCVec_u8Z Bytes"); (*env)->GetByteArrayRegion (env, bytes, 0, vec->datalen, vec->data); - return (long)vec; + return (uint64_t)vec; } JNIEXPORT jbyteArray JNICALL Java_org_ldk_impl_bindings_txpointer_1get_1buffer (JNIEnv * env, jclass _b, jlong ptr) { LDKTransaction *txdata = (LDKTransaction*)ptr; LDKu8slice slice; slice.data = txdata->data; slice.datalen = txdata->datalen; - return Java_org_ldk_impl_bindings_get_1u8_1slice_1bytes(env, _b, (long)&slice); + return Java_org_ldk_impl_bindings_get_1u8_1slice_1bytes(env, _b, (uint64_t)&slice); } JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_new_1txpointer_1copy_1data (JNIEnv * env, jclass _b, jbyteArray bytes) { LDKTransaction *txdata = (LDKTransaction*)MALLOC(sizeof(LDKTransaction), "LDKTransaction"); @@ -341,7 +401,7 @@ JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_new_1txpointer_1copy_1data txdata->data = (uint8_t*)MALLOC(txdata->datalen, "Tx Data Bytes"); txdata->data_is_owned = false; (*env)->GetByteArrayRegion (env, bytes, 0, txdata->datalen, txdata->data); - return (long)txdata; + return (uint64_t)txdata; } JNIEXPORT void JNICALL Java_org_ldk_impl_bindings_txpointer_1free (JNIEnv * env, jclass _b, jlong ptr) { LDKTransaction *tx = (LDKTransaction*)ptr; @@ -356,7 +416,7 @@ JNIEXPORT jlong JNICALL Java_org_ldk_impl_bindings_vec_1slice_1len (JNIEnv * env _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; + return (uint64_t)vec->datalen; } JNIEXPORT int64_t 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 @@ -367,7 +427,7 @@ JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_new_1empty_1slice_1vec (JNI LDKCVec_u8Z *vec = (LDKCVec_u8Z*)MALLOC(sizeof(LDKCVec_u8Z), "Empty LDKCVec"); vec->data = NULL; vec->datalen = 0; - return (long)vec; + return (uint64_t)vec; } // We assume that CVec_u8Z and u8slice are the same size and layout (and thus pointers to the two can be mixed) @@ -405,7 +465,18 @@ static inline LDKStr java_to_owned_str(JNIEnv *env, jstring str) { }; return res; } + +JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_get_1ldk_1c_1bindings_1version(JNIEnv *env, jclass _c) { + return str_ref_to_java(env, check_get_ldk_bindings_version(), strlen(check_get_ldk_bindings_version())); +} +JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_get_1ldk_1version(JNIEnv *env, jclass _c) { + return str_ref_to_java(env, check_get_ldk_version(), strlen(check_get_ldk_version())); +} +#include "version.c" """ + self.c_version_file = """JNIEXPORT jstring JNICALL Java_org_ldk_impl_bindings_get_1lib_1version_1string(JNIEnv *env, jclass _c) { + return str_ref_to_java(env, "", strlen("")); +}""" self.hu_struct_file_prefix = """package org.ldk.structs; @@ -413,6 +484,7 @@ import org.ldk.impl.bindings; import org.ldk.enums.*; import org.ldk.util.*; import java.util.Arrays; +import javax.annotation.Nullable; """ self.c_fn_ty_pfx = "JNIEXPORT " @@ -422,8 +494,27 @@ import java.util.Arrays; self.ptr_native_ty = "long" self.result_c_ty = "jclass" self.ptr_arr = "jobjectArray" + self.is_arr_some_check = ("", " != NULL") self.get_native_arr_len_call = ("(*env)->GetArrayLength(env, ", ")") + def construct_jenv(self): + res = "JNIEnv *env;\n" + res += "jint get_jenv_res = (*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6);\n" + res += "if (get_jenv_res == JNI_EDETACHED) {\n" + if self.target == Target.ANDROID: + res += "\tDO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, &env, NULL) == JNI_OK);\n" + else: + res += "\tDO_ASSERT((*j_calls->vm)->AttachCurrentThread(j_calls->vm, (void**)&env, NULL) == JNI_OK);\n" + res += "} else {\n" + res += "\tDO_ASSERT(get_jenv_res == JNI_OK);\n" + res += "}\n" + return res + def deconstruct_jenv(self): + res = "if (get_jenv_res == JNI_EDETACHED) {\n" + res += "\tDO_ASSERT((*j_calls->vm)->DetachCurrentThread(j_calls->vm) == JNI_OK);\n" + res += "}\n" + return res + def release_native_arr_ptr_call(self, ty_info, arr_var, arr_ptr_var): if ty_info.subty is None or not ty_info.subty.c_ty.endswith("Array"): return "(*env)->ReleasePrimitiveArrayCritical(env, " + arr_var + ", " + arr_ptr_var + ", 0)" @@ -497,7 +588,7 @@ import java.util.Arrays; out_java_enum = "package org.ldk.enums;\n\n" out_java = "" out_c = "" - out_c = out_c + "static inline " + struct_name + " " + struct_name + "_from_java(" + self.c_fn_args_pfx + ") {\n" + out_c = out_c + "static inline LDK" + struct_name + " LDK" + struct_name + "_from_java(" + self.c_fn_args_pfx + ") {\n" out_c = out_c + "\tswitch ((*env)->CallIntMethod(env, clz, ordinal_meth)) {\n" if enum_doc_comment is not None: @@ -526,7 +617,7 @@ import java.util.Arrays; out_c = out_c + "\t" + struct_name + "_" + var + " = (*env)->GetStaticFieldID(env, " + struct_name + "_class, \"" + var + "\", \"Lorg/ldk/enums/" + struct_name + ";\");\n" out_c = out_c + "\tCHECK(" + struct_name + "_" + var + " != NULL);\n" out_c = out_c + "}\n" - out_c = out_c + "static inline jclass " + struct_name + "_to_java(JNIEnv *env, " + struct_name + " val) {\n" + out_c = out_c + "static inline jclass LDK" + struct_name + "_to_java(JNIEnv *env, LDK" + struct_name + " val) {\n" out_c = out_c + "\tswitch (val) {\n" ord_v = 0 for var in variants: @@ -630,7 +721,7 @@ import java.util.Arrays; java_meths = [] for fn_line in field_fns: java_meth_descr = "(" - if fn_line.fn_name != "free" and fn_line.fn_name != "clone": + if fn_line.fn_name != "free" and fn_line.fn_name != "cloned": out_java = out_java + "\t\t " + fn_line.ret_ty_info.java_ty + " " + fn_line.fn_name + "(" java_trait_constr = java_trait_constr + "\t\t\t@Override public " + fn_line.ret_ty_info.java_ty + " " + fn_line.fn_name + "(" out_java_trait += "\t\t/**\n\t\t * " + fn_line.docs.replace("\n", "\n\t\t * ") + "\n\t\t */\n" @@ -723,7 +814,7 @@ import java.util.Arrays; # We're a supertrait out_c = out_c + "\t" + var[0] + "_JCalls* " + var[1] + ";\n" for fn in field_fns: - if fn.fn_name != "free" and fn.fn_name != "clone": + if fn.fn_name != "free" and fn.fn_name != "cloned": out_c = out_c + "\tjmethodID " + fn.fn_name + "_meth;\n" out_c = out_c + "} " + struct_name + "_JCalls;\n" @@ -732,14 +823,14 @@ import java.util.Arrays; 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" - out_c = out_c + "\t\tJNIEnv *env;\n" - out_c = out_c + "\t\tDO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);\n" + out_c += "\t\t" + self.construct_jenv().replace("\n", "\n\t\t").strip() + "\n" out_c = out_c + "\t\t(*env)->DeleteWeakGlobalRef(env, j_calls->o);\n" + out_c += "\t\t" + self.deconstruct_jenv().replace("\n", "\n\t\t").strip() + "\n" out_c = out_c + "\t\tFREE(j_calls);\n" out_c = out_c + "\t}\n}\n" for idx, fn_line in enumerate(field_fns): - if fn_line.fn_name != "free" and fn_line.fn_name != "clone": + if fn_line.fn_name != "free" and fn_line.fn_name != "cloned": assert fn_line.ret_ty_info.ty_info.get_full_rust_ty()[1] == "" out_c = out_c + fn_line.ret_ty_info.ty_info.get_full_rust_ty()[0] + " " + fn_line.fn_name + "_" + struct_name + "_jcall(" if fn_line.self_is_const: @@ -752,8 +843,7 @@ import java.util.Arrays; out_c = out_c + ") {\n" out_c = out_c + "\t" + struct_name + "_JCalls *j_calls = (" + struct_name + "_JCalls*) this_arg;\n" - out_c = out_c + "\tJNIEnv *env;\n" - out_c = out_c + "\tDO_ASSERT((*j_calls->vm)->GetEnv(j_calls->vm, (void**)&env, JNI_VERSION_1_6) == JNI_OK);\n" + out_c += "\t" + self.construct_jenv().replace("\n", "\n\t").strip() + "\n" for arg_info in fn_line.args_ty: if arg_info.ret_conv is not None: @@ -764,10 +854,15 @@ import java.util.Arrays; out_c = out_c + "\tjobject obj = (*env)->NewLocalRef(env, j_calls->o);\n\tCHECK(obj != NULL);\n" if fn_line.ret_ty_info.c_ty.endswith("Array"): out_c = out_c + "\t" + fn_line.ret_ty_info.c_ty + " ret = (*env)->CallObjectMethod(env, obj, j_calls->" + fn_line.fn_name + "_meth" + elif fn_line.ret_ty_info.c_ty == "void": + out_c += "\t(*env)->Call" + fn_line.ret_ty_info.java_ty.title() + "Method(env, obj, j_calls->" + fn_line.fn_name + "_meth" + elif fn_line.ret_ty_info.java_ty == "String": + # Manually write out String methods as they're just an Object + out_c += "\t" + fn_line.ret_ty_info.c_ty + " ret = (*env)->CallObjectMethod(env, obj, j_calls->" + fn_line.fn_name + "_meth" elif not fn_line.ret_ty_info.passed_as_ptr: - out_c = out_c + "\treturn (*env)->Call" + fn_line.ret_ty_info.java_ty.title() + "Method(env, obj, j_calls->" + fn_line.fn_name + "_meth" + out_c += "\t" + fn_line.ret_ty_info.c_ty + " ret = (*env)->Call" + fn_line.ret_ty_info.java_ty.title() + "Method(env, obj, j_calls->" + fn_line.fn_name + "_meth" else: - out_c = out_c + "\t" + fn_line.ret_ty_info.rust_obj + "* ret = (" + fn_line.ret_ty_info.rust_obj + "*)(*env)->CallLongMethod(env, obj, j_calls->" + fn_line.fn_name + "_meth" + out_c = out_c + "\tuint64_t ret = (*env)->CallLongMethod(env, obj, j_calls->" + fn_line.fn_name + "_meth" for idx, arg_info in enumerate(fn_line.args_ty): if arg_info.ret_conv is not None: @@ -775,20 +870,36 @@ import java.util.Arrays; else: out_c = out_c + ", " + arg_info.arg_name out_c = out_c + ");\n" + + out_c += "\tif ((*env)->ExceptionCheck(env)) {\n" + out_c += "\t\t(*env)->ExceptionDescribe(env);\n" + out_c += "\t\t(*env)->FatalError(env, \"A call to " + fn_line.fn_name + " in " + struct_name + " from rust threw an exception.\");\n" + out_c += "\t}\n" + if fn_line.ret_ty_info.arg_conv is not None: - out_c = out_c + "\t" + fn_line.ret_ty_info.arg_conv.replace("\n", "\n\t") + "\n\treturn " + fn_line.ret_ty_info.arg_conv_name + ";\n" + out_c += "\t" + fn_line.ret_ty_info.arg_conv.replace("\n", "\n\t") + "\n" + out_c += "\t" + self.deconstruct_jenv().replace("\n", "\n\t").strip() + "\n" + out_c += "\treturn " + fn_line.ret_ty_info.arg_conv_name + ";\n" + else: + out_c += "\t" + self.deconstruct_jenv().replace("\n", "\n\t").strip() + "\n" + if not fn_line.ret_ty_info.passed_as_ptr and fn_line.ret_ty_info.c_ty != "void": + out_c += "\treturn ret;\n" out_c = out_c + "}\n" - # Write out a clone function whether we need one or not, as we use them in moving to rust - out_c = out_c + "static void* " + struct_name + "_JCalls_clone(const void* this_arg) {\n" - out_c = out_c + "\t" + struct_name + "_JCalls *j_calls = (" + struct_name + "_JCalls*) this_arg;\n" - out_c = out_c + "\tatomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);\n" + # If we can, write out a clone function whether we need one or not, as we use them in moving to rust + can_clone_with_ptr = True for var in field_vars: - if not isinstance(var, ConvInfo): - out_c = out_c + "\tatomic_fetch_add_explicit(&j_calls->" + var[1] + "->refcnt, 1, memory_order_release);\n" - out_c = out_c + "\treturn (void*) this_arg;\n" - out_c = out_c + "}\n" + if isinstance(var, ConvInfo): + can_clone_with_ptr = False + if can_clone_with_ptr: + out_c = out_c + "static void " + struct_name + "_JCalls_cloned(" + struct_name + "* new_obj) {\n" + out_c = out_c + "\t" + struct_name + "_JCalls *j_calls = (" + struct_name + "_JCalls*) new_obj->this_arg;\n" + out_c = out_c + "\tatomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);\n" + for var in field_vars: + if not isinstance(var, ConvInfo): + 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 (" + self.c_fn_args_pfx + ", jobject o" for var in flattened_field_vars: @@ -806,7 +917,7 @@ import java.util.Arrays; out_c = out_c + "\tcalls->o = (*env)->NewWeakGlobalRef(env, o);\n" for (fn_name, java_meth_descr) in java_meths: - if fn_name != "free" and fn_name != "clone": + if fn_name != "free" and fn_name != "cloned": out_c = out_c + "\tcalls->" + fn_name + "_meth = (*env)->GetMethodID(env, c, \"" + fn_name + "\", \"" + java_meth_descr + "\");\n" out_c = out_c + "\tCHECK(calls->" + fn_name + "_meth != NULL);\n" @@ -816,12 +927,12 @@ import java.util.Arrays; out_c = out_c + "\n\t" + struct_name + " ret = {\n" out_c = out_c + "\t\t.this_arg = (void*) calls,\n" for fn_line in field_fns: - if fn_line.fn_name != "free" and fn_line.fn_name != "clone": + if fn_line.fn_name != "free" and fn_line.fn_name != "cloned": out_c = out_c + "\t\t." + fn_line.fn_name + " = " + fn_line.fn_name + "_" + struct_name + "_jcall,\n" elif fn_line.fn_name == "free": out_c = out_c + "\t\t.free = " + struct_name + "_JCalls_free,\n" else: - out_c = out_c + "\t\t.clone = " + struct_name + "_JCalls_clone,\n" + out_c = out_c + "\t\t.cloned = " + struct_name + "_JCalls_cloned,\n" for var in field_vars: if isinstance(var, ConvInfo): if var.arg_conv_name is not None: @@ -860,15 +971,37 @@ import java.util.Arrays; else: out_c = out_c + ", " + var[1] out_c = out_c + ");\n" - out_c = out_c + "\treturn (long)res_ptr;\n" + out_c = out_c + "\treturn (uint64_t)res_ptr;\n" out_c = out_c + "}\n" + for var in flattened_field_vars: + if not isinstance(var, ConvInfo): + out_java_trait += "\n\t/**\n" + out_java_trait += "\t * Gets the underlying " + var[1] + ".\n" + out_java_trait += "\t */\n" + underscore_name = ''.join('_' + c.lower() if c.isupper() else c for c in var[1]).strip('_') + out_java_trait += "\tpublic " + var[1] + " get_" + underscore_name + "() {\n" + out_java_trait += "\t\t" + var[1] + " res = new " + var[1] + "(null, bindings." + struct_name + "_get_" + var[1] + "(this.ptr));\n" + out_java_trait += "\t\tthis.ptrs_to.add(res);\n" + out_java_trait += "\t\treturn res;\n" + out_java_trait += "\t}\n" + out_java_trait += "\n" + + out_java += "\tpublic static native long " + struct_name + "_get_" + var[1] + "(long arg);\n" + + out_c += "JNIEXPORT int64_t JNICALL Java_org_ldk_impl_bindings_" + struct_name + "_1get_1" + var[1] + "(JNIEnv *env, jclass clz, int64_t arg) {\n" + out_c += "\t" + struct_name + " *inp = (" + struct_name + " *)(arg & ~1);\n" + out_c += "\tuint64_t res_ptr = (uint64_t)&inp->" + var[1] + ";\n" + out_c += "\tDO_ASSERT((res_ptr & 1) == 0);\n" + out_c += "\treturn (int64_t)(res_ptr | 1);\n" + out_c += "}\n" + return (out_java, out_java_trait, out_c) def trait_struct_inc_refcnt(self, ty_info): base_conv = "\nif (" + ty_info.var_name + "_conv.free == " + ty_info.rust_obj + "_JCalls_free) {\n" base_conv = base_conv + "\t// If this_arg is a JCalls struct, then we need to increment the refcnt in it.\n" - base_conv = base_conv + "\t" + ty_info.rust_obj + "_JCalls_clone(" + ty_info.var_name + "_conv.this_arg);\n}" + base_conv = base_conv + "\t" + ty_info.rust_obj + "_JCalls_cloned(&" + ty_info.var_name + "_conv);\n}" return base_conv def map_complex_enum(self, struct_name, variant_list, camel_to_snake, enum_doc_comment): @@ -904,9 +1037,25 @@ import java.util.Arrays; init_meth_params = "" init_meth_body = "" hu_conv_body = "" - for idx, field_ty in enumerate(var.fields): - out_java += ("\t\t\tpublic " + field_ty.java_ty + " " + field_ty.arg_name + ";\n") - java_hu_subclasses = java_hu_subclasses + "\t\tpublic final " + field_ty.java_hu_ty + " " + field_ty.arg_name + ";\n" + for idx, (field_ty, field_docs) in enumerate(var.fields): + if idx > 0: + init_meth_params = init_meth_params + ", " + + if field_ty.java_hu_ty == var.var_name: + field_path = field_ty.java_fn_ty_arg.strip("L;").replace("/", ".") + out_java += "\t\t\tpublic " + field_path + " " + field_ty.arg_name + ";\n" + java_hu_subclasses = java_hu_subclasses + "\t\tpublic final " + field_path + " " + field_ty.arg_name + ";\n" + init_meth_params = init_meth_params + field_path + " " + field_ty.arg_name + else: + out_java += "\t\t\tpublic " + field_ty.java_ty + " " + field_ty.arg_name + ";\n" + if field_docs is not None: + java_hu_subclasses += "\t\t/**\n\t\t * " + field_docs.replace("\n", "\n\t\t * ") + "\n\t\t*/\n" + java_hu_subclasses += "\t\t" + if field_ty.nullable: + java_hu_subclasses += "@Nullable " + java_hu_subclasses += "public final " + field_ty.java_hu_ty + " " + field_ty.arg_name + ";\n" + init_meth_params = init_meth_params + field_ty.java_ty + " " + field_ty.arg_name + init_meth_body = init_meth_body + "this." + field_ty.arg_name + " = " + field_ty.arg_name + "; " if field_ty.to_hu_conv is not None: hu_conv_body = hu_conv_body + "\t\t\t" + field_ty.java_ty + " " + field_ty.arg_name + " = obj." + field_ty.arg_name + ";\n" hu_conv_body = hu_conv_body + "\t\t\t" + field_ty.to_hu_conv.replace("\n", "\n\t\t\t") + "\n" @@ -914,10 +1063,6 @@ import java.util.Arrays; else: hu_conv_body = hu_conv_body + "\t\t\tthis." + field_ty.arg_name + " = obj." + field_ty.arg_name + ";\n" init_meth_jty_str = init_meth_jty_str + field_ty.java_fn_ty_arg - if idx > 0: - init_meth_params = init_meth_params + ", " - init_meth_params = init_meth_params + field_ty.java_ty + " " + field_ty.arg_name - init_meth_body = init_meth_body + "this." + field_ty.arg_name + " = " + field_ty.arg_name + "; " out_java += ("\t\t\t" + var.var_name + "(" + init_meth_params + ") { ") out_java += (init_meth_body) out_java += ("}\n") @@ -942,7 +1087,7 @@ import java.util.Arrays; for var in variant_list: out_c += ("\t\tcase " + struct_name + "_" + var.var_name + ": {\n") c_params = [] - for idx, field_map in enumerate(var.fields): + for idx, (field_map, field_docs) in enumerate(var.fields): if field_map.ret_conv is not None: out_c += ("\t\t\t" + field_map.ret_conv[0].replace("\n", "\n\t\t\t")) if var.tuple_variant: @@ -967,11 +1112,12 @@ import java.util.Arrays; out_opaque_struct_human += self.hu_struct_file_prefix out_opaque_struct_human += "\n/**\n * " + struct_doc_comment.replace("\n", "\n * ") + "\n */\n" out_opaque_struct_human += "@SuppressWarnings(\"unchecked\") // We correctly assign various generic arrays\n" - out_opaque_struct_human += ("public class " + struct_name.replace("LDK","") + " extends CommonBase") + hu_name = struct_name.replace("LDKC2Tuple", "TwoTuple").replace("LDKC3Tuple", "ThreeTuple").replace("LDK", "") + out_opaque_struct_human += ("public class " + hu_name + " extends CommonBase") if struct_name.startswith("LDKLocked"): out_opaque_struct_human += (" implements AutoCloseable") out_opaque_struct_human += (" {\n") - out_opaque_struct_human += ("\t" + struct_name.replace("LDK", "") + "(Object _dummy, long ptr) { super(ptr); }\n") + out_opaque_struct_human += ("\t" + hu_name + "(Object _dummy, long ptr) { super(ptr); }\n") if struct_name.startswith("LDKLocked"): out_opaque_struct_human += ("\t@Override public void close() {\n") else: @@ -982,8 +1128,10 @@ import java.util.Arrays; out_opaque_struct_human += ("\t}\n\n") return out_opaque_struct_human + def map_tuple(self, struct_name): + return self.map_opaque_struct(struct_name, "A Tuple") - def map_function(self, argument_types, c_call_string, method_name, return_type_info, struct_meth, default_constructor_args, takes_self, args_known, type_mapping_generator, doc_comment): + 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 = "" out_c = "" out_java_struct = None @@ -1010,29 +1158,40 @@ import java.util.Arrays; if not args_known: out_java_struct += ("\t// Skipped " + method_name + "\n") else: - meth_n = method_name[len(struct_meth) + 1:].strip("_") if doc_comment is not None: out_java_struct += "\t/**\n\t * " + doc_comment.replace("\n", "\n\t * ") + "\n\t */\n" + if return_type_info.nullable: + out_java_struct += "\t@Nullable\n" if not takes_self: - out_java_struct += ( - "\tpublic static " + return_type_info.java_hu_ty + " constructor_" + meth_n + "(") + if meth_n == "new": + out_java_struct += "\tpublic static " + return_type_info.java_hu_ty + " of(" + elif meth_n == "default": + out_java_struct += "\tpublic static " + return_type_info.java_hu_ty + " with_default(" + else: + out_java_struct += "\tpublic static " + return_type_info.java_hu_ty + " " + meth_n + "(" else: out_java_struct += ("\tpublic " + return_type_info.java_hu_ty + " " + meth_n + "(") for idx, arg in enumerate(argument_types): if idx != 0: if not takes_self or idx > 1: - out_java_struct += (", ") + out_java_struct += ", " elif takes_self: continue if arg.java_ty != "void": if arg.arg_name in default_constructor_args: + assert not arg.nullable for explode_idx, explode_arg in enumerate(default_constructor_args[arg.arg_name]): if explode_idx != 0: out_java_struct += (", ") out_java_struct += ( explode_arg.java_hu_ty + " " + arg.arg_name + "_" + explode_arg.arg_name) else: - out_java_struct += (arg.java_hu_ty + " " + arg.arg_name) + if arg.nullable: + out_java_struct += "@Nullable " + ty_string = arg.java_hu_ty + if arg.java_fn_ty_arg[0] == "L" and arg.java_fn_ty_arg[len(arg.java_fn_ty_arg) - 1] == ";": + ty_string = arg.java_fn_ty_arg.strip("L;").replace("/", ".") + out_java_struct += ty_string + " " + arg.arg_name out_java += (");\n") out_c += (") {\n") if out_java_struct is not None: @@ -1098,6 +1257,9 @@ import java.util.Arrays; else: out_java_struct += (info.arg_name) out_java_struct += (");\n") + if return_type_info.java_ty == "long" and return_type_info.java_hu_ty != "long": + out_java_struct += "\t\tif (ret < 1024) { return null; }\n" + if return_type_info.to_hu_conv is not None: if not takes_self: out_java_struct += ("\t\t" + return_type_info.to_hu_conv.replace("\n", "\n\t\t").replace("this", @@ -1122,6 +1284,8 @@ import java.util.Arrays; else: out_java_struct += ("\t\t" + info.from_hu_conv[1].replace("\n", "\n\t\t") + ";\n") + if takes_self and not takes_self_as_ref: + out_java_struct += "\t\t" + argument_types[0].from_hu_conv[1].replace("\n", "\n\t\t").replace("this_arg", "this") + ";\n" if return_type_info.to_hu_conv_name is not None: out_java_struct += ("\t\treturn " + return_type_info.to_hu_conv_name + ";\n") elif return_type_info.java_ty != "void" and return_type_info.rust_obj != "LDK" + struct_meth: