jdk-sandbox: comparison langtools/src/share/classes/com/sun/tools/javac/util/Name.java

equal deleted inserted replaced

-:61142e0aeb3f
+:a772ba9ba43d
 * have any questions.
 */
 package com.sun.tools.javac.util;
-import java.lang.ref.SoftReference;
+/** An abstraction for internal compiler strings. They are stored in
+*  Utf8 format. Names are stored in a Name.Table, and are unique within
+*  that table.
-/** An abstraction for internal compiler strings. For efficiency reasons,
-*  GJC uses hashed strings that are stored in a common large buffer.
-*
-*  <p>Names represent unique hashable strings. Two names are equal
-*  if their indices are equal. Utf8 representation is used
-*  for storing names internally.
 *
 *  <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 Name implements javax.lang.model.element.Name {
+public abstract class Name implements javax.lang.model.element.Name {
-/** The table structure where the name is stored
+public final Table table;
-*/
-public Table table;
+protected Name(Table table) {
+this.table = table;
-/** The index where the bytes of this name are stored in the global name
+}
-*  buffer `names'.
-*/
+/**
-public int index;
+* @inheritDoc
+*/
-/** The number of bytes in this name.
+public boolean contentEquals(CharSequence cs) {
-*/
+return toString().equals(cs.toString());
-public int len;
+}
-/** The next name occupying the same hash bucket.
+/**
-*/
+* @inheritDoc
-Name next;
-/** The hashcode of a name.
-*/
-private static int hashValue(byte cs[], int start, int len) {
-int h = 0;
-int off = start;
-for (int i = 0; i < len; i++) {
-h = (h << 5) - h + cs[off++];
-}
-return h;
-}
-/** Is (the utf8 representation of) name equal to
-*  cs[start..start+len-1]?
-*/
-private static boolean equals(byte[] names, int index,
-byte cs[], int start, int len) {
-int i = 0;
-while (i < len && names[index + i] == cs[start + i]) i++;
-return i == len;
-}
-/** Create a name from the bytes in cs[start..start+len-1].
-*  Assume that bytes are in utf8 format.
-*/
-public static Name fromUtf(Table table, byte cs[], int start, int len) {
-int h = hashValue(cs, start, len) & table.hashMask;
-Name n = table.hashes[h];
-byte[] names = table.names;
-while (n != null &&
-(n.len != len || !equals(names, n.index, cs, start, len)))
-n = n.next;
-if (n == null) {
-int nc = table.nc;
-while (nc + len > names.length) {
-//              System.err.println("doubling name buffer of length + " + names.length + " to fit " + len + " bytes");//DEBUG
-byte[] newnames = new byte[names.length * 2];
-System.arraycopy(names, 0, newnames, 0, names.length);
-names = table.names = newnames;
-}
-System.arraycopy(cs, start, names, nc, len);
-n = new Name();
-n.table = table;
-n.index = nc;
-n.len = len;
-n.next = table.hashes[h];
-table.hashes[h] = n;
-table.nc = nc + len;
-if (len == 0) table.nc++;
-}
-return n;
-}
-/** Create a name from the bytes in array cs.
-*  Assume that bytes are in utf8 format.
-*/
-public static Name fromUtf(Table table, byte cs[]) {
-return fromUtf(table, cs, 0, cs.length);
-}
-/** Create a name from the characters in cs[start..start+len-1].
-*/
-public static Name fromChars(Table table, char[] cs, int start, int len) {
-int nc = table.nc;
-byte[] names = table.names;
-while (nc + len * 3 >= names.length) {
-//          System.err.println("doubling name buffer of length " + names.length + " to fit " + len + " chars");//DEBUG
-byte[] newnames = new byte[names.length * 2];
-System.arraycopy(names, 0, newnames, 0, names.length);
-names = table.names = newnames;
-}
-int nbytes =
-Convert.chars2utf(cs, start, names, nc, len) - nc;
-int h = hashValue(names, nc, nbytes) & table.hashMask;
-Name n = table.hashes[h];
-while (n != null &&
-(n.len != nbytes ||
-!equals(names, n.index, names, nc, nbytes)))
-n = n.next;
-if (n == null) {
-n = new Name();
-n.table = table;
-n.index = nc;
-n.len = nbytes;
-n.next = table.hashes[h];
-table.hashes[h] = n;
-table.nc = nc + nbytes;
-if (nbytes == 0) table.nc++;
-}
-return n;
-}
-/** Create a name from the characters in string s.
-*/
-public static Name fromString(Table table, String s) {
-char[] cs = s.toCharArray();
-return fromChars(table, cs, 0, cs.length);
-}
-/** Create a name from the characters in char sequence s.
-*/
-public static Name fromString(Table table, CharSequence s) {
-return fromString(table, s.toString());
-}
-/** Return the Utf8 representation of this name.
-*/
-public byte[] toUtf() {
-byte[] bs = new byte[len];
-System.arraycopy(table.names, index, bs, 0, len);
-return bs;
-}
-/** Return the string representation of this name.
-*/
-public String toString() {
-return Convert.utf2string(table.names, index, len);
-}
-/** Copy all bytes of this name to buffer cs, starting at start.
-*/
-public void getBytes(byte cs[], int start) {
-System.arraycopy(table.names, index, cs, start, len);
-}
-/** Return the hash value of this name.
-*/
-public int hashCode() {
-return index;
-}
-/** Is this name equal to other?
-*/
-public boolean equals(Object other) {
-if (other instanceof Name)
-return
-table == ((Name)other).table && index == ((Name)other).index;
-else return false;
-}
-/** Compare this name to other name, yielding -1 if smaller, 0 if equal,
-*  1 if greater.
-*/
-public boolean less(Name that) {
-int i = 0;
-while (i < this.len && i < that.len) {
-byte thisb = this.table.names[this.index + i];
-byte thatb = that.table.names[that.index + i];
-if (thisb < thatb) return true;
-else if (thisb > thatb) return false;
-else i++;
-}
-return this.len < that.len;
-}
-/** Returns the length of this name.
 */
 public int length() {
 return toString().length();
 }
-/** Returns i'th byte of this name.
+/**
-*/
+* @inheritDoc
-public byte byteAt(int i) {
+*/
-return table.names[index + i];
+public char charAt(int index) {
-}
+return toString().charAt(index);
+}
-/** Returns first occurrence of byte b in this name, len if not found.
-*/
+/**
-public int indexOf(byte b) {
+* @inheritDoc
-byte[] names = table.names;
+*/
+public CharSequence subSequence(int start, int end) {
+return toString().subSequence(start, end);
+}
+/** Return the concatenation of this name and name `n'.
+*/
+public Name append(Name n) {
+int len = getByteLength();
+byte[] bs = new byte[len + n.getByteLength()];
+getBytes(bs, 0);
+n.getBytes(bs, len);
+return table.fromUtf(bs, 0, bs.length);
+}
+/** Return the concatenation of this name, the given ASCII
+*  character, and name `n'.
+*/
+public Name append(char c, Name n) {
+int len = getByteLength();
+byte[] bs = new byte[len + 1 + n.getByteLength()];
+getBytes(bs, 0);
+bs[len] = (byte) c;
+n.getBytes(bs, len+1);
+return table.fromUtf(bs, 0, bs.length);
+}
+/** An arbitrary but consistent complete order among all Names.
+*/
+public int compareTo(Name other) {
+return other.getIndex() - this.getIndex();
+}
+/** Return true if this is the empty name.
+*/
+public boolean isEmpty() {
+return getByteLength() == 0;
+}
+/** Returns last occurrence of byte b in this name, -1 if not found.
+*/
+public int lastIndexOf(byte b) {
+byte[] bytes = getByteArray();
+int offset = getByteOffset();
+int i = getByteLength() - 1;
+while (i >= 0 && bytes[offset + i] != b) i--;
+return i;
+}
+/** Does this name start with prefix?
+*/
+public boolean startsWith(Name prefix) {
+byte[] thisBytes = this.getByteArray();
+int thisOffset   = this.getByteOffset();
+int thisLength   = this.getByteLength();
+byte[] prefixBytes = prefix.getByteArray();
+int prefixOffset   = prefix.getByteOffset();
+int prefixLength   = prefix.getByteLength();
 int i = 0;
-while (i < len && names[index + i] != b) i++;
+while (i < prefixLength &&
-return i;
+i < thisLength &&
-}
+thisBytes[thisOffset + i] == prefixBytes[prefixOffset + i])
-/** Returns last occurrence of byte b in this name, -1 if not found.
-*/
-public int lastIndexOf(byte b) {
-byte[] names = table.names;
-int i = len - 1;
-while (i >= 0 && names[index + i] != b) i--;
-return i;
-}
-/** Does this name start with prefix?
-*/
-public boolean startsWith(Name prefix) {
-int i = 0;
-while (i < prefix.len &&
-i < len &&
-table.names[index + i] == prefix.table.names[prefix.index + i])
 i++;
-return i == prefix.len;
+return i == prefixLength;
-}
-/** Does this name end with suffix?
-*/
-public boolean endsWith(Name suffix) {
-int i = len - 1;
-int j = suffix.len - 1;
-while (j >= 0 && i >= 0 &&
-table.names[index + i] == suffix.table.names[suffix.index + j]) {
-i--; j--;
-}
-return j < 0;
 }
 /** Returns the sub-name starting at position start, up to and
 *  excluding position end.
 */
 public Name subName(int start, int end) {
 if (end < start) end = start;
-return fromUtf(table, table.names, index + start, end - start);
+return table.fromUtf(getByteArray(), getByteOffset() + start, end - start);
 }
-/** Replace all `from' bytes in this name with `to' bytes.
+/** Return the string representation of this name.
 */
-public Name replace(byte from, byte to) {
+public String toString() {
-byte[] names = table.names;
+return Convert.utf2string(getByteArray(), getByteOffset(), getByteLength());
-int i = 0;
+}
-while (i < len) {
-if (names[index + i] == from) {
+/** Return the Utf8 representation of this name.
-byte[] bs = new byte[len];
+*/
-System.arraycopy(names, index, bs, 0, i);
+public byte[] toUtf() {
-bs[i] = to;
+byte[] bs = new byte[getByteLength()];
+getBytes(bs, 0);
+return bs;
+}
+/* Get a "reasonably small" value that uniquely identifies this name
+* within its name table.
+*/
+public abstract int getIndex();
+/** Get the length (in bytes) of this name.
+*/
+public abstract int getByteLength();
+/** Returns i'th byte of this name.
+*/
+public abstract byte getByteAt(int i);
+/** Copy all bytes of this name to buffer cs, starting at start.
+*/
+public void getBytes(byte cs[], int start) {
+System.arraycopy(getByteArray(), getByteOffset(), cs, start, getByteLength());
+}
+/** Get the underlying byte array for this name. The contents of the
+* array must not be modified.
+*/
+public abstract byte[] getByteArray();
+/** Get the start offset of this name within its byte array.
+*/
+public abstract int getByteOffset();
+/** An abstraction for the hash table used to create unique Name instances.
+*/
+public static abstract class Table {
+/** Standard name table.
+*/
+public final Names names;
+Table(Names names) {
+this.names = names;
+}
+/** Get the name from the characters in cs[start..start+len-1].
+*/
+public abstract Name fromChars(char[] cs, int start, int len);
+/** Get the name for the characters in string s.
+*/
+public Name fromString(String s) {
+char[] cs = s.toCharArray();
+return fromChars(cs, 0, cs.length);
+}
+/** Get the name for the bytes in array cs.
+*  Assume that bytes are in utf8 format.
+*/
+public Name fromUtf(byte[] cs) {
+return fromUtf(cs, 0, cs.length);
+}
+/** get the name for the bytes in cs[start..start+len-1].
+*  Assume that bytes are in utf8 format.
+*/
+public abstract Name fromUtf(byte[] cs, int start, int len);
+/** Release any resources used by this table.
+*/
+public abstract void dispose();
+/** The hashcode of a name.
+*/
+protected static int hashValue(byte bytes[], int offset, int length) {
+int h = 0;
+int off = offset;
+for (int i = 0; i < length; i++) {
+h = (h << 5) - h + bytes[off++];
+}
+return h;
+}
+/** Compare two subarrays
+*/
+protected static boolean equals(byte[] bytes1, int offset1,
+byte[] bytes2, int offset2, int length) {
+int i = 0;
+while (i < length && bytes1[offset1 + i] == bytes2[offset2 + i]) {
 i++;
-while (i < len) {
-byte b = names[index + i];
-bs[i] = b == from ? to : b;
-i++;
-}
-return fromUtf(table, bs, 0, len);
 }
-i++;
+return i == length;
 }
-return this;
-}
-/** Return the concatenation of this name and name `n'.
-*/
-public Name append(Name n) {
-byte[] bs = new byte[len + n.len];
-getBytes(bs, 0);
-n.getBytes(bs, len);
-return fromUtf(table, bs, 0, bs.length);
-}
-/** Return the concatenation of this name, the given ASCII
-*  character, and name `n'.
-*/
-public Name append(char c, Name n) {
-byte[] bs = new byte[len + n.len + 1];
-getBytes(bs, 0);
-bs[len] = (byte)c;
-n.getBytes(bs, len+1);
-return fromUtf(table, bs, 0, bs.length);
-}
-/** An arbitrary but consistent complete order among all Names.
-*/
-public int compareTo(Name other) {
-return other.index - this.index;
-}
-/** Return the concatenation of all names in the array `ns'.
-*/
-public static Name concat(Table table, Name ns[]) {
-int len = 0;
-for (int i = 0; i < ns.length; i++)
-len = len + ns[i].len;
-byte[] bs = new byte[len];
-len = 0;
-for (int i = 0; i < ns.length; i++) {
-ns[i].getBytes(bs, len);
-len = len + ns[i].len;
-}
-return fromUtf(table, bs, 0, len);
-}
-public char charAt(int index) {
-return toString().charAt(index);
-}
-public CharSequence subSequence(int start, int end) {
-return toString().subSequence(start, end);
-}
-public boolean contentEquals(CharSequence cs) {
-return this.toString().equals(cs.toString());
-}
-public static class Table {
-// maintain a freelist of recently used name tables for reuse.
-private static List<SoftReference<Table>> freelist = List.nil();
-static private synchronized Table make() {
-while (freelist.nonEmpty()) {
-Table t = freelist.head.get();
-freelist = freelist.tail;
-if (t != null) return t;
-}
-return new Table();
-}
-static private synchronized void dispose(Table t) {
-freelist = freelist.prepend(new SoftReference<Table>(t));
-}
-public void dispose() {
-dispose(this);
-}
-public static final Context.Key<Table> namesKey =
-new Context.Key<Table>();
-public static Table instance(Context context) {
-Table instance = context.get(namesKey);
-if (instance == null) {
-instance = make();
-context.put(namesKey, instance);
-}
-return instance;
-}
-/** The hash table for names.
-*/
-private Name[] hashes;
-/** The array holding all encountered names.
-*/
-public byte[] names;
-/** The mask to be used for hashing
-*/
-private int hashMask;
-/** The number of filled bytes in `names'.
-*/
-private int nc = 0;
-/** Allocator
-*  @param hashSize the (constant) size to be used for the hash table
-*                  needs to be a power of two.
-*  @param nameSize the initial size of the name table.
-*/
-public Table(int hashSize, int nameSize) {
-hashMask = hashSize - 1;
-hashes = new Name[hashSize];
-names = new byte[nameSize];
-slash = fromString("/");
-hyphen = fromString("-");
-T = fromString("T");
-slashequals = fromString("/=");
-deprecated = fromString("deprecated");
-init = fromString("<init>");
-clinit = fromString("<clinit>");
-error = fromString("<error>");
-any = fromString("<any>");
-empty = fromString("");
-one = fromString("1");
-period = fromString(".");
-comma = fromString(",");
-semicolon = fromString(";");
-asterisk = fromString("*");
-_this = fromString("this");
-_super = fromString("super");
-_default = fromString("default");
-_class = fromString("class");
-java_lang = fromString("java.lang");
-java_lang_Object = fromString("java.lang.Object");
-java_lang_Class = fromString("java.lang.Class");
-java_lang_Cloneable = fromString("java.lang.Cloneable");
-java_io_Serializable = fromString("java.io.Serializable");
-java_lang_Enum = fromString("java.lang.Enum");
-package_info = fromString("package-info");
-serialVersionUID = fromString("serialVersionUID");
-ConstantValue = fromString("ConstantValue");
-LineNumberTable = fromString("LineNumberTable");
-LocalVariableTable = fromString("LocalVariableTable");
-LocalVariableTypeTable = fromString("LocalVariableTypeTable");
-CharacterRangeTable = fromString("CharacterRangeTable");
-StackMap = fromString("StackMap");
-StackMapTable = fromString("StackMapTable");
-SourceID = fromString("SourceID");
-CompilationID = fromString("CompilationID");
-Code = fromString("Code");
-Exceptions = fromString("Exceptions");
-SourceFile = fromString("SourceFile");
-InnerClasses = fromString("InnerClasses");
-Synthetic = fromString("Synthetic");
-Bridge= fromString("Bridge");
-Deprecated = fromString("Deprecated");
-Enum = fromString("Enum");
-_name = fromString("name");
-Signature = fromString("Signature");
-Varargs = fromString("Varargs");
-Annotation = fromString("Annotation");
-RuntimeVisibleAnnotations = fromString("RuntimeVisibleAnnotations");
-RuntimeInvisibleAnnotations = fromString("RuntimeInvisibleAnnotations");
-RuntimeVisibleParameterAnnotations = fromString("RuntimeVisibleParameterAnnotations");
-RuntimeInvisibleParameterAnnotations = fromString("RuntimeInvisibleParameterAnnotations");
-Value = fromString("Value");
-EnclosingMethod = fromString("EnclosingMethod");
-desiredAssertionStatus = fromString("desiredAssertionStatus");
-append  = fromString("append");
-family  = fromString("family");
-forName = fromString("forName");
-toString = fromString("toString");
-length = fromString("length");
-valueOf = fromString("valueOf");
-value = fromString("value");
-getMessage = fromString("getMessage");
-getClass = fromString("getClass");
-TYPE = fromString("TYPE");
-FIELD = fromString("FIELD");
-METHOD = fromString("METHOD");
-PARAMETER = fromString("PARAMETER");
-CONSTRUCTOR = fromString("CONSTRUCTOR");
-LOCAL_VARIABLE = fromString("LOCAL_VARIABLE");
-ANNOTATION_TYPE = fromString("ANNOTATION_TYPE");
-PACKAGE = fromString("PACKAGE");
-SOURCE = fromString("SOURCE");
-CLASS = fromString("CLASS");
-RUNTIME = fromString("RUNTIME");
-Array = fromString("Array");
-Method = fromString("Method");
-Bound = fromString("Bound");
-clone = fromString("clone");
-getComponentType = fromString("getComponentType");
-getClassLoader = fromString("getClassLoader");
-initCause = fromString("initCause");
-values = fromString("values");
-iterator = fromString("iterator");
-hasNext = fromString("hasNext");
-next = fromString("next");
-AnnotationDefault = fromString("AnnotationDefault");
-ordinal = fromString("ordinal");
-equals = fromString("equals");
-hashCode = fromString("hashCode");
-compareTo = fromString("compareTo");
-getDeclaringClass = fromString("getDeclaringClass");
-ex = fromString("ex");
-finalize = fromString("finalize");
-}
-public Table() {
-this(0x8000, 0x20000);
-}
-/** Create a name from the bytes in cs[start..start+len-1].
-*  Assume that bytes are in utf8 format.
-*/
-public Name fromUtf(byte cs[], int start, int len) {
-return Name.fromUtf(this, cs, start, len);
-}
-/** Create a name from the bytes in array cs.
-*  Assume that bytes are in utf8 format.
-*/
-public Name fromUtf(byte cs[]) {
-return Name.fromUtf(this, cs, 0, cs.length);
-}
-/** Create a name from the characters in cs[start..start+len-1].
-*/
-public Name fromChars(char[] cs, int start, int len) {
-return Name.fromChars(this, cs, start, len);
-}
-/** Create a name from the characters in string s.
-*/
-public Name fromString(CharSequence s) {
-return Name.fromString(this, s);
-}
-public final Name slash;
-public final Name hyphen;
-public final Name T;
-public final Name slashequals;
-public final Name deprecated;
-public final Name init;
-public final Name clinit;
-public final Name error;
-public final Name any;
-public final Name empty;
-public final Name one;
-public final Name period;
-public final Name comma;
-public final Name semicolon;
-public final Name asterisk;
-public final Name _this;
-public final Name _super;
-public final Name _default;
-public final Name _class;
-public final Name java_lang;
-public final Name java_lang_Object;
-public final Name java_lang_Class;
-public final Name java_lang_Cloneable;
-public final Name java_io_Serializable;
-public final Name serialVersionUID;
-public final Name java_lang_Enum;
-public final Name package_info;
-public final Name ConstantValue;
-public final Name LineNumberTable;
-public final Name LocalVariableTable;
-public final Name LocalVariableTypeTable;
-public final Name CharacterRangeTable;
-public final Name StackMap;
-public final Name StackMapTable;
-public final Name SourceID;
-public final Name CompilationID;
-public final Name Code;
-public final Name Exceptions;
-public final Name SourceFile;
-public final Name InnerClasses;
-public final Name Synthetic;
-public final Name Bridge;
-public final Name Deprecated;
-public final Name Enum;
-public final Name _name;
-public final Name Signature;
-public final Name Varargs;
-public final Name Annotation;
-public final Name RuntimeVisibleAnnotations;
-public final Name RuntimeInvisibleAnnotations;
-public final Name RuntimeVisibleParameterAnnotations;
-public final Name RuntimeInvisibleParameterAnnotations;
-public final Name Value;
-public final Name EnclosingMethod;
-public final Name desiredAssertionStatus;
-public final Name append;
-public final Name family;
-public final Name forName;
-public final Name toString;
-public final Name length;
-public final Name valueOf;
-public final Name value;
-public final Name getMessage;
-public final Name getClass;
-public final Name TYPE;
-public final Name FIELD;
-public final Name METHOD;
-public final Name PARAMETER;
-public final Name CONSTRUCTOR;
-public final Name LOCAL_VARIABLE;
-public final Name ANNOTATION_TYPE;
-public final Name PACKAGE;
-public final Name SOURCE;
-public final Name CLASS;
-public final Name RUNTIME;
-public final Name Array;
-public final Name Method;
-public final Name Bound;
-public final Name clone;
-public final Name getComponentType;
-public final Name getClassLoader;
-public final Name initCause;
-public final Name values;
-public final Name iterator;
-public final Name hasNext;
-public final Name next;
-public final Name AnnotationDefault;
-public final Name ordinal;
-public final Name equals;
-public final Name hashCode;
-public final Name compareTo;
-public final Name getDeclaringClass;
-public final Name ex;
-public final Name finalize;
-}
-public boolean isEmpty() {
-return len == 0;
 }
 }

changeset 1260	a772ba9ba43d
parent 10	06bc494ca11e
child 1264	076a3cde30d5