re GNATS gcj/211 (gcjh doesn't handle method names that are reserved C++ keywords)

	PR gcj/211:
	* gjavah.c (utf8_cmp): Changed return value.
	(cxx_keyword_subst): Handle all C++ keywords.  Allocate new return
	result.
	(cxx_keywords): New global.
	(get_field_name): Handle new result of cxx_keyword_subst.
	(print_method_info): Likewise.

From-SVN: r33225

diff --git a/gcc/java/ChangeLog b/gcc/java/ChangeLog
index 5215ce08226392558099311857bf357ba2c4c747..be558a33ee1ae8ab1c9abb0f947c601dedd10684 100644 (file)
--- a/gcc/java/ChangeLog
+++ b/gcc/java/ChangeLog
@@ -1,3 +1,13 @@
+2000-04-18  Tom Tromey  <tromey@cygnus.com>
+
+       PR gcj/211:
+       * gjavah.c (utf8_cmp): Changed return value.
+       (cxx_keyword_subst): Handle all C++ keywords.  Allocate new return
+       result.
+       (cxx_keywords): New global.
+       (get_field_name): Handle new result of cxx_keyword_subst.
+       (print_method_info): Likewise.
+
 2000-04-17  Bryce McKinlay  <bryce@albatross.co.nz>
 
        * gjavah.c (print_name_for_stub_or_jni): Don't prefix method names 

diff --git a/gcc/java/gjavah.c b/gcc/java/gjavah.c
index 355f99c34aa158f47eaa2057dffaef5690da4aad..0ee85a56638cae00d9e1cf1e54066ae3da574831 100644 (file)
--- a/gcc/java/gjavah.c
+++ b/gcc/java/gjavah.c
@@ -131,7 +131,7 @@ static int java_double_finite PARAMS ((jdouble));
 static void print_name PARAMS ((FILE *, JCF *, int));
 static void print_base_classname PARAMS ((FILE *, JCF *, int));
 static int utf8_cmp PARAMS ((const unsigned char *, int, const char *));
-static const char *cxx_keyword_subst PARAMS ((const unsigned char *, int));
+static char *cxx_keyword_subst PARAMS ((const unsigned char *, int));
 static void generate_access PARAMS ((FILE *, JCF_u2));
 static int name_is_method_p PARAMS ((const unsigned char *, int));
 static char *get_field_name PARAMS ((JCF *, int, JCF_u2));
@@ -336,7 +336,8 @@ print_base_classname (stream, jcf, index)
     }
 }
 
-/* Return 0 if NAME is equal to STR, nonzero otherwise.  */
+/* Return 0 if NAME is equal to STR, -1 if STR is "less" than NAME,
+   and 1 if STR is "greater" than NAME.  */
 
 static int
 utf8_cmp (str, length, name)
@@ -351,26 +352,79 @@ utf8_cmp (str, length, name)
     {
       int ch = UTF8_GET (str, limit);
       if (ch != name[i])
-       return 1;
+       return ch - name[i];
     }
 
-  return str != limit;
+  return str == limit ? 0 : 1;
 }
 
+/* This is a sorted list of all C++ keywords.  */
+
+static const char *cxx_keywords[] =
+{
+  "asm",
+  "auto",
+  "bool",
+  "const_cast",
+  "delete",
+  "dynamic_cast",
+  "enum",
+  "explicit",
+  "extern",
+  "friend",
+  "inline",
+  "mutable",
+  "namespace",
+  "overload",
+  "register",
+  "reinterpret_cast",
+  "signed",
+  "sizeof",
+  "static_cast",
+  "struct",
+  "template",
+  "typedef",
+  "typeid",
+  "typename",
+  "typenameopt",
+  "union",
+  "unsigned",
+  "using",
+  "virtual",
+  "volatile",
+  "wchar_t"
+};
+
+
 /* If NAME is the name of a C++ keyword, then return an override name.
    This is a name that can be used in place of the keyword.
-   Otherwise, return NULL.  FIXME: for now, we only handle those
-   keywords we know to be a problem for libgcj.  */
+   Otherwise, return NULL.  The return value is malloc()d.  */
 
-static const char *
+static char *
 cxx_keyword_subst (str, length)
      const unsigned char *str;
      int length;
 {
-  if (! utf8_cmp (str, length, "delete"))
-    return "__dummy_delete";
-  else if (! utf8_cmp (str, length, "enum"))
-    return "__dummy_enum";
+  int last = sizeof (cxx_keywords) / sizeof (const char *);
+  int first = 0;
+  int mid, r;
+
+  while (last != first)
+    {
+      mid = (last + first) / 2;
+      r = utf8_cmp (str, length, cxx_keywords[mid]);
+      if (r == 0)
+       {
+         char *str = xmalloc (9 + strlen (cxx_keywords[mid]));
+         strcpy (str, "__dummy_");
+         strcat (str, cxx_keywords[mid]);
+         return str;
+       }
+      else if (r < 0)
+       last = mid;
+      else
+       first = mid;
+    }
   return NULL;
 }
 
@@ -455,7 +509,6 @@ get_field_name (jcf, name_index, flags)
   unsigned char *name = JPOOL_UTF_DATA (jcf, name_index);
   int length = JPOOL_UTF_LENGTH (jcf, name_index);
   char *override;
-  const char *tmpconstptr;
 
   if (name_is_method_p (name, length))
     {
@@ -474,14 +527,9 @@ get_field_name (jcf, name_index, flags)
       memcpy (override, name, length);
       strcpy (override + length, "__");
     }
-  else if ((tmpconstptr = cxx_keyword_subst (name, length)) != NULL)
-    {
-      /* Must malloc OVERRIDE.  */
-      override = xstrdup (tmpconstptr);
-    }
   else
-    override = NULL;
-  
+    override = cxx_keyword_subst (name, length);
+
   return override;
 }
 
@@ -621,7 +669,7 @@ DEFUN(print_method_info, (stream, jcf, name_index, sig_index, flags),
 {
   const unsigned char *str;
   int length, is_init = 0;
-  const char *override = NULL;
+  char *override = NULL;
 
   method_declared = 0;
   method_access = flags;
@@ -687,7 +735,10 @@ DEFUN(print_method_info, (stream, jcf, name_index, sig_index, flags),
             mangling will be wrong.  FIXME.  */
          if (METHOD_IS_FINAL (jcf->access_flags, flags)
              || (flags & ACC_STATIC))
-           return;
+           {
+             free (override);
+             return;
+           }
        }
     }
 
@@ -722,6 +773,9 @@ DEFUN(print_method_info, (stream, jcf, name_index, sig_index, flags),
                             is_init, override, flags);
        }
     }
+
+  if (override)
+    free (override);
 }
 
 /* Try to decompile a method body.  Right now we just try to handle a