Correct copy&paste-o in warning message.

[cparser] / wrappergen / write_jna.c

diff --git a/wrappergen/write_jna.c b/wrappergen/write_jna.c
index 9115c7d..f86da8a 100644 (file)
--- a/wrappergen/write_jna.c
+++ b/wrappergen/write_jna.c
@@ -30,11 +30,19 @@
 #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 output_limit  *output_limits;
+static const char    *libname;
 
 static void write_type(type_t *type);
 
@@ -83,7 +91,6 @@ static const char *get_atomic_type_string(const atomic_type_kind_t type)
        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");
        }
@@ -103,7 +110,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);
@@ -283,6 +290,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;
@@ -296,6 +304,7 @@ static void write_binary_expression(const binary_expression_t *expression)
        default:
                panic("unimplemented binexpr");
        }
+       fputc(' ', out);
        write_expression(expression->right);
        fputs(")", out);
 }
@@ -361,23 +370,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
@@ -401,6 +416,7 @@ static void write_function(const entity_t *entity)
        const function_type_t *function_type
                = (const function_type_t*) entity->declaration.type;
 
+       fputc('\n', out);
        fprintf(out, "\tpublic static native ");
        type_t *return_type = skip_typeref(function_type->return_type);
        write_type(return_type);
@@ -409,7 +425,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, ", ");
@@ -434,6 +450,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)
 {
@@ -446,11 +475,18 @@ void write_jna_decls(FILE *output, const translation_unit_t *unit)
        fprintf(out, "/* WARNING: Automatically generated file */\n");
        fputs("import com.sun.jna.Native;\n", out);
        fputs("import com.sun.jna.Pointer;\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 class binding {\n", out);
-       fputs("\tstatic { Native.register(\"firm\"); }\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");
@@ -477,7 +513,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;
@@ -499,11 +535,24 @@ 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 (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;