elif fn_arg.startswith("uint16_t"):
mapped_type = consts.c_type_map['uint16_t']
java_ty = mapped_type[0]
- c_ty = "jshort"
+ c_ty = "int16_t"
fn_ty_arg = "S"
fn_arg = fn_arg[8:].strip()
is_primitive = True
is_primitive = True
elif fn_arg.startswith("uint64_t") or fn_arg.startswith("uintptr_t"):
# TODO: uintptr_t is arch-dependent :(
- mapped_type = consts.c_type_map['long']
+ mapped_type = consts.c_type_map['uint64_t']
java_ty = mapped_type[0]
- c_ty = "int64_t"
fn_ty_arg = "J"
if fn_arg.startswith("uint64_t"):
+ c_ty = "int64_t"
fn_arg = fn_arg[8:].strip()
else:
+ c_ty = "intptr_t"
fn_arg = fn_arg[9:].strip()
is_primitive = True
elif is_const and fn_arg.startswith("char *"):
reg_fn_regex = re.compile("([A-Za-z_0-9\* ]* \*?)([a-zA-Z_0-9]*)\((.*)\);$")
clone_fns = set()
constructor_fns = {}
-c_array_class_caches = set()
-
from gen_type_mapping import TypeMappingGenerator
-type_mapping_generator = TypeMappingGenerator(java_c_types, consts, c_array_class_caches, opaque_structs, clone_fns, unitary_enums, trait_structs, complex_enums, result_types, tuple_types)
-
-
+type_mapping_generator = TypeMappingGenerator(java_c_types, consts, opaque_structs, clone_fns, unitary_enums, trait_structs, complex_enums, result_types, tuple_types)
with open(sys.argv[1]) as in_h:
for line in in_h:
can_clone = False
out_java.write("\tpublic static native boolean " + struct_name + "_result_ok(long arg);\n")
- write_c(consts.c_fn_ty_pfx + "jboolean " + consts.c_fn_name_pfx + struct_name.replace("_", "_1") + "_1result_1ok (" + consts.c_fn_args_pfx + ", " + consts.ptr_c_ty + " arg) {\n")
+ write_c(consts.c_fn_ty_pfx + "jboolean " + consts.c_fn_name_define_pfx(struct_name + "_result_ok", True) + consts.ptr_c_ty + " arg) {\n")
write_c("\treturn ((" + struct_name + "*)arg)->result_ok;\n")
write_c("}\n")
out_java.write("\tpublic static native " + res_map.java_ty + " " + struct_name + "_get_ok(long arg);\n")
- write_c(consts.c_fn_ty_pfx + res_map.c_ty + " " + consts.c_fn_name_pfx + struct_name.replace("_", "_1") + "_1get_1ok (" + consts.c_fn_args_pfx + ", " + consts.ptr_c_ty + " arg) {\n")
+ write_c(consts.c_fn_ty_pfx + res_map.c_ty + " " + consts.c_fn_name_define_pfx(struct_name + "_get_ok", True) + consts.ptr_c_ty + " arg) {\n")
write_c("\t" + struct_name + " *val = (" + struct_name + "*)arg;\n")
write_c("\tCHECK(val->result_ok);\n\t")
out_java_struct.write("\tpublic static final class " + human_ty + "_OK extends " + human_ty + " {\n")
out_java_struct.write("\t\t}\n\t}\n\n")
out_java.write("\tpublic static native " + err_map.java_ty + " " + struct_name + "_get_err(long arg);\n")
- write_c(consts.c_fn_ty_pfx + err_map.c_ty + " " + consts.c_fn_name_pfx + struct_name.replace("_", "_1") + "_1get_1err (" + consts.c_fn_args_pfx + ", " + consts.ptr_c_ty + " arg) {\n")
+ write_c(consts.c_fn_ty_pfx + err_map.c_ty + " " + consts.c_fn_name_define_pfx(struct_name + "_get_err", True) + consts.ptr_c_ty + " arg) {\n")
write_c("\t" + struct_name + " *val = (" + struct_name + "*)arg;\n")
write_c("\tCHECK(!val->result_ok);\n\t")
out_java_struct.write("\tpublic static final class " + human_ty + "_Err extends " + human_ty + " {\n")
def map_tuple(struct_name, field_lines):
out_java.write("\tpublic static native long " + struct_name + "_new(")
- write_c(consts.c_fn_ty_pfx + consts.ptr_c_ty + " " + consts.c_fn_name_pfx + struct_name.replace("_", "_1") + "_1new(" + consts.c_fn_args_pfx)
+ write_c(consts.c_fn_ty_pfx + consts.ptr_c_ty + " " + consts.c_fn_name_define_pfx(struct_name + "_new", len(field_lines) > 3))
ty_list = []
for idx, line in enumerate(field_lines):
if idx != 0 and idx < len(field_lines) - 2:
ty_info = java_c_types(line.strip(';'), None)
if idx != 1:
out_java.write(", ")
+ write_c(", ")
e = chr(ord('a') + idx - 1)
out_java.write(ty_info.java_ty + " " + e)
- write_c(", " + ty_info.c_ty + " " + e)
+ write_c(ty_info.c_ty + " " + e)
ty_list.append(ty_info)
tuple_types[struct_name] = (ty_list, struct_name)
out_java.write(");\n")
for idx, ty_info in enumerate(ty_list):
e = chr(ord('a') + idx)
out_java.write("\tpublic static native " + ty_info.java_ty + " " + struct_name + "_get_" + e + "(long ptr);\n")
- write_c(consts.c_fn_ty_pfx + ty_info.c_ty + " " + consts.c_fn_name_pfx + struct_name.replace("_", "_1") + "_1get_1" + e + "(" + consts.c_fn_args_pfx + ", " + consts.ptr_c_ty + " ptr) {\n")
+ write_c(consts.c_fn_ty_pfx + ty_info.c_ty + " " + consts.c_fn_name_define_pfx(struct_name + "_get_" + e, True) + consts.ptr_c_ty + " ptr) {\n")
write_c("\t" + struct_name + " *tuple = (" + struct_name + "*)ptr;\n")
conv_info = type_mapping_generator.map_type_with_info(ty_info, False, None, False, True)
if conv_info.ret_conv is not None:
ty_info = type_mapping_generator.map_type(vec_ty + " arr_elem", False, None, False, False)
if len(ty_info.java_fn_ty_arg) == 1: # ie we're a primitive of some form
out_java.write("\tpublic static native long " + struct_name + "_new(" + ty_info.java_ty + "[] elems);\n")
- write_c(consts.c_fn_ty_pfx + consts.ptr_c_ty + " " + consts.c_fn_name_pfx + struct_name.replace("_", "_1") + "_1new(" + consts.c_fn_args_pfx + ", " + ty_info.c_ty + "Array elems) {\n")
+ write_c(consts.c_fn_ty_pfx + consts.ptr_c_ty + " " + consts.c_fn_name_define_pfx(struct_name + "_new", True) + ty_info.c_ty + "Array elems) {\n")
write_c("\t" + struct_name + " *ret = MALLOC(sizeof(" + struct_name + "), \"" + struct_name + "\");\n")
write_c("\tret->datalen = " + consts.get_native_arr_len_call[0] + "elems" + consts.get_native_arr_len_call[1] + ";\n")
write_c("\tif (ret->datalen == 0) {\n")
write_c("\t\tret->data = NULL;\n")
write_c("\t} else {\n")
write_c("\t\tret->data = MALLOC(sizeof(" + vec_ty + ") * ret->datalen, \"" + struct_name + " Data\");\n")
- write_c("\t\t" + ty_info.c_ty + " *java_elems = " + consts.get_native_arr_ptr_call[0] + "elems" + consts.get_native_arr_ptr_call[1] + ";\n")
+ native_arr_ptr_call = consts.get_native_arr_ptr_call(ty_info.ty_info)
+ write_c("\t\t" + ty_info.c_ty + " *java_elems = " + native_arr_ptr_call[0] + "elems" + native_arr_ptr_call[1] + ";\n")
write_c("\t\tfor (size_t i = 0; i < ret->datalen; i++) {\n")
if ty_info.arg_conv is not None:
write_c("\t\t\t" + ty_info.c_ty + " arr_elem = java_elems[i];\n")
else:
write_c("\t\t\tret->data[i] = java_elems[i];\n")
write_c("\t\t}\n")
- cleanup = consts.release_native_arr_ptr_call("elems", "java_elems")
+ cleanup = consts.release_native_arr_ptr_call(ty_info.ty_info, "elems", "java_elems")
if cleanup is not None:
write_c("\t\t" + cleanup + ";\n")
write_c("\t}\n")
with open(sys.argv[4], "w") as out_c:
out_c.write(consts.c_file_pfx)
- out_c.write(consts.init_str(c_array_class_caches))
+ out_c.write(consts.init_str())
out_c.write(c_file)