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

3 files changed, 43 insertions, 17 deletions

diff --git a/gcc/java/ChangeLog b/gcc/java/ChangeLog
index 96e1ba5..c356f68 100644
--- 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 40c8a83..894671c 100644
--- 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 2ea7af0..37b5f1d 100644
--- 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);