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

-:bbc9765d9ec6
+:50f9ac2f4730
 /** The number of elements in this scope.
 */
 public int nelems = 0;
+/** A timestamp - useful to quickly check whether a scope has changed or not
+*/
+public ScopeCounter scopeCounter;
+static ScopeCounter dummyCounter = new ScopeCounter() {
+@Override
+public void inc() {
+//do nothing
+}
+};
+public static class ScopeCounter {
+protected static final Context.Key<ScopeCounter> scopeCounterKey =
+new Context.Key<ScopeCounter>();
+public static ScopeCounter instance(Context context) {
+ScopeCounter instance = context.get(scopeCounterKey);
+if (instance == null)
+instance = new ScopeCounter(context);
+return instance;
+}
+protected ScopeCounter(Context context) {
+context.put(scopeCounterKey, this);
+}
+private ScopeCounter() {};
+private long val = 0;
+public void inc() {
+val++;
+}
+public long val() {
+return val;
+}
+}
 /** 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[]{});
+public static final Scope emptyScope = new Scope(null, null, new Entry[]{}, dummyCounter);
 /** 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) {
+private Scope(Scope next, Symbol owner, Entry[] table, ScopeCounter scopeCounter) {
 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;
 }
 /** 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]);
+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() {
-Scope result = new Scope(this, this.owner, this.table);
+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;
 }
 *  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.
 */
 int hash = sym.name.hashCode() & hashMask;
 Entry e = makeEntry(sym, table[hash], 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);
 }
 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;
 Entry te = table[sym.name.hashCode() & hashMask];
 if (te == e)
 table[sym.name.hashCode() & hashMask] = e.shadowed;
 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);
+super(outer, outer.owner, emptyTable, outer.scopeCounter);
 delegatee = outer;
 }
 public Scope dup() {
 return new DelegatedScope(next);
 }
 public void remove(Symbol sym) {
 throw new AssertionError(sym);
 }
 public Entry lookup(Name name) {
 return delegatee.lookup(name);
+}
+}
+/** A class scope, for which a scope counter should be provided */
+public static class ClassScope extends Scope {
+ClassScope(Scope next, Symbol owner, Entry[] table, ScopeCounter scopeCounter) {
+super(next, owner, table, scopeCounter);
+}
+public ClassScope(Symbol owner, ScopeCounter scopeCounter) {
+super(owner, scopeCounter);
 }
 }
 /** 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);
+super(next, /*owner=*/errSymbol, table, dummyCounter);
 }
 public ErrorScope(Symbol errSymbol) {
 super(errSymbol);
 }
 public Scope dup() {

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