src/share/classes/com/sun/tools/javac/code/Scope.java - toolchain/jdk/jdk9_langtools - Git at Google

 /*
  * Copyright 1999-2008 Sun Microsystems, Inc.  All Rights Reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Sun designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Sun in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  * CA 95054 USA or visit www.sun.com if you need additional information or
  * have any questions.
  */

 package com.sun.tools.javac.code;

 import com.sun.tools.javac.util.*;
 import java.util.Iterator;

 /** A scope represents an area of visibility in a Java program. The
  *  Scope class is a container for symbols which provides
  *  efficient access to symbols given their names. Scopes are implemented
  *  as hash tables. Scopes can be nested; the next field of a scope points
  *  to its next outer scope. Nested scopes can share their hash tables.
  *
  *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
  *  you write code that depends on this, you do so at your own risk.
  *  This code and its internal interfaces are subject to change or
  *  deletion without notice.</b>
  */
 public class Scope {

     /** The number of scopes that share this scope's hash table.
      */
     private int shared;

     /** Next enclosing scope (with whom this scope may share a hashtable)
      */
     public Scope next;

     /** The scope's owner.
      */
     public Symbol owner;

     /** A hash table for the scope's entries.
      */
     public Entry[] table;

     /** Mask for hash codes, always equal to (table.length - 1).
      */
     int hashMask;

     /** A linear list that also contains all entries in
      *  reverse order of appearance (i.e later entries are pushed on top).
      */
     public Entry elems;

     /** The number of elements in this scope.
      */
     public int nelems = 0;

     /** Every hash bucket is a list of Entry's which ends in sentinel.
      */
     private static final Entry sentinel = new Entry(null, null, null, null);

     /** The hash table's initial size.
      */
     private static final int INITIAL_SIZE = 0x10;

     /** A value for the empty scope.
      */
     public static final Scope emptyScope = new Scope(null, null, new Entry[]{});

     /** Construct a new scope, within scope next, with given owner, using
      *  given table. The table's length must be an exponent of 2.
      */
     Scope(Scope next, Symbol owner, Entry[] table) {
         this.next = next;
         assert emptyScope == null || owner != null;
         this.owner = owner;
         this.table = table;
         this.hashMask = table.length - 1;
         this.elems = null;
         this.nelems = 0;
         this.shared = 0;
     }

     /** Construct a new scope, within scope next, with given owner,
      *  using a fresh table of length INITIAL_SIZE.
      */
     public Scope(Symbol owner) {
         this(null, owner, new Entry[INITIAL_SIZE]);
         for (int i = 0; i < INITIAL_SIZE; i++) table[i] = sentinel;
     }

     /** Construct a fresh scope within this scope, with same owner,
      *  which shares its table with the outer scope. Used in connection with
      *  method leave if scope access is stack-like in order to avoid allocation
      *  of fresh tables.
      */
     public Scope dup() {
         Scope result = new Scope(this, this.owner, this.table);
         shared++;
         // System.out.println("====> duping scope " + this.hashCode() + " owned by " + this.owner + " to " + result.hashCode());
         // new Error().printStackTrace(System.out);
         return result;
     }

     /** Construct a fresh scope within this scope, with new owner,
      *  which shares its table with the outer scope. Used in connection with
      *  method leave if scope access is stack-like in order to avoid allocation
      *  of fresh tables.
      */
     public Scope dup(Symbol newOwner) {
         Scope result = new Scope(this, newOwner, this.table);
         shared++;
         // System.out.println("====> duping scope " + this.hashCode() + " owned by " + newOwner + " to " + result.hashCode());
         // new Error().printStackTrace(System.out);
         return result;
     }

     /** Construct a fresh scope within this scope, with same owner,
      *  with a new hash table, whose contents initially are those of
      *  the table of its outer scope.
      */
     public Scope dupUnshared() {
         return new Scope(this, this.owner, this.table.clone());
     }

     /** Remove all entries of this scope from its table, if shared
      *  with next.
      */
     public Scope leave() {
         assert shared == 0;
         if (table != next.table) return next;
         while (elems != null) {
             int hash = elems.sym.name.hashCode() & hashMask;
             Entry e = table[hash];
             assert e == elems : elems.sym;
             table[hash] = elems.shadowed;
             elems = elems.sibling;
         }
         assert next.shared > 0;
         next.shared--;
         // System.out.println("====> leaving scope " + this.hashCode() + " owned by " + this.owner + " to " + next.hashCode());
         // new Error().printStackTrace(System.out);
         return next;
     }

     /** Double size of hash table.
      */
     private void dble() {
         assert shared == 0;
         Entry[] oldtable = table;
         Entry[] newtable = new Entry[oldtable.length * 2];
         for (Scope s = this; s != null; s = s.next) {
             if (s.table == oldtable) {
                 assert s == this || s.shared != 0;
                 s.table = newtable;
                 s.hashMask = newtable.length - 1;
             }
         }
         for (int i = 0; i < newtable.length; i++) newtable[i] = sentinel;
         for (int i = 0; i < oldtable.length; i++) copy(oldtable[i]);
     }

     /** Copy the given entry and all entries shadowed by it to table
      */
     private void copy(Entry e) {
         if (e.sym != null) {
             copy(e.shadowed);
             int hash = e.sym.name.hashCode() & hashMask;
             e.shadowed = table[hash];
             table[hash] = e;
         }
     }

     /** Enter symbol sym in this scope.
      */
     public void enter(Symbol sym) {
         assert shared == 0;
         enter(sym, this);
     }

     public void enter(Symbol sym, Scope s) {
         enter(sym, s, s);
     }

     /**
      * Enter symbol sym in this scope, but mark that it comes from
      * given scope `s' accessed through `origin'.  The last two
      * arguments are only used in import scopes.
      */
     public void enter(Symbol sym, Scope s, Scope origin) {
         assert shared == 0;
         // Temporarily disabled (bug 6460352):
         // if (nelems * 3 >= hashMask * 2) dble();
         int hash = sym.name.hashCode() & hashMask;
         Entry e = makeEntry(sym, table[hash], elems, s, origin);
         table[hash] = e;
         elems = e;
         nelems++;
     }

     Entry makeEntry(Symbol sym, Entry shadowed, Entry sibling, Scope scope, Scope origin) {
         return new Entry(sym, shadowed, sibling, scope);
     }

     /** Remove symbol from this scope.  Used when an inner class
      *  attribute tells us that the class isn't a package member.
      */
     public void remove(Symbol sym) {
         assert shared == 0;
         Entry e = lookup(sym.name);
         while (e.scope == this && e.sym != sym) e = e.next();
         if (e.scope == null) return;

         // remove e from table and shadowed list;
         Entry te = table[sym.name.hashCode() & hashMask];
         if (te == e)
             table[sym.name.hashCode() & hashMask] = e.shadowed;
         else while (true) {
             if (te.shadowed == e) {
                 te.shadowed = e.shadowed;
                 break;
             }
             te = te.shadowed;
         }

         // remove e from elems and sibling list
         te = elems;
         if (te == e)
             elems = e.sibling;
         else while (true) {
             if (te.sibling == e) {
                 te.sibling = e.sibling;
                 break;
             }
             te = te.sibling;
         }
     }

     /** Enter symbol sym in this scope if not already there.
      */
     public void enterIfAbsent(Symbol sym) {
         assert shared == 0;
         Entry e = lookup(sym.name);
         while (e.scope == this && e.sym.kind != sym.kind) e = e.next();
         if (e.scope != this) enter(sym);
     }

     /** Given a class, is there already a class with same fully
      *  qualified name in this (import) scope?
      */
     public boolean includes(Symbol c) {
         for (Scope.Entry e = lookup(c.name);
              e.scope == this;
              e = e.next()) {
             if (e.sym == c) return true;
         }
         return false;
     }

     /** Return the entry associated with given name, starting in
      *  this scope and proceeding outwards. If no entry was found,
      *  return the sentinel, which is characterized by having a null in
      *  both its scope and sym fields, whereas both fields are non-null
      *  for regular entries.
      */
     public Entry lookup(Name name) {
         Entry e = table[name.hashCode() & hashMask];
         while (e.scope != null && e.sym.name != name)
             e = e.shadowed;
         return e;
     }

     public Iterable<Symbol> getElements() {
         return new Iterable<Symbol>() {
             public Iterator<Symbol> iterator() {
                 return new Iterator<Symbol>() {
                     private Scope currScope = Scope.this;
                     private Scope.Entry currEntry = elems;
                     {
                         update();
                     }

                     public boolean hasNext() {
                         return currEntry != null;
                     }

                     public Symbol next() {
                         Symbol sym = (currEntry == null ? null : currEntry.sym);
                         currEntry = currEntry.sibling;
                         update();
                         return sym;
                     }

                     public void remove() {
                         throw new UnsupportedOperationException();
                     }

                     private void update() {
                         while (currEntry == null && currScope.next != null) {
                             currScope = currScope.next;
                             currEntry = currScope.elems;
                         }
                     }
                 };
             }
         };

     }

     public String toString() {
         StringBuilder result = new StringBuilder();
         result.append("Scope[");
         for (Scope s = this; s != null ; s = s.next) {
             if (s != this) result.append(" | ");
             for (Entry e = s.elems; e != null; e = e.sibling) {
                 if (e != s.elems) result.append(", ");
                 result.append(e.sym);
             }
         }
         result.append("]");
         return result.toString();
     }

     /** A class for scope entries.
      */
     public static class Entry {

         /** The referenced symbol.
          *  sym == null   iff   this == sentinel
          */
         public Symbol sym;

         /** An entry with the same hash code, or sentinel.
          */
         private Entry shadowed;

         /** Next entry in same scope.
          */
         public Entry sibling;

         /** The entry's scope.
          *  scope == null   iff   this == sentinel
          *  for an entry in an import scope, this is the scope
          *  where the entry came from (i.e. was imported from).
          */
         public Scope scope;

         public Entry(Symbol sym, Entry shadowed, Entry sibling, Scope scope) {
             this.sym = sym;
             this.shadowed = shadowed;
             this.sibling = sibling;
             this.scope = scope;
         }

         /** Return next entry with the same name as this entry, proceeding
          *  outwards if not found in this scope.
          */
         public Entry next() {
             Entry e = shadowed;
             while (e.scope != null && e.sym.name != sym.name)
                 e = e.shadowed;
             return e;
         }

         public Scope getOrigin() {
             // The origin is only recorded for import scopes.  For all
             // other scope entries, the "enclosing" type is available
             // from other sources.  See Attr.visitSelect and
             // Attr.visitIdent.  Rather than throwing an assertion
             // error, we return scope which will be the same as origin
             // in many cases.
             return scope;
         }
     }

     public static class ImportScope extends Scope {

         public ImportScope(Symbol owner) {
             super(owner);
         }

         @Override
         Entry makeEntry(Symbol sym, Entry shadowed, Entry sibling, Scope scope, Scope origin) {
             return new ImportEntry(sym, shadowed, sibling, scope, origin);
         }

         public Entry lookup(Name name) {
             Entry e = table[name.hashCode() & hashMask];
             while (e.scope != null &&
                    (e.sym.name != name ||
                     /* Since an inner class will show up in package and
                      * import scopes until its inner class attribute has
                      * been processed, we have to weed it out here.  This
                      * is done by comparing the owners of the entry's
                      * scope and symbol fields.  The scope field's owner
                      * points to where the class originally was imported
                      * from.  The symbol field's owner points to where the
                      * class is situated now.  This can change when an
                      * inner class is read (see ClassReader.enterClass).
                      * By comparing the two fields we make sure that we do
                      * not accidentally import an inner class that started
                      * life as a flat class in a package. */
                     e.sym.owner != e.scope.owner))
                 e = e.shadowed;
             return e;
         }

         static class ImportEntry extends Entry {
             private Scope origin;

             ImportEntry(Symbol sym, Entry shadowed, Entry sibling, Scope scope, Scope origin) {
                 super(sym, shadowed, sibling, scope);
                 this.origin = origin;
             }
             public Entry next() {
                 Entry e = super.shadowed;
                 while (e.scope != null &&
                        (e.sym.name != sym.name ||
                         e.sym.owner != e.scope.owner)) // see lookup()
                     e = e.shadowed;
                 return e;
             }

             @Override
             public Scope getOrigin() { return origin; }
         }
     }

     /** An empty scope, into which you can't place anything.  Used for
      *  the scope for a variable initializer.
      */
     public static class DelegatedScope extends Scope {
         Scope delegatee;
         public static final Entry[] emptyTable = new Entry[0];

         public DelegatedScope(Scope outer) {
             super(outer, outer.owner, emptyTable);
             delegatee = outer;
         }
         public Scope dup() {
             return new DelegatedScope(next);
         }
         public Scope dupUnshared() {
             return new DelegatedScope(next);
         }
         public Scope leave() {
             return next;
         }
         public void enter(Symbol sym) {
             // only anonymous classes could be put here
         }
         public void enter(Symbol sym, Scope s) {
             // only anonymous classes could be put here
         }
         public void remove(Symbol sym) {
             throw new AssertionError(sym);
         }
         public Entry lookup(Name name) {
             return delegatee.lookup(name);
         }
     }

     /** An error scope, for which the owner should be an error symbol. */
     public static class ErrorScope extends Scope {
         ErrorScope(Scope next, Symbol errSymbol, Entry[] table) {
             super(next, /*owner=*/errSymbol, table);
         }
         public ErrorScope(Symbol errSymbol) {
             super(errSymbol);
         }
         public Scope dup() {
             return new ErrorScope(this, owner, table);
         }
         public Scope dupUnshared() {
             return new ErrorScope(this, owner, table.clone());
         }
         public Entry lookup(Name name) {
             Entry e = super.lookup(name);
             if (e.scope == null)
                 return new Entry(owner, null, null, null);
             else
                 return e;
         }
     }
 }
	/*
	* Copyright 1999-2008 Sun Microsystems, Inc. All Rights Reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Sun designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Sun in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
	* CA 95054 USA or visit www.sun.com if you need additional information or
	* have any questions.
	*/

	package com.sun.tools.javac.code;

	import com.sun.tools.javac.util.*;
	import java.util.Iterator;

	/** A scope represents an area of visibility in a Java program. The
	* Scope class is a container for symbols which provides
	* efficient access to symbols given their names. Scopes are implemented
	* as hash tables. Scopes can be nested; the next field of a scope points
	* to its next outer scope. Nested scopes can share their hash tables.
	*
	* <p><b>This is NOT part of any API supported by Sun Microsystems. If
	* you write code that depends on this, you do so at your own risk.
	* This code and its internal interfaces are subject to change or
	* deletion without notice.</b>
	*/
	public class Scope {

	/** The number of scopes that share this scope's hash table.
	*/
	private int shared;

	/** Next enclosing scope (with whom this scope may share a hashtable)
	*/
	public Scope next;

	/** The scope's owner.
	*/
	public Symbol owner;

	/** A hash table for the scope's entries.
	*/
	public Entry[] table;

	/** Mask for hash codes, always equal to (table.length - 1).
	*/
	int hashMask;

	/** A linear list that also contains all entries in
	* reverse order of appearance (i.e later entries are pushed on top).
	*/
	public Entry elems;

	/** The number of elements in this scope.
	*/
	public int nelems = 0;

	/** Every hash bucket is a list of Entry's which ends in sentinel.
	*/
	private static final Entry sentinel = new Entry(null, null, null, null);

	/** The hash table's initial size.
	*/
	private static final int INITIAL_SIZE = 0x10;

	/** A value for the empty scope.
	*/
	public static final Scope emptyScope = new Scope(null, null, new Entry[]{});

	/** Construct a new scope, within scope next, with given owner, using
	* given table. The table's length must be an exponent of 2.
	*/
	Scope(Scope next, Symbol owner, Entry[] table) {
	this.next = next;
	assert emptyScope == null \|\| owner != null;
	this.owner = owner;
	this.table = table;
	this.hashMask = table.length - 1;
	this.elems = null;
	this.nelems = 0;
	this.shared = 0;
	}

	/** Construct a new scope, within scope next, with given owner,
	* using a fresh table of length INITIAL_SIZE.
	*/
	public Scope(Symbol owner) {
	this(null, owner, new Entry[INITIAL_SIZE]);
	for (int i = 0; i < INITIAL_SIZE; i++) table[i] = sentinel;
	}

	/** Construct a fresh scope within this scope, with same owner,
	* which shares its table with the outer scope. Used in connection with
	* method leave if scope access is stack-like in order to avoid allocation
	* of fresh tables.
	*/
	public Scope dup() {
	Scope result = new Scope(this, this.owner, this.table);
	shared++;
	// System.out.println("====> duping scope " + this.hashCode() + " owned by " + this.owner + " to " + result.hashCode());
	// new Error().printStackTrace(System.out);
	return result;
	}

	/** Construct a fresh scope within this scope, with new owner,
	* which shares its table with the outer scope. Used in connection with
	* method leave if scope access is stack-like in order to avoid allocation
	* of fresh tables.
	*/
	public Scope dup(Symbol newOwner) {
	Scope result = new Scope(this, newOwner, this.table);
	shared++;
	// System.out.println("====> duping scope " + this.hashCode() + " owned by " + newOwner + " to " + result.hashCode());
	// new Error().printStackTrace(System.out);
	return result;
	}

	/** Construct a fresh scope within this scope, with same owner,
	* with a new hash table, whose contents initially are those of
	* the table of its outer scope.
	*/
	public Scope dupUnshared() {
	return new Scope(this, this.owner, this.table.clone());
	}

	/** Remove all entries of this scope from its table, if shared
	* with next.
	*/
	public Scope leave() {
	assert shared == 0;
	if (table != next.table) return next;
	while (elems != null) {
	int hash = elems.sym.name.hashCode() & hashMask;
	Entry e = table[hash];
	assert e == elems : elems.sym;
	table[hash] = elems.shadowed;
	elems = elems.sibling;
	}
	assert next.shared > 0;
	next.shared--;
	// System.out.println("====> leaving scope " + this.hashCode() + " owned by " + this.owner + " to " + next.hashCode());
	// new Error().printStackTrace(System.out);
	return next;
	}

	/** Double size of hash table.
	*/
	private void dble() {
	assert shared == 0;
	Entry[] oldtable = table;
	Entry[] newtable = new Entry[oldtable.length * 2];
	for (Scope s = this; s != null; s = s.next) {
	if (s.table == oldtable) {
	assert s == this \|\| s.shared != 0;
	s.table = newtable;
	s.hashMask = newtable.length - 1;
	}
	}
	for (int i = 0; i < newtable.length; i++) newtable[i] = sentinel;
	for (int i = 0; i < oldtable.length; i++) copy(oldtable[i]);
	}

	/** Copy the given entry and all entries shadowed by it to table
	*/
	private void copy(Entry e) {
	if (e.sym != null) {
	copy(e.shadowed);
	int hash = e.sym.name.hashCode() & hashMask;
	e.shadowed = table[hash];
	table[hash] = e;
	}
	}

	/** Enter symbol sym in this scope.
	*/
	public void enter(Symbol sym) {
	assert shared == 0;
	enter(sym, this);
	}

	public void enter(Symbol sym, Scope s) {
	enter(sym, s, s);
	}

	/**
	* Enter symbol sym in this scope, but mark that it comes from
	* given scope `s' accessed through `origin'. The last two
	* arguments are only used in import scopes.
	*/
	public void enter(Symbol sym, Scope s, Scope origin) {
	assert shared == 0;
	// Temporarily disabled (bug 6460352):
	// if (nelems * 3 >= hashMask * 2) dble();
	int hash = sym.name.hashCode() & hashMask;
	Entry e = makeEntry(sym, table[hash], elems, s, origin);
	table[hash] = e;
	elems = e;
	nelems++;
	}

	Entry makeEntry(Symbol sym, Entry shadowed, Entry sibling, Scope scope, Scope origin) {
	return new Entry(sym, shadowed, sibling, scope);
	}

	/** Remove symbol from this scope. Used when an inner class
	* attribute tells us that the class isn't a package member.
	*/
	public void remove(Symbol sym) {
	assert shared == 0;
	Entry e = lookup(sym.name);
	while (e.scope == this && e.sym != sym) e = e.next();
	if (e.scope == null) return;

	// remove e from table and shadowed list;
	Entry te = table[sym.name.hashCode() & hashMask];
	if (te == e)
	table[sym.name.hashCode() & hashMask] = e.shadowed;
	else while (true) {
	if (te.shadowed == e) {
	te.shadowed = e.shadowed;
	break;
	}
	te = te.shadowed;
	}

	// remove e from elems and sibling list
	te = elems;
	if (te == e)
	elems = e.sibling;
	else while (true) {
	if (te.sibling == e) {
	te.sibling = e.sibling;
	break;
	}
	te = te.sibling;
	}
	}

	/** Enter symbol sym in this scope if not already there.
	*/
	public void enterIfAbsent(Symbol sym) {
	assert shared == 0;
	Entry e = lookup(sym.name);
	while (e.scope == this && e.sym.kind != sym.kind) e = e.next();
	if (e.scope != this) enter(sym);
	}

	/** Given a class, is there already a class with same fully
	* qualified name in this (import) scope?
	*/
	public boolean includes(Symbol c) {
	for (Scope.Entry e = lookup(c.name);
	e.scope == this;
	e = e.next()) {
	if (e.sym == c) return true;
	}
	return false;
	}

	/** Return the entry associated with given name, starting in
	* this scope and proceeding outwards. If no entry was found,
	* return the sentinel, which is characterized by having a null in
	* both its scope and sym fields, whereas both fields are non-null
	* for regular entries.
	*/
	public Entry lookup(Name name) {
	Entry e = table[name.hashCode() & hashMask];
	while (e.scope != null && e.sym.name != name)
	e = e.shadowed;
	return e;
	}

	public Iterable<Symbol> getElements() {
	return new Iterable<Symbol>() {
	public Iterator<Symbol> iterator() {
	return new Iterator<Symbol>() {
	private Scope currScope = Scope.this;
	private Scope.Entry currEntry = elems;
	{
	update();
	}

	public boolean hasNext() {
	return currEntry != null;
	}

	public Symbol next() {
	Symbol sym = (currEntry == null ? null : currEntry.sym);
	currEntry = currEntry.sibling;
	update();
	return sym;
	}

	public void remove() {
	throw new UnsupportedOperationException();
	}

	private void update() {
	while (currEntry == null && currScope.next != null) {
	currScope = currScope.next;
	currEntry = currScope.elems;
	}
	}
	};
	}
	};

	}

	public String toString() {
	StringBuilder result = new StringBuilder();
	result.append("Scope[");
	for (Scope s = this; s != null ; s = s.next) {
	if (s != this) result.append(" \| ");
	for (Entry e = s.elems; e != null; e = e.sibling) {
	if (e != s.elems) result.append(", ");
	result.append(e.sym);
	}
	}
	result.append("]");
	return result.toString();
	}

	/** A class for scope entries.
	*/
	public static class Entry {

	/** The referenced symbol.
	* sym == null iff this == sentinel
	*/
	public Symbol sym;

	/** An entry with the same hash code, or sentinel.
	*/
	private Entry shadowed;

	/** Next entry in same scope.
	*/
	public Entry sibling;

	/** The entry's scope.
	* scope == null iff this == sentinel
	* for an entry in an import scope, this is the scope
	* where the entry came from (i.e. was imported from).
	*/
	public Scope scope;

	public Entry(Symbol sym, Entry shadowed, Entry sibling, Scope scope) {
	this.sym = sym;
	this.shadowed = shadowed;
	this.sibling = sibling;
	this.scope = scope;
	}

	/** Return next entry with the same name as this entry, proceeding
	* outwards if not found in this scope.
	*/
	public Entry next() {
	Entry e = shadowed;
	while (e.scope != null && e.sym.name != sym.name)
	e = e.shadowed;
	return e;
	}

	public Scope getOrigin() {
	// The origin is only recorded for import scopes. For all
	// other scope entries, the "enclosing" type is available
	// from other sources. See Attr.visitSelect and
	// Attr.visitIdent. Rather than throwing an assertion
	// error, we return scope which will be the same as origin
	// in many cases.
	return scope;
	}
	}

	public static class ImportScope extends Scope {

	public ImportScope(Symbol owner) {
	super(owner);
	}

	@Override
	Entry makeEntry(Symbol sym, Entry shadowed, Entry sibling, Scope scope, Scope origin) {
	return new ImportEntry(sym, shadowed, sibling, scope, origin);
	}

	public Entry lookup(Name name) {
	Entry e = table[name.hashCode() & hashMask];
	while (e.scope != null &&
	(e.sym.name != name \|\|
	/* Since an inner class will show up in package and
	* import scopes until its inner class attribute has
	* been processed, we have to weed it out here. This
	* is done by comparing the owners of the entry's
	* scope and symbol fields. The scope field's owner
	* points to where the class originally was imported
	* from. The symbol field's owner points to where the
	* class is situated now. This can change when an
	* inner class is read (see ClassReader.enterClass).
	* By comparing the two fields we make sure that we do
	* not accidentally import an inner class that started
	* life as a flat class in a package. */
	e.sym.owner != e.scope.owner))
	e = e.shadowed;
	return e;
	}

	static class ImportEntry extends Entry {
	private Scope origin;

	ImportEntry(Symbol sym, Entry shadowed, Entry sibling, Scope scope, Scope origin) {
	super(sym, shadowed, sibling, scope);
	this.origin = origin;
	}
	public Entry next() {
	Entry e = super.shadowed;
	while (e.scope != null &&
	(e.sym.name != sym.name \|\|
	e.sym.owner != e.scope.owner)) // see lookup()
	e = e.shadowed;
	return e;
	}

	@Override
	public Scope getOrigin() { return origin; }
	}
	}

	/** An empty scope, into which you can't place anything. Used for
	* the scope for a variable initializer.
	*/
	public static class DelegatedScope extends Scope {
	Scope delegatee;
	public static final Entry[] emptyTable = new Entry[0];

	public DelegatedScope(Scope outer) {
	super(outer, outer.owner, emptyTable);
	delegatee = outer;
	}
	public Scope dup() {
	return new DelegatedScope(next);
	}
	public Scope dupUnshared() {
	return new DelegatedScope(next);
	}
	public Scope leave() {
	return next;
	}
	public void enter(Symbol sym) {
	// only anonymous classes could be put here
	}
	public void enter(Symbol sym, Scope s) {
	// only anonymous classes could be put here
	}
	public void remove(Symbol sym) {
	throw new AssertionError(sym);
	}
	public Entry lookup(Name name) {
	return delegatee.lookup(name);
	}
	}

	/** An error scope, for which the owner should be an error symbol. */
	public static class ErrorScope extends Scope {
	ErrorScope(Scope next, Symbol errSymbol, Entry[] table) {
	super(next, /owner=/errSymbol, table);
	}
	public ErrorScope(Symbol errSymbol) {
	super(errSymbol);
	}
	public Scope dup() {
	return new ErrorScope(this, owner, table);
	}
	public Scope dupUnshared() {
	return new ErrorScope(this, owner, table.clone());
	}
	public Entry lookup(Name name) {
	Entry e = super.lookup(name);
	if (e.scope == null)
	return new Entry(owner, null, null, null);
	else
	return e;
	}
	}
	}