jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/javac/code/Scope.java

-:895bea45a3e8
+:6ce6ee1b831a
 /*
-* Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1999, 2008, Oracle and/or its affiliates. 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.  Oracle designates this
 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 with "open addressing" and "double hashing".
+*  as hash tables. Scopes can be nested; the next field of a scope points
-*  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 supported API.
 *  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
 *  reverse order of appearance (i.e later entries are pushed on top).
 */
 public Entry elems;
 /** The number of elements in this scope.
-* This includes deleted elements, whose value is the sentinel.
 */
 public int nelems = 0;
 /** A timestamp - useful to quickly check whether a scope has changed or not
 */
 public long val() {
 return val;
 }
 }
-/** Use as a "not-found" result for lookup.
+/** Every hash bucket is a list of Entry's which ends in sentinel.
-* Also used to mark deleted entries in the table.
 */
 private static final Entry sentinel = new Entry(null, null, null, null);
 /** The hash table's initial size.
 */
 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;
 this.scopeCounter = scopeCounter;
-}
-/** Convenience constructor used for dup and dupUnshared. */
-private Scope(Scope next, Symbol owner, Entry[] table) {
-this(next, owner, table, next.scopeCounter);
-this.nelems = next.nelems;
 }
 /** Construct a new scope, within scope next, with given owner,
 *  using a fresh table of length INITIAL_SIZE.
 */
 this(owner, dummyCounter);
 }
 protected Scope(Symbol owner, ScopeCounter scopeCounter) {
 this(null, owner, new Entry[INITIAL_SIZE], scopeCounter);
+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() {
-return dup(this.owner);
+Scope result = new Scope(this, this.owner, this.table, scopeCounter);
+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);
+Scope result = new Scope(this, newOwner, this.table, scopeCounter);
 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());
+return new Scope(this, this.owner, this.table.clone(), scopeCounter);
 }
 /** 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 = getIndex(elems.sym.name);
+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--;
-next.nelems = nelems;
 // System.out.println("====> leaving scope " + this.hashCode() + " owned by " + this.owner + " to " + next.hashCode());
 // new Error().printStackTrace(System.out);
 return next;
 }
 assert s == this || s.shared != 0;
 s.table = newtable;
 s.hashMask = newtable.length - 1;
 }
 }
-int n = 0;
+for (int i = 0; i < newtable.length; i++) newtable[i] = sentinel;
-for (int i = oldtable.length; --i >= 0; ) {
+for (int i = 0; i < oldtable.length; i++) copy(oldtable[i]);
-Entry e = oldtable[i];
+}
-if (e != null && e != sentinel) {
-table[getIndex(e.sym.name)] = e;
+/** Copy the given entry and all entries shadowed by it to table
-n++;
+*/
-}
+private void copy(Entry e) {
-}
+if (e.sym != null) {
-// We don't need to update nelems for shared inherited scopes,
+copy(e.shadowed);
-// since that gets handled by leave().
+int hash = e.sym.name.hashCode() & hashMask;
-nelems = n;
+e.shadowed = table[hash];
+table[hash] = e;
+}
 }
 /** Enter symbol sym in this scope.
 */
 public void enter(Symbol sym) {
 * 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;
-if (nelems * 3 >= hashMask * 2)
+// Temporarily disabled (bug 6460352):
-dble();
+// if (nelems * 3 >= hashMask * 2) dble();
-int hash = getIndex(sym.name);
+int hash = sym.name.hashCode() & hashMask;
-Entry old = table[hash];
+Entry e = makeEntry(sym, table[hash], elems, s, origin);
-if (old == null) {
-old = sentinel;
-nelems++;
-}
-Entry e = makeEntry(sym, old, elems, s, origin);
 table[hash] = e;
 elems = e;
+nelems++;
 scopeCounter.inc();
 }
 Entry makeEntry(Symbol sym, Entry shadowed, Entry sibling, Scope scope, Scope origin) {
 return new Entry(sym, shadowed, sibling, scope);
 *  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;
 scopeCounter.inc();
 // remove e from table and shadowed list;
-int i = getIndex(sym.name);
+Entry te = table[sym.name.hashCode() & hashMask];
-Entry te = table[i];
 if (te == e)
-table[i] = e.shadowed;
+table[sym.name.hashCode() & hashMask] = e.shadowed;
 else while (true) {
 if (te.shadowed == e) {
 te.shadowed = e.shadowed;
 break;
 }
 */
 public Entry lookup(Name name) {
 return lookup(name, noFilter);
 }
 public Entry lookup(Name name, Filter<Symbol> sf) {
-Entry e = table[getIndex(name)];
+Entry e = table[name.hashCode() & hashMask];
-if (e == null || e == sentinel)
-return sentinel;
 while (e.scope != null && (e.sym.name != name || !sf.accepts(e.sym)))
 e = e.shadowed;
 return e;
-}
-/*void dump (java.io.PrintStream out) {
-out.println(this);
-for (int l=0; l < table.length; l++) {
-Entry le = table[l];
-out.print("#"+l+": ");
-if (le==sentinel) out.println("sentinel");
-else if(le == null) out.println("null");
-else out.println(""+le+" s:"+le.sym);
-}
-}*/
-/** Look for slot in the table.
-*  We use open addressing with double hashing.
-*/
-int getIndex (Name name) {
-int h = name.hashCode();
-int i = h & hashMask;
-// The expression below is always odd, so it is guaranteed
-// be be mutually prime with table.length, a power of 2.
-int x = hashMask - ((h + (h >> 16)) << 1);
-int d = -1; // Index of a deleted item.
-for (;;) {
-Entry e = table[i];
-if (e == null)
-return d >= 0 ? d : i;
-if (e == sentinel) {
-// We have to keep searching even if we see a deleted item.
-// However, remember the index in case we fail to find the name.
-if (d < 0)
-d = i;
-} else if (e.sym.name == name)
-return i;
-i = (i + x) & hashMask;
-}
 }
 public Iterable<Symbol> getElements() {
 return getElements(noFilter);
 }
 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[getIndex(name)];
+Entry e = table[name.hashCode() & hashMask];
-if (e == null)
-return sentinel;
 while (e.scope != null &&
-(/* Since an inner class will show up in package and
+(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

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/javac/code/Scope.java

src/share/classes/com/sun/tools/javac/code/Scope.java