class.c (java_hash_tree_node): Fixed indentation in leading comment.

2001-06-20  Alexandre Petit-Bianco  <apbianco@redhat.com>

	* class.c (java_hash_tree_node): Fixed indentation in leading comment.
	* parse.y (do_resolve_class): Moved comments out to leading comment
	section. Removed local `start', New local `_ht' and
	`circularity_hash.'  Record `enclosing' in hash table and search
	it to detect circularity.  Use `enclosing' as an argument to
	`lookup_cl.' Free the hash table when done.

(http://gcc.gnu.org/ml/gcc-patches/2001-06/msg01318.html )

From-SVN: r43480

diff --git a/gcc/java/ChangeLog b/gcc/java/ChangeLog
index 96e1ba5743c478c22732bb422713226479594922..c356f68ba3ae7d2d2c2b4dc7861523c46e36d3ce 100644 (file)
--- a/gcc/java/ChangeLog
+++ b/gcc/java/ChangeLog
@@ -1,3 +1,12 @@
+2001-06-20  Alexandre Petit-Bianco  <apbianco@redhat.com>
+
+       * class.c (java_hash_tree_node): Fixed indentation in leading comment.
+       * parse.y (do_resolve_class): Moved comments out to leading comment
+       section. Removed local `start', New local `_ht' and
+       `circularity_hash.'  Record `enclosing' in hash table and search
+       it to detect circularity.  Use `enclosing' as an argument to
+       `lookup_cl.' Free the hash table when done.
+
 2001-06-19  Tom Tromey  <tromey@redhat.com>
 
        * lex.c (java_read_char): Disallow invalid and overlong

diff --git a/gcc/java/class.c b/gcc/java/class.c
index 40c8a83a03c97cedda51b448eb02f1b0187b1b21..894671c24222ed47d336331e845603c2b44c1b64 100644 (file)
--- a/gcc/java/class.c
+++ b/gcc/java/class.c
@@ -618,9 +618,9 @@ init_test_hash_newfunc (entry, table, string)
   return (struct hash_entry *) ret;
 }
 
-/* Hash table helpers. Also reused in find_applicable_accessible_methods_list
-   (parse.y). The hash of a tree node is it's pointer value,
-   comparison is direct. */
+/* Hash table helpers. Also reused in find_applicable_accessible_methods_list 
+   (parse.y). The hash of a tree node is its pointer value, comparison
+   is direct. */
 
 unsigned long
 java_hash_hash_tree_node (k)

diff --git a/gcc/java/parse.y b/gcc/java/parse.y
index 2ea7af0c672523b28d1db8761b9c6addc4b22e1e..37b5f1d58b30722b04784b23a34afe2dfd6cc4ab 100644 (file)
--- a/gcc/java/parse.y
+++ b/gcc/java/parse.y
@@ -5519,30 +5519,41 @@ resolve_class (enclosing, class_type, decl, cl)
 }
 
 /* Effectively perform the resolution of class CLASS_TYPE. DECL or CL
-   are used to report error messages.  */
+   are used to report error messages. Do not try to replace TYPE_NAME
+   (class_type) by a variable, since it is changed by
+   find_in_imports{_on_demand} and (but it doesn't really matter)
+   qualify_and_find.  */
 
 tree
 do_resolve_class (enclosing, class_type, decl, cl)
      tree enclosing, class_type, decl, cl;
 {
-  tree new_class_decl, super, start;
+  tree new_class_decl, super;
+  struct hash_table _ht, *circularity_hash = &_ht;
 
-  /* Do not try to replace TYPE_NAME (class_type) by a variable, since
-     it is changed by find_in_imports{_on_demand} and (but it doesn't
-     really matter) qualify_and_find */
+  /* This hash table is used to register the classes we're going
+     through when searching the current class as an inner class, in
+     order to detect circular references. Remember to free it before
+     returning the section 0- of this function. */
+  hash_table_init (circularity_hash, hash_newfunc,
+                  java_hash_hash_tree_node, java_hash_compare_tree_node);
 
-  /* 0- Search in the current class as an inner class */
-  start = enclosing;
-
-  /* Maybe some code here should be added to load the class or
+  /* 0- Search in the current class as an inner class.
+     Maybe some code here should be added to load the class or
      something, at least if the class isn't an inner class and ended
      being loaded from class file. FIXME. */
   while (enclosing)
     {
       tree intermediate;
 
+      hash_lookup (circularity_hash, 
+                  (const  hash_table_key) enclosing, TRUE, NULL);
+
       if ((new_class_decl = find_as_inner_class (enclosing, class_type, cl)))
-        return new_class_decl;
+       {
+         hash_table_free (circularity_hash);
+         return new_class_decl;
+       }
 
       intermediate = enclosing;
       /* Explore enclosing contexts. */
@@ -5551,7 +5562,10 @@ do_resolve_class (enclosing, class_type, decl, cl)
          intermediate = DECL_CONTEXT (intermediate);
          if ((new_class_decl = find_as_inner_class (intermediate, 
                                                     class_type, cl)))
-           return new_class_decl;
+           {
+             hash_table_free (circularity_hash);
+             return new_class_decl;
+           }
        }
 
       /* Now go to the upper classes, bail out if necessary. */
@@ -5563,13 +5577,14 @@ do_resolve_class (enclosing, class_type, decl, cl)
         super = do_resolve_class (NULL, super, NULL, NULL);
       else
        super = TYPE_NAME (super);
- 
+
       /* We may not have checked for circular inheritance yet, so do so
          here to prevent an infinite loop. */
-      if (super == start)
+      if (hash_lookup (circularity_hash,
+                      (const hash_table_key) super, FALSE, NULL))
         {
           if (!cl)
-            cl = lookup_cl (decl);
+            cl = lookup_cl (enclosing);
          
           parse_error_context
             (cl, "Cyclic inheritance involving %s",
@@ -5579,6 +5594,8 @@ do_resolve_class (enclosing, class_type, decl, cl)
       enclosing = super;
     }
 
+  hash_table_free (circularity_hash);
+
   /* 1- Check for the type in single imports. This will change
      TYPE_NAME() if something relevant is found */
   find_in_imports (class_type);