From 116238639891022b3cf3c6d6240b3ea437123478 Mon Sep 17 00:00:00 2001 From: tromey Date: Fri, 26 Feb 1999 12:49:52 +0000 Subject: [PATCH] * gjavah.c (add_class_decl): Only generate `#include' if outer class is not the name of the class we are processing. Correctly append `.h' in #include. (process_file): Clean up newlines around generated `#include's. (decode_signature_piece): Correctly handle inner classes. (struct include): New structure. (all_includes): New global. (print_include): New function. (add_class_decl): Use it. (process_file): Likewise. (add_class_decl): Generate include for java-array.h if array seen. (process_file): Don't generate java-array.h include. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@25460 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/java/ChangeLog | 14 ++++++++ gcc/java/gjavah.c | 98 +++++++++++++++++++++++++++++++++++++++++++----------- 2 files changed, 92 insertions(+), 20 deletions(-) diff --git a/gcc/java/ChangeLog b/gcc/java/ChangeLog index 432ba03d4e8..f066ccf88e5 100644 --- a/gcc/java/ChangeLog +++ b/gcc/java/ChangeLog @@ -1,5 +1,19 @@ 1999-02-26 Tom Tromey + * gjavah.c (add_class_decl): Only generate `#include' if outer + class is not the name of the class we are processing. Correctly + append `.h' in #include. + (process_file): Clean up newlines around generated `#include's. + (decode_signature_piece): Correctly handle inner classes. + (struct include): New structure. + (all_includes): New global. + (print_include): New function. + (add_class_decl): Use it. + (process_file): Likewise. + (add_class_decl): Generate include for java-array.h if array + seen. + (process_file): Don't generate java-array.h include. + * gjavah.c (add_namelet): Check for standard package names here. (add_class_decl): Don't check for standard package names here. diff --git a/gcc/java/gjavah.c b/gcc/java/gjavah.c index 0733373e5ee..5ec6a883dff 100644 --- a/gcc/java/gjavah.c +++ b/gcc/java/gjavah.c @@ -650,7 +650,8 @@ decode_signature_piece (stream, signature, limit, need_space) while (*signature && *signature != ';') { int ch = UTF8_GET (signature, limit); - if (ch == '/') + /* `$' is the separator for an inner class. */ + if (ch == '/' || ch == '$') fputs ("::", stream); else jcf_print_char (stream, ch); @@ -832,6 +833,52 @@ super_class_name (derived_jcf, len) +/* We keep track of all the `#include's we generate, so we can avoid + duplicates. */ +struct include +{ + char *name; + struct include *next; +}; + +/* List of all includes. */ +static struct include *all_includes = NULL; + +/* Generate a #include. */ +static void +print_include (out, utf8, len) + FILE *out; + unsigned char *utf8; + int len; +{ + struct include *incl; + + if (! out) + return; + + if (len == -1) + len = strlen (utf8); + + for (incl = all_includes; incl; incl = incl->next) + { + if (! strncmp (incl->name, utf8, len)) + return; + } + + incl = (struct include *) malloc (sizeof (struct include)); + incl->name = malloc (len + 1); + strncpy (incl->name, utf8, len); + incl->name[len] = '\0'; + incl->next = all_includes; + all_includes = incl; + + fputs ("#include <", out); + jcf_print_utf8 (out, utf8, len); + fputs (".h>\n", out); +} + + + /* This is used to represent part of a package or class name. */ struct namelet { @@ -975,27 +1022,47 @@ add_class_decl (out, jcf, signature) unsigned char *s = JPOOL_UTF_DATA (jcf, signature); int len = JPOOL_UTF_LENGTH (jcf, signature); int i; + /* Name of class we are processing. */ + int name_index = JPOOL_USHORT1 (jcf, jcf->this_class); + int tlen = JPOOL_UTF_LENGTH (jcf, name_index); + char *tname = JPOOL_UTF_DATA (jcf, name_index); for (i = 0; i < len; ++i) { - int start; + int start, saw_dollar; + + /* If we see an array, then we include the array header. */ + if (s[i] == '[') + { + print_include (out, "java-array", -1); + continue; + } + /* We're looking for `L;' -- everything else is ignorable. */ if (s[i] != 'L') continue; + + saw_dollar = 0; for (start = ++i; i < len && s[i] != ';'; ++i) { - if (s[i] == '$' && out) + if (! saw_dollar && s[i] == '$' && out) { + saw_dollar = 1; /* If this class represents an inner class, then - generate a `#include' for the outer class. */ - fputs ("#include <", out); - jcf_print_utf8 (out, &s[start], i - start); - fputs (">\n", out); + generate a `#include' for the outer class. However, + don't generate the include if the outer class is the + class we are processing. */ + if (i - start < tlen || strncmp (&s[start], tname, i - start)) + print_include (out, &s[start], i - start); + break; } } - add_namelet (&s[start], &s[i], &root); + /* If we saw an inner class, then the generated #include will + declare the class. So in this case we needn't bother. */ + if (! saw_dollar) + add_namelet (&s[start], &s[i], &root); } } @@ -1082,7 +1149,7 @@ DEFUN(process_file, (jcf, out), /* We do this to ensure that inline methods won't be `outlined' by g++. This works as long as method and fields are not added by the user. */ - fprintf (out, "#pragma interface\n\n"); + fprintf (out, "#pragma interface\n"); } if (jcf->super_class && out) @@ -1090,18 +1157,8 @@ DEFUN(process_file, (jcf, out), int super_length; unsigned char *supername = super_class_name (jcf, &super_length); - fputs ("#include <", out); - jcf_print_utf8 (out, supername, super_length); - fputs (".h>\n", out); - - /* FIXME: If our superclass is Object, then we include - java-array.h. The right thing to do here is look at all the - methods and fields and see if an array is in use. Only then - would we need to include java-array.h. */ - if (! utf8_cmp (supername, super_length, "java/lang/Object")) - fputs ("#include \n", out); - fputs ("\n", out); + print_include (out, supername, super_length); } /* We want to parse the methods first. But we need to find where @@ -1119,6 +1176,7 @@ DEFUN(process_file, (jcf, out), if (out) { + fputs ("\n", out); print_class_decls (out, jcf, jcf->this_class); for (i = 0; i < prepend_count; ++i) -- 2.11.4.GIT