X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=wrappergen%2Fwrite_jna.c;h=1f180d25f9b0e551a9bc688654c6aa2c30844da4;hb=bf92df408b5fef01d5ee065b02c1deb7e4289a5b;hp=070c15cc0b6ef66b1df3fdccf1bd5221a410886d;hpb=6d7d61de445629e1590d3a2ba2990ef7a651368a;p=cparser

diff --git a/wrappergen/write_jna.c b/wrappergen/write_jna.c
index 070c15c..1f180d2 100644
--- a/wrappergen/write_jna.c
+++ b/wrappergen/write_jna.c
@@ -28,18 +28,29 @@
 #include "type_t.h"
 #include "entity_t.h"
 #include "type.h"
+#include "printer.h"
 #include "adt/error.h"
+#include "adt/xmalloc.h"
 #include <libfirm/adt/pset_new.h>
 
+typedef struct output_limit {
+	const char          *filename;
+	struct output_limit *next;
+} output_limit;
+
 static const scope_t *global_scope;
 static FILE          *out;
 static pset_new_t     avoid_symbols;
-
-static void write_type(type_t *type);
+static output_limit  *output_limits;
+static const char    *libname;
 
 static bool is_system_header(const char *fname)
 {
-	return strncmp(fname, "/usr/include", 12) == 0;
+	if (strncmp(fname, "/usr/include", 12) == 0)
+		return true;
+	if (fname == builtin_source_position.input_name)
+		return true;
+	return false;
 }
 
 static const char *fix_builtin_names(const char *name)
@@ -68,17 +79,16 @@ static const char *get_atomic_type_string(const atomic_type_kind_t type)
 	case ATOMIC_TYPE_CHAR:        return "byte";
 	case ATOMIC_TYPE_SCHAR:       return "byte";
 	case ATOMIC_TYPE_UCHAR:       return "byte";
-	case ATOMIC_TYPE_SHORT:	      return "short";
+	case ATOMIC_TYPE_SHORT:       return "short";
 	case ATOMIC_TYPE_USHORT:      return "short";
 	case ATOMIC_TYPE_INT:         return "int";
 	case ATOMIC_TYPE_UINT:        return "int";
-	case ATOMIC_TYPE_LONG:        return "NativeLong";
-	case ATOMIC_TYPE_ULONG:       return "NativeLong";
+	case ATOMIC_TYPE_LONG:        return "com.sun.jna.NativeLong";
+	case ATOMIC_TYPE_ULONG:       return "com.sun.jna.NativeLong";
 	case ATOMIC_TYPE_LONGLONG:    return "long";
 	case ATOMIC_TYPE_ULONGLONG:   return "long";
 	case ATOMIC_TYPE_FLOAT:       return "float";
 	case ATOMIC_TYPE_DOUBLE:      return "double";
-	case ATOMIC_TYPE_LONG_DOUBLE: return "double";
 	case ATOMIC_TYPE_BOOL:        return "boolean";
 	default:                      panic("unsupported atomic type");
 	}
@@ -98,7 +108,7 @@ static void write_pointer_type(const pointer_type_t *type)
 	}
 	if (is_type_pointer(points_to)) {
 		/* hack... */
-		fputs("Pointer[]", out);
+		fputs("java.nio.Buffer", out);
 		return;
 	}
 	fputs("Pointer", out);
@@ -212,9 +222,6 @@ static void write_type(type_t *type)
 	case TYPE_ENUM:
 		write_enum_type(&type->enumt);
 		return;
-	case TYPE_BUILTIN:
-		write_type(type->builtin.real_type);
-		return;
 	case TYPE_ERROR:
 	case TYPE_INVALID:
 	case TYPE_TYPEOF:
@@ -278,6 +285,7 @@ static void write_binary_expression(const binary_expression_t *expression)
 {
 	fputs("(", out);
 	write_expression(expression->left);
+	fputc(' ', out);
 	switch(expression->base.kind) {
 	case EXPR_BINARY_BITWISE_OR:  fputs("|", out); break;
 	case EXPR_BINARY_BITWISE_AND: fputs("&", out); break;
@@ -291,22 +299,21 @@ static void write_binary_expression(const binary_expression_t *expression)
 	default:
 		panic("unimplemented binexpr");
 	}
+	fputc(' ', out);
 	write_expression(expression->right);
 	fputs(")", out);
 }
 
 static void write_expression(const expression_t *expression)
 {
-	const const_expression_t *constant;
 	/* TODO */
 	switch(expression->kind) {
-	case EXPR_CONST:
-		constant = &expression->conste;
-		if(is_type_integer(expression->base.type)) {
-			fprintf(out, "%lld", constant->v.int_value);
-		} else {
-			fprintf(out, "%Lf", constant->v.float_value);
-		}
+	case EXPR_LITERAL_INTEGER:
+	case EXPR_LITERAL_INTEGER_OCTAL:
+		fprintf(out, "%s", expression->literal.value.begin);
+		break;
+	case EXPR_LITERAL_INTEGER_HEXADECIMAL:
+		fprintf(out, "0x%s", expression->literal.value.begin);
 		break;
 	case EXPR_REFERENCE_ENUM_VALUE: {
 		/* UHOH... hacking */
@@ -358,23 +365,29 @@ static void write_enum(const symbol_t *symbol, const enum_t *entity)
 		}
 	}
 	fprintf(out, "\t\tpublic final int val;\n");
-	fprintf(out, "\t\tprivate static class C { static int next_val; }\n\n");
+	fprintf(out, "\n");
+	fprintf(out, "\t\tprivate static class C {\n");
+	fprintf(out, "\t\t\tstatic int next_val;\n");
+	fprintf(out, "\t\t}\n");
+	fprintf(out, "\n");
 	fprintf(out, "\t\t%s(int val) {\n", name);
 	fprintf(out, "\t\t\tthis.val = val;\n");
 	fprintf(out, "\t\t\tC.next_val = val + 1;\n");
 	fprintf(out, "\t\t}\n");
+	fprintf(out, "\n");
 	fprintf(out, "\t\t%s() {\n", name);
 	fprintf(out, "\t\t\tthis.val = C.next_val++;\n");
 	fprintf(out, "\t\t}\n");
-	fprintf(out, "\t\t\n");
+	fprintf(out, "\n");
 	fprintf(out, "\t\tpublic static %s getEnum(int val) {\n", name);
-	fprintf(out, "\t\t\tfor(%s entry : values()) {\n", name);
+	fprintf(out, "\t\t\tfor (%s entry : values()) {\n", name);
 	fprintf(out, "\t\t\t\tif (val == entry.val)\n");
 	fprintf(out, "\t\t\t\t\treturn entry;\n");
 	fprintf(out, "\t\t\t}\n");
 	fprintf(out, "\t\t\treturn null;\n");
 	fprintf(out, "\t\t}\n");
 	fprintf(out, "\t}\n");
+	fprintf(out, "\n");
 }
 
 #if 0
@@ -398,7 +411,8 @@ static void write_function(const entity_t *entity)
 	const function_type_t *function_type
 		= (const function_type_t*) entity->declaration.type;
 
-	fputc('\t', out);
+	fputc('\n', out);
+	fprintf(out, "\tpublic static native ");
 	type_t *return_type = skip_typeref(function_type->return_type);
 	write_type(return_type);
 	fprintf(out, " %s(", entity->base.symbol->string);
@@ -406,7 +420,7 @@ static void write_function(const entity_t *entity)
 	entity_t *parameter = entity->function.parameters.entities;
 	int       first     = 1;
 	int       n         = 0;
-	for( ; parameter != NULL; parameter = parameter->base.next) {
+	for ( ; parameter != NULL; parameter = parameter->base.next) {
 		assert(parameter->kind == ENTITY_PARAMETER);
 		if(!first) {
 			fprintf(out, ", ");
@@ -431,6 +445,19 @@ static void write_function(const entity_t *entity)
 	fprintf(out, ");\n");
 }
 
+void jna_limit_output(const char *filename)
+{
+	output_limit *limit = xmalloc(sizeof(limit[0]));
+	limit->filename = filename;
+
+	limit->next   = output_limits;
+	output_limits = limit;
+}
+
+void jna_set_libname(const char *new_libname)
+{
+	libname = new_libname;
+}
 
 void write_jna_decls(FILE *output, const translation_unit_t *unit)
 {
@@ -439,30 +466,37 @@ void write_jna_decls(FILE *output, const translation_unit_t *unit)
 
 	pset_new_init(&avoid_symbols);
 
-	ast_set_output(out);
-	type_set_output(out);
+	print_to_file(out);
 	fprintf(out, "/* WARNING: Automatically generated file */\n");
-	fputs("import com.sun.jna.Library;\n", out);
 	fputs("import com.sun.jna.Native;\n", out);
-	fputs("import com.sun.jna.Platform;\n", out);
 	fputs("import com.sun.jna.Pointer;\n", out);
-	fputs("import com.sun.jna.NativeLong;\n", out);
-	fputs("\n\n", out);
+	fputs("\n", out);
+
+	const char *register_libname = libname;
+	if (register_libname == NULL)
+		register_libname = "library";
 
 	/* TODO: where to get the name from? */
-	fputs("public interface binding extends Library {\n", out);
+	fputs("public class binding {\n", out);
+	fputs("\tstatic {\n", out);
+	fprintf(out, "\t\tNative.register(\"%s\");\n", register_libname);
+	fputs("\t}\n", out);
+	fputs("\n", out);
 
 	/* read the avoid list */
 	FILE *avoid = fopen("avoid.config", "r");
 	if (avoid != NULL) {
 		while (!feof(avoid)) {
 			char buf[1024];
-			fgets(buf, sizeof(buf), avoid);
+			char *res = fgets(buf, sizeof(buf), avoid);
+			if (res == NULL)
+				break;
+			if (buf[0] == 0)
+				continue;
+
 			size_t len = strlen(buf);
 			if (buf[len-1] == '\n')
 				buf[len-1] = 0;
-			if (buf[0] == 0)
-				continue;
 
 			char *str = malloc(len+1);
 			memcpy(str, buf, len+1);
@@ -474,7 +508,7 @@ void write_jna_decls(FILE *output, const translation_unit_t *unit)
 
 	/* write structs,unions + enums */
 	entity_t *entity = unit->scope.entities;
-	for( ; entity != NULL; entity = entity->base.next) {
+	for ( ; entity != NULL; entity = entity->base.next) {
 		if (entity->kind == ENTITY_ENUM) {
 			if (find_enum_typedef(&entity->enume) != NULL)
 				continue;
@@ -496,11 +530,26 @@ void write_jna_decls(FILE *output, const translation_unit_t *unit)
 
 	/* write functions */
 	entity = unit->scope.entities;
-	for( ; entity != NULL; entity = entity->base.next) {
+	for ( ; entity != NULL; entity = entity->base.next) {
 		if (entity->kind != ENTITY_FUNCTION)
 			continue;
-		if (is_system_header(entity->base.source_position.input_name))
+		const char *input_name = entity->base.source_position.input_name;
+		if (is_system_header(input_name))
+			continue;
+		if (entity->function.elf_visibility != ELF_VISIBILITY_DEFAULT)
 			continue;
+		if (output_limits != NULL) {
+			bool in_limits = false;
+			for (output_limit *limit = output_limits; limit != NULL;
+			     limit = limit->next) {
+			    if (strcmp(limit->filename, input_name) == 0) {
+					in_limits = true;
+					break;
+				}
+			}
+			if (!in_limits)
+				continue;
+		}
 
 		if (pset_new_contains(&avoid_symbols, entity->base.symbol))
 			continue;