* 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

diff --git a/gcc/java/ChangeLog b/gcc/java/ChangeLog
index 432ba03..f066ccf 100644 (file)
--- a/gcc/java/ChangeLog
+++ b/gcc/java/ChangeLog
@@ -1,5 +1,19 @@
 1999-02-26  Tom Tromey  <tromey@cygnus.com>
 
+       * 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 0733373..5ec6a88 100644 (file)
--- 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)
 
 \f
 
+/* 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);
+}
+
+\f
+
 /* 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<stuff>;' -- 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 <java-array.h>\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)