X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=java_strings.py;h=3d5a2a0150cd1c5680d6a51495e27183a93e5ba9;hb=4adc27e9bf581b4f5edd148e12d7c344381d0f46;hp=1987c10e58db6d3915cdf7e2ba7f8fe1aafb1a2f;hpb=798362a31590a4c5626db086566c083088ef0861;p=ldk-java diff --git a/java_strings.py b/java_strings.py index 1987c10e..3d5a2a01 100644 --- a/java_strings.py +++ b/java_strings.py @@ -126,7 +126,7 @@ void __attribute__((constructor)) spawn_stderr_redirection() { if not DEBUG: self.c_file_pfx = self.c_file_pfx + """#define MALLOC(a, _) malloc(a) -#define FREE(p) if ((long)(p) > 1024) { free(p); } +#define FREE(p) if ((uint64_t)(p) > 1024) { free(p); } #define DO_ASSERT(a) (void)(a) #define CHECK(a) """ @@ -256,7 +256,7 @@ static void alloc_freed(void* 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); } @@ -345,14 +345,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"); @@ -360,7 +360,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; @@ -375,7 +375,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 @@ -386,7 +386,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) @@ -453,6 +453,24 @@ import java.util.Arrays; self.ptr_arr = "jobjectArray" 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)" @@ -526,7 +544,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: @@ -555,7 +573,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: @@ -761,9 +779,9 @@ 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" @@ -781,8 +799,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: @@ -793,8 +810,10 @@ 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 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" @@ -805,7 +824,13 @@ import java.util.Arrays; out_c = out_c + ", " + arg_info.arg_name out_c = out_c + ");\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" @@ -889,7 +914,7 @@ 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" return (out_java, out_java_trait, out_c) @@ -934,8 +959,19 @@ import java.util.Arrays; 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" + 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" + java_hu_subclasses = java_hu_subclasses + "\t\tpublic 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" @@ -943,10 +979,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") @@ -1012,7 +1044,7 @@ import java.util.Arrays; return out_opaque_struct_human - 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, 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 @@ -1039,18 +1071,22 @@ 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("_") + meth_n = method_name[len(struct_meth) + 1 if len(struct_meth) != 0 else 0:].strip("_") if doc_comment is not None: out_java_struct += "\t/**\n\t * " + doc_comment.replace("\n", "\n\t * ") + "\n\t */\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": @@ -1151,6 +1187,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: