/** Read inner class info. For each inner/outer pair allocate a * member class. */ void readInnerClasses(ClassSymbol c) { int n = nextChar(); for (int i = 0; i < n; i++) { nextChar(); // skip inner class symbol ClassSymbol outer = readClassSymbol(nextChar()); Name name = readName(nextChar()); if (name == null) name = names.empty; long flags = adjustClassFlags(nextChar()); if (outer != null) { // we have a member class if (name == names.empty) name = names.one; ClassSymbol member = enterClass(name, outer); if ((flags & STATIC) == 0) { ((ClassType)member.type).setEnclosingType(outer.type); if (member.erasure_field != null) ((ClassType)member.erasure_field).setEnclosingType(types.erasure(outer.type)); } if (c == outer) { member.flags_field = flags; enterMember(c, member); } } } }
public Symbol.ClassSymbol loadClass( final Name name ) { try { return reader.loadClass( name ); } catch( ClassReader.BadClassFile err ) { throw err; } catch( Symbol.CompletionFailure ex ) { throw ex; } }
/** Get the ClassReader instance for this invocation. */ public static ClassReader instance(Context context) { ClassReader instance = context.get(classReaderKey); if (instance == null) instance = new ClassReader(context, true); return instance; }
Type readEnumType(int i) { // support preliminary jsr175-format class files int index = poolIdx[i]; int length = getChar(index + 1); if (buf[index + length + 2] != ';') return enterClass(readName(i)).type; return readType(i); }
/** Read a field. */ VarSymbol readField() { long flags = adjustFieldFlags(nextChar()); Name name = readName(nextChar()); Type type = readType(nextChar()); VarSymbol v = new VarSymbol(flags, name, type, currentOwner); readMemberAttrs(v); return v; }
/** If name is an array type or class signature, return the * corresponding type; otherwise return a ClassSymbol with given name. */ Object readClassOrType(int i) { int index = poolIdx[i]; int len = getChar(index + 1); int start = index + 3; assert buf[start] == '[' || buf[start + len - 1] != ';'; // by the above assertion, the following test can be // simplified to (buf[start] == '[') return (buf[start] == '[' || buf[start + len - 1] == ';') ? (Object)sigToType(buf, start, len) : (Object)enterClass(names.fromUtf(internalize(buf, start, len))); }
if (ct.getEnclosingType().tag == CLASS) enterTypevars(ct.getEnclosingType()); long flags = adjustClassFlags(nextChar()); if (c.owner.kind == PCK) c.flags_field = flags; ClassSymbol self = readClassSymbol(nextChar()); if (c != self) throw badClassFile("class.file.wrong.class", self.flatname); nextChar(); char interfaceCount = nextChar(); bp += interfaceCount * 2; char fieldCount = nextChar(); for (int i = 0; i < fieldCount; i++) skipMember(); char methodCount = nextChar(); for (int i = 0; i < methodCount; i++) skipMember(); readClassAttrs(c); for (int i = 1; i < poolObj.length; i++) readPool(i); c.pool = new Pool(poolObj.length, poolObj); int n = nextChar(); if (ct.supertype_field == null) ct.supertype_field = (n == 0) ? Type.noType : readClassSymbol(n).erasure(types); n = nextChar(); List<Type> is = List.nil();
Object v = readPool(nextChar()); } else if (attrName == names.Code) { if (readAllOfClassFile || saveParameterNames) ((MethodSymbol)sym).code = readCode(sym); else bp = bp + attrLen; } else if (attrName == names.Exceptions) { int nexceptions = nextChar(); List<Type> thrown = List.nil(); for (int j = 0; j < nexceptions; j++) thrown = thrown.prepend(readClassSymbol(nextChar()).type); if (sym.type.getThrownTypes().isEmpty()) sym.type.asMethodType().thrown = thrown.reverse(); } else if (allowGenerics && attrName == names.Signature) { List<Type> thrown = sym.type.getThrownTypes(); sym.type = readType(nextChar()); attachAnnotations(sym); } else if (attrName == names.RuntimeInvisibleAnnotations) { attachAnnotations(sym); } else if (attrName == names.RuntimeVisibleParameterAnnotations) { attachParameterAnnotations(sym); } else if (attrName == names.RuntimeInvisibleParameterAnnotations) { attachParameterAnnotations(sym); } else if (attrName == names.LocalVariableTable) { int newbp = bp + attrLen;
long flags = adjustMethodFlags(nextChar()); Name name = readName(nextChar()); Type type = readType(nextChar()); if (currentOwner.isInterface() && (flags & ABSTRACT) == 0 && !name.equals(names.clinit)) { throw badClassFile((flags & STATIC) == 0 ? "invalid.default.interface" : "invalid.static.interface", Integer.toString(majorVersion), Integer.toString(minorVersion)); type = new MethodType(adjustMethodParams(flags, type.getParameterTypes()), type.getReturnType(), type.getThrownTypes(), initParameterNames(m); Symbol prevOwner = currentOwner; currentOwner = m; try { readMemberAttrs(m); } finally { currentOwner = prevOwner; setParameterNames(m, type); return m;
protected JOpsAttr( Context context ) { super( context ); names = Names.instance( context ); reader = ClassReader.instance( context ); types = Types.instance( context ); rs = Resolve.instance( context ); }
/** Read a method. */ MethodSymbol readMethod() { long flags = adjustMethodFlags(nextChar()); Name name = readName(nextChar()); Type type = readType(nextChar()); if (name == names.init && currentOwner.hasOuterInstance()) { // Sometimes anonymous classes don't have an outer // instance, however, there is no reliable way to tell so // we never strip this$n if (currentOwner.name.len != 0) type = new MethodType(type.getParameterTypes().tail, type.getReturnType(), type.getThrownTypes(), syms.methodClass); } MethodSymbol m = new MethodSymbol(flags, name, type, currentOwner); if (saveParameterNames) initParameterNames(m); Symbol prevOwner = currentOwner; currentOwner = m; try { readMemberAttrs(m); } finally { currentOwner = prevOwner; } if (saveParameterNames) setParameterNames(m, type); return m; }
/** Enter a set of generated class files. */ private List<ClassSymbol> enterClassFiles(Map<String, JavaFileObject> classFiles) { ClassReader reader = ClassReader.instance(context); Names names = Names.instance(context); List<ClassSymbol> list = List.nil(); for (Map.Entry<String,JavaFileObject> entry : classFiles.entrySet()) { Name name = names.fromString(entry.getKey()); JavaFileObject file = entry.getValue(); if (file.getKind() != JavaFileObject.Kind.CLASS) throw new AssertionError(file); ClassSymbol cs; if (isPkgInfo(file, JavaFileObject.Kind.CLASS)) { Name packageName = Convert.packagePart(name); PackageSymbol p = reader.enterPackage(packageName); if (p.package_info == null) p.package_info = reader.enterClass(Convert.shortName(name), p); cs = p.package_info; if (cs.classfile == null) cs.classfile = file; } else cs = reader.enterClass(name, file); list = list.prepend(cs); } return list.reverse(); }
/** Read a method. */ MethodSymbol readMethod() { long flags = adjustMethodFlags(nextChar()); Name name = readName(nextChar()); Type type = readType(nextChar()); if (name == names.init && currentOwner.hasOuterInstance()) { // Sometimes anonymous classes don't have an outer // instance, however, there is no reliable way to tell so // we never strip this$n if (currentOwner.name.len != 0) type = new MethodType(type.getParameterTypes().tail, type.getReturnType(), type.getThrownTypes(), syms.methodClass); } MethodSymbol m = new MethodSymbol(flags, name, type, currentOwner); Symbol prevOwner = currentOwner; currentOwner = m; try { readMemberAttrs(m); } finally { currentOwner = prevOwner; } return m; }
/** * Return the class that boxes the given primitive. */ public ClassSymbol boxedClass(Type t) { return reader.enterClass(syms.boxedName[t.tag]); }
/** If name is an array type or class signature, return the * corresponding type; otherwise return a ClassSymbol with given name. */ Object readClassOrType(int i) { int index = poolIdx[i]; int len = getChar(index + 1); int start = index + 3; Assert.check(buf[start] == '[' || buf[start + len - 1] != ';'); // by the above assertion, the following test can be // simplified to (buf[start] == '[') return (buf[start] == '[' || buf[start + len - 1] == ';') ? (Object)sigToType(buf, start, len) : (Object)enterClass(names.fromUtf(internalize(buf, start, len))); }
private ListBuffer<ClassSymbol> enterNewClassFiles(Context currentContext) { ClassReader reader = ClassReader.instance(currentContext); Name.Table names = Name.Table.instance(currentContext); ListBuffer<ClassSymbol> list = new ListBuffer<ClassSymbol>(); for (Map.Entry<String,JavaFileObject> entry : filer.getGeneratedClasses().entrySet()) { Name name = names.fromString(entry.getKey()); JavaFileObject file = entry.getValue(); if (file.getKind() != JavaFileObject.Kind.CLASS) throw new AssertionError(file); ClassSymbol cs = reader.enterClass(name, file); list.append(cs); } return list; }
/** Attach parameter annotations. */ void attachParameterAnnotations(final Symbol method) { final MethodSymbol meth = (MethodSymbol)method; int numParameters = buf[bp++] & 0xFF; List<VarSymbol> parameters = meth.params(); int pnum = 0; while (parameters.tail != null) { attachAnnotations(parameters.head); parameters = parameters.tail; pnum++; } if (pnum != numParameters) { throw badClassFile("bad.runtime.invisible.param.annotations", meth); } }
protected void read(Symbol sym, int attrLen) { attachParameterAnnotations(sym); } },
protected void read(Symbol sym, int attrLen) { attachAnnotations(sym); } },
protected void read(Symbol sym, int attrLen) { attachAnnotationDefault(sym); } },