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

-:4a1c57a1c410
+:c002fdee76fd
 import com.sun.tools.javac.util.*;
 import static com.sun.tools.javac.code.BoundKind.*;
 import static com.sun.tools.javac.code.Flags.*;
 import static com.sun.tools.javac.code.Kinds.*;
-import static com.sun.tools.javac.code.TypeTags.*;
+import static com.sun.tools.javac.code.TypeTag.*;
 import static com.sun.tools.javac.jvm.UninitializedType.*;
 import static com.sun.tools.javac.main.Option.*;
 import static javax.tools.StandardLocation.CLASS_OUTPUT;
 ******************************************************************/
 /** Assemble signature of given type in string buffer.
 */
 void assembleSig(Type type) {
-switch (type.tag) {
+switch (type.getTag()) {
 case BYTE:
 sigbuf.appendByte('B');
 break;
 case SHORT:
 sigbuf.appendByte('S');
 // we don't yet have a spec for uninitialized types in the
 // local variable table
 assembleSig(types.erasure(((UninitializedType)type).qtype));
 break;
 default:
-throw new AssertionError("typeSig " + type.tag);
+throw new AssertionError("typeSig " + type.getTag());
 }
 }
 boolean hasTypeVar(List<Type> l) {
 while (l.nonEmpty()) {
-if (l.head.tag == TypeTags.TYPEVAR) return true;
+if (l.head.hasTag(TYPEVAR)) return true;
 l = l.tail;
 }
 return false;
 }
 /** Given a type t, return the extended class name of its erasure in
 *  external representation.
 */
 public Name xClassName(Type t) {
-if (t.tag == CLASS) {
+if (t.hasTag(CLASS)) {
 return names.fromUtf(externalize(t.tsym.flatName()));
-} else if (t.tag == ARRAY) {
+} else if (t.hasTag(ARRAY)) {
 return typeSig(types.erasure(t));
 } else {
 throw new AssertionError("xClassName");
 }
 }
 throw new StringOverflow(value.toString());
 } else if (value instanceof ClassSymbol) {
 ClassSymbol c = (ClassSymbol)value;
 if (c.owner.kind == TYP) pool.put(c.owner);
 poolbuf.appendByte(CONSTANT_Class);
-if (c.type.tag == ARRAY) {
+if (c.type.hasTag(ARRAY)) {
 poolbuf.appendChar(pool.put(typeSig(c.type)));
 } else {
 poolbuf.appendChar(pool.put(names.fromUtf(externalize(c.flatname))));
 enterInner(c);
 }
 MethodType mtype = (MethodType)value;
 poolbuf.appendByte(CONSTANT_MethodType);
 poolbuf.appendChar(pool.put(typeSig(mtype)));
 } else if (value instanceof Type) {
 Type type = (Type)value;
-if (type.tag == CLASS) enterInner((ClassSymbol)type.tsym);
+if (type.hasTag(CLASS)) enterInner((ClassSymbol)type.tsym);
 poolbuf.appendByte(CONSTANT_Class);
 poolbuf.appendChar(pool.put(xClassName(type)));
 } else if (value instanceof Pool.MethodHandle) {
 Pool.MethodHandle ref = (Pool.MethodHandle)value;
 poolbuf.appendByte(CONSTANT_MethodHandle);
 *  single-character marker.
 */
 class AttributeWriter implements Attribute.Visitor {
 public void visitConstant(Attribute.Constant _value) {
 Object value = _value.value;
-switch (_value.type.tag) {
+switch (_value.type.getTag()) {
 case BYTE:
 databuf.appendByte('B');
 break;
 case CHAR:
 databuf.appendByte('C');
 c.complete();
 } catch (CompletionFailure ex) {
 System.err.println("error: " + c + ": " + ex.getMessage());
 throw ex;
 }
-if (c.type.tag != CLASS) return; // arrays
+if (!c.type.hasTag(CLASS)) return; // arrays
 if (pool != null && // pool might be null if called from xClassName
 c.owner.enclClass() != null &&
 (innerClasses == null || !innerClasses.contains(c))) {
 //          log.errWriter.println("enter inner " + c);//DEBUG
 enterInner(c.owner.enclClass());
 void writeStackMapType(Type t) {
 if (t == null) {
 if (debugstackmap) System.out.print("empty");
 databuf.appendByte(0);
 }
-else switch(t.tag) {
+else switch(t.getTag()) {
 case BYTE:
 case CHAR:
 case SHORT:
 case INT:
 case BOOLEAN:
 // FULL_FRAME
 return new FullFrame(offset_delta, locals, stack);
 }
 static boolean isInt(Type t) {
-return (t.tag < TypeTags.INT || t.tag == TypeTags.BOOLEAN);
+return (t.getTag().isStrictSubRangeOf(INT)  || t.hasTag(BOOLEAN));
 }
 static boolean isSameType(Type t1, Type t2, Types types) {
 if (t1 == null) { return t2 == null; }
 if (t2 == null) { return false; }
 if (isInt(t1) && isInt(t2)) { return true; }
-if (t1.tag == UNINITIALIZED_THIS) {
+if (t1.hasTag(UNINITIALIZED_THIS)) {
-return t2.tag == UNINITIALIZED_THIS;
+return t2.hasTag(UNINITIALIZED_THIS);
-} else if (t1.tag == UNINITIALIZED_OBJECT) {
+} else if (t1.hasTag(UNINITIALIZED_OBJECT)) {
-if (t2.tag == UNINITIALIZED_OBJECT) {
+if (t2.hasTag(UNINITIALIZED_OBJECT)) {
 return ((UninitializedType)t1).offset == ((UninitializedType)t2).offset;
 } else {
 return false;
 }
-} else if (t2.tag == UNINITIALIZED_THIS || t2.tag == UNINITIALIZED_OBJECT) {
+} else if (t2.hasTag(UNINITIALIZED_THIS) || t2.hasTag(UNINITIALIZED_OBJECT)) {
 return false;
 }
 return types.isSameType(t1, t2);
 }
 pw.println("---" + flagNames(flags));
 }
 databuf.appendChar(flags);
 databuf.appendChar(pool.put(c));
-databuf.appendChar(supertype.tag == CLASS ? pool.put(supertype.tsym) : 0);
+databuf.appendChar(supertype.hasTag(CLASS) ? pool.put(supertype.tsym) : 0);
 databuf.appendChar(interfaces.length());
 for (List<Type> l = interfaces; l.nonEmpty(); l = l.tail)
 databuf.appendChar(pool.put(l.head.tsym));
 int fieldsCount = 0;
 int methodsCount = 0;

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

comparison: src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java

src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java