X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=java_strings.py;h=af7672b00b53676af0c8c58d6553e034232a4894;hb=e3b8d99ecdfd932e009456d4eb8ea01365795223;hp=d827da9e05f62d586e0605568cdb8c579b2ab64f;hpb=1b870a3ffab1c0024411e30102bc6d198300f095;p=ldk-java diff --git a/java_strings.py b/java_strings.py index d827da9e..af7672b0 100644 --- a/java_strings.py +++ b/java_strings.py @@ -197,6 +197,9 @@ void __wrap_reallocarray(void* ptr, size_t new_sz) { void __attribute__((destructor)) check_leaks() { size_t alloc_count = 0; size_t alloc_size = 0; + fprintf(stderr, "The following LDK-allocated blocks still remain.\\n"); + fprintf(stderr, "Note that this is only accurate if System.gc(); System.runFinalization()\\n"); + fprintf(stderr, "was called prior to exit after all LDK objects were out of scope.\\n"); for (allocation* a = allocation_ll; a != NULL; a = a->next) { fprintf(stderr, "%s %p (%lu bytes) remains:\\n", a->struct_name, a->ptr, a->alloc_len); backtrace_symbols_fd(a->bt, a->bt_len, STDERR_FILENO); @@ -205,7 +208,8 @@ void __attribute__((destructor)) check_leaks() { alloc_size += a->alloc_len; } fprintf(stderr, "%lu allocations remained for %lu bytes.\\n", alloc_count, alloc_size); - DO_ASSERT(allocation_ll == NULL); + fprintf(stderr, "Note that this is only accurate if System.gc(); System.runFinalization()\\n"); + fprintf(stderr, "was called prior to exit after all LDK objects were out of scope.\\n"); } """ self.c_file_pfx = self.c_file_pfx + """ @@ -387,10 +391,10 @@ import java.util.Arrays; def init_str(self): res = "" - for ty in self.c_array_class_caches: + for ty in sorted(self.c_array_class_caches): res = res + "static jclass " + ty + "_clz = NULL;\n" res = res + "JNIEXPORT void Java_org_ldk_impl_bindings_init_1class_1cache(JNIEnv * env, jclass clz) {\n" - for ty in self.c_array_class_caches: + for ty in sorted(self.c_array_class_caches): res = res + "\t" + ty + "_clz = (*env)->FindClass(env, \"" + ty.replace("arr_of_", "[") + "\");\n" res = res + "\tCHECK(" + ty + "_clz != NULL);\n" res = res + "\t" + ty + "_clz = (*env)->NewGlobalRef(env, " + ty + "_clz);\n" @@ -475,7 +479,7 @@ import java.util.Arrays; ret = ret + ", " + param return ret + ")" - def native_c_map_trait(self, struct_name, field_vars, field_fns, trait_doc_comment): + def native_c_map_trait(self, struct_name, field_vars, flattened_field_vars, field_fns, trait_doc_comment): out_java_trait = "" out_java = "" @@ -488,14 +492,14 @@ import java.util.Arrays; out_java_trait = out_java_trait + "\tfinal bindings." + struct_name + " bindings_instance;\n" out_java_trait = out_java_trait + "\t" + struct_name.replace("LDK", "") + "(Object _dummy, long ptr) { super(ptr); bindings_instance = null; }\n" out_java_trait = out_java_trait + "\tprivate " + struct_name.replace("LDK", "") + "(bindings." + struct_name + " arg" - for var in field_vars: + for var in flattened_field_vars: if isinstance(var, ConvInfo): out_java_trait = out_java_trait + ", " + var.java_hu_ty + " " + var.arg_name else: out_java_trait = out_java_trait + ", bindings." + var[0] + " " + var[1] out_java_trait = out_java_trait + ") {\n" out_java_trait = out_java_trait + "\t\tsuper(bindings." + struct_name + "_new(arg" - for var in field_vars: + for var in flattened_field_vars: if isinstance(var, ConvInfo): if var.from_hu_conv is not None: out_java_trait = out_java_trait + ", " + var.from_hu_conv[0] @@ -505,7 +509,7 @@ import java.util.Arrays; out_java_trait = out_java_trait + ", " + var[1] out_java_trait = out_java_trait + "));\n" out_java_trait = out_java_trait + "\t\tthis.ptrs_to.add(arg);\n" - for var in field_vars: + for var in flattened_field_vars: if isinstance(var, ConvInfo): if var.from_hu_conv is not None and var.from_hu_conv[1] != "": out_java_trait = out_java_trait + "\t\t" + var.from_hu_conv[1].replace("\n", "\n\t\t") + ";\n" @@ -520,7 +524,7 @@ import java.util.Arrays; java_trait_constr = "\tprivate static class " + struct_name + "Holder { " + struct_name.replace("LDK", "") + " held; }\n" java_trait_constr = java_trait_constr + "\tpublic static " + struct_name.replace("LDK", "") + " new_impl(" + struct_name.replace("LDK", "") + "Interface arg" - for var in field_vars: + for var in flattened_field_vars: if isinstance(var, ConvInfo): java_trait_constr = java_trait_constr + ", " + var.java_hu_ty + " " + var.arg_name else: @@ -589,14 +593,25 @@ import java.util.Arrays; if isinstance(var, ConvInfo): java_trait_constr = java_trait_constr + ", " + var.arg_name else: - java_trait_constr = java_trait_constr + ", " + var[1] + ".new_impl(" + var[1] + "_impl).bindings_instance" + java_trait_constr += ", " + var[1] + ".new_impl(" + var[1] + "_impl" + for suparg in var[2]: + if isinstance(suparg, ConvInfo): + java_trait_constr += ", " + suparg.arg_name + else: + java_trait_constr += ", " + suparg[1] + java_trait_constr += ").bindings_instance" + for suparg in var[2]: + if isinstance(suparg, ConvInfo): + java_trait_constr += ", " + suparg.arg_name + else: + java_trait_constr += ", " + suparg[1] out_java_trait = out_java_trait + "\t}\n" out_java_trait = out_java_trait + java_trait_constr + ");\n\t\treturn impl_holder.held;\n\t}\n" out_java = out_java + "\t}\n" out_java = out_java + "\tpublic static native long " + struct_name + "_new(" + struct_name + " impl" - for var in field_vars: + for var in flattened_field_vars: if isinstance(var, ConvInfo): out_java = out_java + ", " + var.java_ty + " " + var.arg_name else: @@ -608,7 +623,7 @@ import java.util.Arrays; out_c = out_c + "\tatomic_size_t refcnt;\n" out_c = out_c + "\tJavaVM *vm;\n" out_c = out_c + "\tjweak o;\n" - for var in field_vars: + for var in flattened_field_vars: if isinstance(var, ConvInfo): # We're a regular ol' field pass @@ -634,7 +649,7 @@ import java.util.Arrays; for idx, fn_line in enumerate(field_fns): if fn_line.fn_name != "free" and fn_line.fn_name != "clone": 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 + "_jcall(" + 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: out_c = out_c + "const void* this_arg" else: @@ -684,7 +699,7 @@ import java.util.Arrays; 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 field_vars: + for var in flattened_field_vars: if isinstance(var, ConvInfo): out_c = out_c + ", " + var.c_ty + " " + var.arg_name else: @@ -703,14 +718,14 @@ import java.util.Arrays; 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" - for var in field_vars: + for var in flattened_field_vars: if isinstance(var, ConvInfo) and var.arg_conv is not None: out_c = out_c + "\n\t" + var.arg_conv.replace("\n", "\n\t") +"\n" 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": - out_c = out_c + "\t\t." + fn_line.fn_name + " = " + fn_line.fn_name + "_jcall,\n" + 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: @@ -724,16 +739,22 @@ import java.util.Arrays; out_c = out_c + "\t\t." + var.var_name + " = " + var.var_name + ",\n" out_c = out_c + "\t\t.set_" + var.var_name + " = NULL,\n" else: - out_c = out_c + "\t\t." + var[1] + " = " + var[0] + "_init(env, clz, " + var[1] + "),\n" + out_c += "\t\t." + var[1] + " = " + var[0] + "_init(env, clz, " + var[1] + for suparg in var[2]: + if isinstance(suparg, ConvInfo): + out_c = out_c + ", " + suparg.arg_name + else: + out_c = out_c + ", " + suparg[1] + out_c += "),\n" out_c = out_c + "\t};\n" - for var in field_vars: + for var in flattened_field_vars: if not isinstance(var, ConvInfo): out_c = out_c + "\tcalls->" + var[1] + " = ret." + var[1] + ".this_arg;\n" out_c = out_c + "\treturn ret;\n" out_c = out_c + "}\n" out_c = out_c + self.c_fn_ty_pfx + "int64_t " + self.c_fn_name_define_pfx(struct_name + "_new", True) + "jobject o" - for var in field_vars: + for var in flattened_field_vars: if isinstance(var, ConvInfo): out_c = out_c + ", " + var.c_ty + " " + var.arg_name else: @@ -741,7 +762,7 @@ import java.util.Arrays; out_c = out_c + ") {\n" out_c = out_c + "\t" + struct_name + " *res_ptr = MALLOC(sizeof(" + struct_name + "), \"" + struct_name + "\");\n" out_c = out_c + "\t*res_ptr = " + struct_name + "_init(env, clz, o" - for var in field_vars: + for var in flattened_field_vars: if isinstance(var, ConvInfo): out_c = out_c + ", " + var.arg_name else: @@ -759,7 +780,7 @@ import java.util.Arrays; return base_conv def map_complex_enum(self, struct_name, variant_list, camel_to_snake, enum_doc_comment): - java_hu_type = struct_name.replace("LDK", "") + java_hu_type = struct_name.replace("LDK", "").replace("COption", "Option") out_java_enum = "" out_java = "" out_c = "" @@ -772,7 +793,7 @@ import java.util.Arrays; out_java_enum += ("\t@Override @SuppressWarnings(\"deprecation\")\n") out_java_enum += ("\tprotected void finalize() throws Throwable {\n") out_java_enum += ("\t\tsuper.finalize();\n") - out_java_enum += ("\t\tif (ptr != 0) { bindings." + java_hu_type + "_free(ptr); }\n") + out_java_enum += ("\t\tif (ptr != 0) { bindings." + struct_name.replace("LDK", "") + "_free(ptr); }\n") out_java_enum += ("\t}\n") out_java_enum += ("\tstatic " + java_hu_type + " constr_from_ptr(long ptr) {\n") out_java_enum += ("\t\tbindings." + struct_name + " raw_val = bindings." + struct_name + "_ref_from_ptr(ptr);\n") @@ -824,7 +845,7 @@ import java.util.Arrays; out_c += (self.c_complex_enum_pfx(struct_name, [x.var_name for x in variant_list], init_meth_jty_strs)) out_c += (self.c_fn_ty_pfx + self.c_complex_enum_pass_ty(struct_name) + " " + self.c_fn_name_define_pfx(struct_name + "_ref_from_ptr", True) + self.ptr_c_ty + " ptr) {\n") - out_c += ("\t" + struct_name + " *obj = (" + struct_name + "*)ptr;\n") + out_c += ("\t" + struct_name + " *obj = (" + struct_name + "*)(ptr & ~1);\n") out_c += ("\tswitch(obj->tag) {\n") for var in variant_list: out_c += ("\t\tcase " + struct_name + "_" + var.var_name + ": {\n") @@ -832,16 +853,21 @@ import java.util.Arrays; for idx, field_map 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")) - out_c += ("obj->" + camel_to_snake(var.var_name) + "." + field_map.arg_name) + if var.tuple_variant: + out_c += "obj->" + camel_to_snake(var.var_name) + else: + out_c += "obj->" + camel_to_snake(var.var_name) + "." + field_map.arg_name out_c += (field_map.ret_conv[1].replace("\n", "\n\t\t\t") + "\n") c_params.append(field_map.ret_conv_name) else: - c_params.append("obj->" + camel_to_snake(var.var_name) + "." + field_map.arg_name) + if var.tuple_variant: + c_params.append("obj->" + camel_to_snake(var.var_name)) + else: + c_params.append("obj->" + camel_to_snake(var.var_name) + "." + field_map.arg_name) out_c += ("\t\t\treturn " + self.c_constr_native_complex_enum(struct_name, var.var_name, c_params) + ";\n") out_c += ("\t\t}\n") out_c += ("\t\tdefault: abort();\n") out_c += ("\t}\n}\n") - out_java_enum += ("}\n") return (out_java, out_java_enum, out_c) def map_opaque_struct(self, struct_name, struct_doc_comment): @@ -892,7 +918,7 @@ 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:] + 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 not takes_self: