duke@1: /*
xdono@54: * Copyright 1999-2008 Sun Microsystems, Inc. All Rights Reserved.
duke@1: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@1: *
duke@1: * This code is free software; you can redistribute it and/or modify it
duke@1: * under the terms of the GNU General Public License version 2 only, as
duke@1: * published by the Free Software Foundation. Sun designates this
duke@1: * particular file as subject to the "Classpath" exception as provided
duke@1: * by Sun in the LICENSE file that accompanied this code.
duke@1: *
duke@1: * This code is distributed in the hope that it will be useful, but WITHOUT
duke@1: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@1: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@1: * version 2 for more details (a copy is included in the LICENSE file that
duke@1: * accompanied this code).
duke@1: *
duke@1: * You should have received a copy of the GNU General Public License version
duke@1: * 2 along with this work; if not, write to the Free Software Foundation,
duke@1: * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@1: *
duke@1: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
duke@1: * CA 95054 USA or visit www.sun.com if you need additional information or
duke@1: * have any questions.
duke@1: */
duke@1:
duke@1: package com.sun.tools.javac.jvm;
duke@1:
duke@1: import java.io.*;
duke@1: import java.net.URI;
duke@1: import java.nio.CharBuffer;
duke@1: import java.util.EnumSet;
duke@1: import java.util.HashMap;
duke@1: import java.util.Map;
duke@1: import java.util.Set;
duke@1: import javax.lang.model.SourceVersion;
duke@1: import javax.tools.JavaFileObject;
duke@1: import javax.tools.JavaFileManager;
duke@1: import javax.tools.StandardJavaFileManager;
duke@1:
duke@1: import com.sun.tools.javac.comp.Annotate;
duke@1: import com.sun.tools.javac.code.*;
duke@1: import com.sun.tools.javac.code.Type.*;
duke@1: import com.sun.tools.javac.code.Symbol.*;
duke@1: import com.sun.tools.javac.code.Symtab;
jjg@50: import com.sun.tools.javac.file.BaseFileObject;
duke@1: import com.sun.tools.javac.util.*;
duke@1: import com.sun.tools.javac.util.List;
duke@1:
duke@1: import static com.sun.tools.javac.code.Flags.*;
duke@1: import static com.sun.tools.javac.code.Kinds.*;
duke@1: import static com.sun.tools.javac.code.TypeTags.*;
duke@1: import com.sun.tools.javac.jvm.ClassFile.NameAndType;
duke@1: import javax.tools.JavaFileManager.Location;
duke@1: import static javax.tools.StandardLocation.*;
duke@1:
duke@1: /** This class provides operations to read a classfile into an internal
duke@1: * representation. The internal representation is anchored in a
duke@1: * ClassSymbol which contains in its scope symbol representations
duke@1: * for all other definitions in the classfile. Top-level Classes themselves
duke@1: * appear as members of the scopes of PackageSymbols.
duke@1: *
duke@1: *
This is NOT part of any API supported by Sun Microsystems. If
duke@1: * you write code that depends on this, you do so at your own risk.
duke@1: * This code and its internal interfaces are subject to change or
duke@1: * deletion without notice.
duke@1: */
duke@1: public class ClassReader extends ClassFile implements Completer {
duke@1: /** The context key for the class reader. */
duke@1: protected static final Context.Key classReaderKey =
duke@1: new Context.Key();
duke@1:
duke@1: Annotate annotate;
duke@1:
duke@1: /** Switch: verbose output.
duke@1: */
duke@1: boolean verbose;
duke@1:
duke@1: /** Switch: check class file for correct minor version, unrecognized
duke@1: * attributes.
duke@1: */
duke@1: boolean checkClassFile;
duke@1:
duke@1: /** Switch: read constant pool and code sections. This switch is initially
duke@1: * set to false but can be turned on from outside.
duke@1: */
duke@1: public boolean readAllOfClassFile = false;
duke@1:
duke@1: /** Switch: read GJ signature information.
duke@1: */
duke@1: boolean allowGenerics;
duke@1:
duke@1: /** Switch: read varargs attribute.
duke@1: */
duke@1: boolean allowVarargs;
duke@1:
duke@1: /** Switch: allow annotations.
duke@1: */
duke@1: boolean allowAnnotations;
duke@1:
duke@1: /** Switch: preserve parameter names from the variable table.
duke@1: */
duke@1: public boolean saveParameterNames;
duke@1:
duke@1: /**
duke@1: * Switch: cache completion failures unless -XDdev is used
duke@1: */
duke@1: private boolean cacheCompletionFailure;
duke@1:
duke@1: /**
duke@1: * Switch: prefer source files instead of newer when both source
duke@1: * and class are available
duke@1: **/
duke@1: public boolean preferSource;
duke@1:
duke@1: /** The log to use for verbose output
duke@1: */
duke@1: final Log log;
duke@1:
duke@1: /** The symbol table. */
duke@1: Symtab syms;
duke@1:
duke@1: Types types;
duke@1:
duke@1: /** The name table. */
jjg@113: final Names names;
duke@1:
duke@1: /** Force a completion failure on this name
duke@1: */
duke@1: final Name completionFailureName;
duke@1:
duke@1: /** Access to files
duke@1: */
duke@1: private final JavaFileManager fileManager;
duke@1:
jjg@12: /** Factory for diagnostics
jjg@12: */
jjg@12: JCDiagnostic.Factory diagFactory;
jjg@12:
duke@1: /** Can be reassigned from outside:
duke@1: * the completer to be used for ".java" files. If this remains unassigned
duke@1: * ".java" files will not be loaded.
duke@1: */
duke@1: public SourceCompleter sourceCompleter = null;
duke@1:
duke@1: /** A hashtable containing the encountered top-level and member classes,
duke@1: * indexed by flat names. The table does not contain local classes.
duke@1: */
duke@1: private Map classes;
duke@1:
duke@1: /** A hashtable containing the encountered packages.
duke@1: */
duke@1: private Map packages;
duke@1:
duke@1: /** The current scope where type variables are entered.
duke@1: */
duke@1: protected Scope typevars;
duke@1:
duke@1: /** The path name of the class file currently being read.
duke@1: */
duke@1: protected JavaFileObject currentClassFile = null;
duke@1:
duke@1: /** The class or method currently being read.
duke@1: */
duke@1: protected Symbol currentOwner = null;
duke@1:
duke@1: /** The buffer containing the currently read class file.
duke@1: */
duke@1: byte[] buf = new byte[0x0fff0];
duke@1:
duke@1: /** The current input pointer.
duke@1: */
duke@1: int bp;
duke@1:
duke@1: /** The objects of the constant pool.
duke@1: */
duke@1: Object[] poolObj;
duke@1:
duke@1: /** For every constant pool entry, an index into buf where the
duke@1: * defining section of the entry is found.
duke@1: */
duke@1: int[] poolIdx;
duke@1:
duke@1: /** Get the ClassReader instance for this invocation. */
duke@1: public static ClassReader instance(Context context) {
duke@1: ClassReader instance = context.get(classReaderKey);
duke@1: if (instance == null)
duke@1: instance = new ClassReader(context, true);
duke@1: return instance;
duke@1: }
duke@1:
duke@1: /** Initialize classes and packages, treating this as the definitive classreader. */
duke@1: public void init(Symtab syms) {
duke@1: init(syms, true);
duke@1: }
duke@1:
duke@1: /** Initialize classes and packages, optionally treating this as
duke@1: * the definitive classreader.
duke@1: */
duke@1: private void init(Symtab syms, boolean definitive) {
duke@1: if (classes != null) return;
duke@1:
duke@1: if (definitive) {
duke@1: assert packages == null || packages == syms.packages;
duke@1: packages = syms.packages;
duke@1: assert classes == null || classes == syms.classes;
duke@1: classes = syms.classes;
duke@1: } else {
duke@1: packages = new HashMap();
duke@1: classes = new HashMap();
duke@1: }
duke@1:
duke@1: packages.put(names.empty, syms.rootPackage);
duke@1: syms.rootPackage.completer = this;
duke@1: syms.unnamedPackage.completer = this;
duke@1: }
duke@1:
duke@1: /** Construct a new class reader, optionally treated as the
duke@1: * definitive classreader for this invocation.
duke@1: */
duke@1: protected ClassReader(Context context, boolean definitive) {
duke@1: if (definitive) context.put(classReaderKey, this);
duke@1:
jjg@113: names = Names.instance(context);
duke@1: syms = Symtab.instance(context);
duke@1: types = Types.instance(context);
duke@1: fileManager = context.get(JavaFileManager.class);
duke@1: if (fileManager == null)
duke@1: throw new AssertionError("FileManager initialization error");
jjg@12: diagFactory = JCDiagnostic.Factory.instance(context);
duke@1:
duke@1: init(syms, definitive);
duke@1: log = Log.instance(context);
duke@1:
duke@1: Options options = Options.instance(context);
duke@1: annotate = Annotate.instance(context);
duke@1: verbose = options.get("-verbose") != null;
duke@1: checkClassFile = options.get("-checkclassfile") != null;
duke@1: Source source = Source.instance(context);
duke@1: allowGenerics = source.allowGenerics();
duke@1: allowVarargs = source.allowVarargs();
duke@1: allowAnnotations = source.allowAnnotations();
duke@1: saveParameterNames = options.get("save-parameter-names") != null;
duke@1: cacheCompletionFailure = options.get("dev") == null;
duke@1: preferSource = "source".equals(options.get("-Xprefer"));
duke@1:
duke@1: completionFailureName =
duke@1: (options.get("failcomplete") != null)
duke@1: ? names.fromString(options.get("failcomplete"))
duke@1: : null;
duke@1:
duke@1: typevars = new Scope(syms.noSymbol);
duke@1: }
duke@1:
duke@1: /** Add member to class unless it is synthetic.
duke@1: */
duke@1: private void enterMember(ClassSymbol c, Symbol sym) {
duke@1: if ((sym.flags_field & (SYNTHETIC|BRIDGE)) != SYNTHETIC)
duke@1: c.members_field.enter(sym);
duke@1: }
duke@1:
duke@1: /************************************************************************
duke@1: * Error Diagnoses
duke@1: ***********************************************************************/
duke@1:
jjg@12:
jjg@12: public class BadClassFile extends CompletionFailure {
duke@1: private static final long serialVersionUID = 0;
duke@1:
jjg@12: public BadClassFile(TypeSymbol sym, JavaFileObject file, JCDiagnostic diag) {
jjg@12: super(sym, createBadClassFileDiagnostic(file, diag));
duke@1: }
duke@1: }
jjg@12: // where
jjg@12: private JCDiagnostic createBadClassFileDiagnostic(JavaFileObject file, JCDiagnostic diag) {
jjg@12: String key = (file.getKind() == JavaFileObject.Kind.SOURCE
jjg@12: ? "bad.source.file.header" : "bad.class.file.header");
jjg@12: return diagFactory.fragment(key, file, diag);
jjg@12: }
duke@1:
duke@1: public BadClassFile badClassFile(String key, Object... args) {
duke@1: return new BadClassFile (
duke@1: currentOwner.enclClass(),
duke@1: currentClassFile,
jjg@12: diagFactory.fragment(key, args));
duke@1: }
duke@1:
duke@1: /************************************************************************
duke@1: * Buffer Access
duke@1: ***********************************************************************/
duke@1:
duke@1: /** Read a character.
duke@1: */
duke@1: char nextChar() {
duke@1: return (char)(((buf[bp++] & 0xFF) << 8) + (buf[bp++] & 0xFF));
duke@1: }
duke@1:
duke@1: /** Read an integer.
duke@1: */
duke@1: int nextInt() {
duke@1: return
duke@1: ((buf[bp++] & 0xFF) << 24) +
duke@1: ((buf[bp++] & 0xFF) << 16) +
duke@1: ((buf[bp++] & 0xFF) << 8) +
duke@1: (buf[bp++] & 0xFF);
duke@1: }
duke@1:
duke@1: /** Extract a character at position bp from buf.
duke@1: */
duke@1: char getChar(int bp) {
duke@1: return
duke@1: (char)(((buf[bp] & 0xFF) << 8) + (buf[bp+1] & 0xFF));
duke@1: }
duke@1:
duke@1: /** Extract an integer at position bp from buf.
duke@1: */
duke@1: int getInt(int bp) {
duke@1: return
duke@1: ((buf[bp] & 0xFF) << 24) +
duke@1: ((buf[bp+1] & 0xFF) << 16) +
duke@1: ((buf[bp+2] & 0xFF) << 8) +
duke@1: (buf[bp+3] & 0xFF);
duke@1: }
duke@1:
duke@1:
duke@1: /** Extract a long integer at position bp from buf.
duke@1: */
duke@1: long getLong(int bp) {
duke@1: DataInputStream bufin =
duke@1: new DataInputStream(new ByteArrayInputStream(buf, bp, 8));
duke@1: try {
duke@1: return bufin.readLong();
duke@1: } catch (IOException e) {
duke@1: throw new AssertionError(e);
duke@1: }
duke@1: }
duke@1:
duke@1: /** Extract a float at position bp from buf.
duke@1: */
duke@1: float getFloat(int bp) {
duke@1: DataInputStream bufin =
duke@1: new DataInputStream(new ByteArrayInputStream(buf, bp, 4));
duke@1: try {
duke@1: return bufin.readFloat();
duke@1: } catch (IOException e) {
duke@1: throw new AssertionError(e);
duke@1: }
duke@1: }
duke@1:
duke@1: /** Extract a double at position bp from buf.
duke@1: */
duke@1: double getDouble(int bp) {
duke@1: DataInputStream bufin =
duke@1: new DataInputStream(new ByteArrayInputStream(buf, bp, 8));
duke@1: try {
duke@1: return bufin.readDouble();
duke@1: } catch (IOException e) {
duke@1: throw new AssertionError(e);
duke@1: }
duke@1: }
duke@1:
duke@1: /************************************************************************
duke@1: * Constant Pool Access
duke@1: ***********************************************************************/
duke@1:
duke@1: /** Index all constant pool entries, writing their start addresses into
duke@1: * poolIdx.
duke@1: */
duke@1: void indexPool() {
duke@1: poolIdx = new int[nextChar()];
duke@1: poolObj = new Object[poolIdx.length];
duke@1: int i = 1;
duke@1: while (i < poolIdx.length) {
duke@1: poolIdx[i++] = bp;
duke@1: byte tag = buf[bp++];
duke@1: switch (tag) {
duke@1: case CONSTANT_Utf8: case CONSTANT_Unicode: {
duke@1: int len = nextChar();
duke@1: bp = bp + len;
duke@1: break;
duke@1: }
duke@1: case CONSTANT_Class:
duke@1: case CONSTANT_String:
duke@1: bp = bp + 2;
duke@1: break;
duke@1: case CONSTANT_Fieldref:
duke@1: case CONSTANT_Methodref:
duke@1: case CONSTANT_InterfaceMethodref:
duke@1: case CONSTANT_NameandType:
duke@1: case CONSTANT_Integer:
duke@1: case CONSTANT_Float:
duke@1: bp = bp + 4;
duke@1: break;
duke@1: case CONSTANT_Long:
duke@1: case CONSTANT_Double:
duke@1: bp = bp + 8;
duke@1: i++;
duke@1: break;
duke@1: default:
duke@1: throw badClassFile("bad.const.pool.tag.at",
duke@1: Byte.toString(tag),
duke@1: Integer.toString(bp -1));
duke@1: }
duke@1: }
duke@1: }
duke@1:
duke@1: /** Read constant pool entry at start address i, use pool as a cache.
duke@1: */
duke@1: Object readPool(int i) {
duke@1: Object result = poolObj[i];
duke@1: if (result != null) return result;
duke@1:
duke@1: int index = poolIdx[i];
duke@1: if (index == 0) return null;
duke@1:
duke@1: byte tag = buf[index];
duke@1: switch (tag) {
duke@1: case CONSTANT_Utf8:
duke@1: poolObj[i] = names.fromUtf(buf, index + 3, getChar(index + 1));
duke@1: break;
duke@1: case CONSTANT_Unicode:
duke@1: throw badClassFile("unicode.str.not.supported");
duke@1: case CONSTANT_Class:
duke@1: poolObj[i] = readClassOrType(getChar(index + 1));
duke@1: break;
duke@1: case CONSTANT_String:
duke@1: // FIXME: (footprint) do not use toString here
duke@1: poolObj[i] = readName(getChar(index + 1)).toString();
duke@1: break;
duke@1: case CONSTANT_Fieldref: {
duke@1: ClassSymbol owner = readClassSymbol(getChar(index + 1));
duke@1: NameAndType nt = (NameAndType)readPool(getChar(index + 3));
duke@1: poolObj[i] = new VarSymbol(0, nt.name, nt.type, owner);
duke@1: break;
duke@1: }
duke@1: case CONSTANT_Methodref:
duke@1: case CONSTANT_InterfaceMethodref: {
duke@1: ClassSymbol owner = readClassSymbol(getChar(index + 1));
duke@1: NameAndType nt = (NameAndType)readPool(getChar(index + 3));
duke@1: poolObj[i] = new MethodSymbol(0, nt.name, nt.type, owner);
duke@1: break;
duke@1: }
duke@1: case CONSTANT_NameandType:
duke@1: poolObj[i] = new NameAndType(
duke@1: readName(getChar(index + 1)),
duke@1: readType(getChar(index + 3)));
duke@1: break;
duke@1: case CONSTANT_Integer:
duke@1: poolObj[i] = getInt(index + 1);
duke@1: break;
duke@1: case CONSTANT_Float:
duke@1: poolObj[i] = new Float(getFloat(index + 1));
duke@1: break;
duke@1: case CONSTANT_Long:
duke@1: poolObj[i] = new Long(getLong(index + 1));
duke@1: break;
duke@1: case CONSTANT_Double:
duke@1: poolObj[i] = new Double(getDouble(index + 1));
duke@1: break;
duke@1: default:
duke@1: throw badClassFile("bad.const.pool.tag", Byte.toString(tag));
duke@1: }
duke@1: return poolObj[i];
duke@1: }
duke@1:
duke@1: /** Read signature and convert to type.
duke@1: */
duke@1: Type readType(int i) {
duke@1: int index = poolIdx[i];
duke@1: return sigToType(buf, index + 3, getChar(index + 1));
duke@1: }
duke@1:
duke@1: /** If name is an array type or class signature, return the
duke@1: * corresponding type; otherwise return a ClassSymbol with given name.
duke@1: */
duke@1: Object readClassOrType(int i) {
duke@1: int index = poolIdx[i];
duke@1: int len = getChar(index + 1);
duke@1: int start = index + 3;
duke@1: assert buf[start] == '[' || buf[start + len - 1] != ';';
duke@1: // by the above assertion, the following test can be
duke@1: // simplified to (buf[start] == '[')
duke@1: return (buf[start] == '[' || buf[start + len - 1] == ';')
duke@1: ? (Object)sigToType(buf, start, len)
duke@1: : (Object)enterClass(names.fromUtf(internalize(buf, start,
duke@1: len)));
duke@1: }
duke@1:
duke@1: /** Read signature and convert to type parameters.
duke@1: */
duke@1: List readTypeParams(int i) {
duke@1: int index = poolIdx[i];
duke@1: return sigToTypeParams(buf, index + 3, getChar(index + 1));
duke@1: }
duke@1:
duke@1: /** Read class entry.
duke@1: */
duke@1: ClassSymbol readClassSymbol(int i) {
duke@1: return (ClassSymbol) (readPool(i));
duke@1: }
duke@1:
duke@1: /** Read name.
duke@1: */
duke@1: Name readName(int i) {
duke@1: return (Name) (readPool(i));
duke@1: }
duke@1:
duke@1: /************************************************************************
duke@1: * Reading Types
duke@1: ***********************************************************************/
duke@1:
duke@1: /** The unread portion of the currently read type is
duke@1: * signature[sigp..siglimit-1].
duke@1: */
duke@1: byte[] signature;
duke@1: int sigp;
duke@1: int siglimit;
duke@1: boolean sigEnterPhase = false;
duke@1:
duke@1: /** Convert signature to type, where signature is a byte array segment.
duke@1: */
duke@1: Type sigToType(byte[] sig, int offset, int len) {
duke@1: signature = sig;
duke@1: sigp = offset;
duke@1: siglimit = offset + len;
duke@1: return sigToType();
duke@1: }
duke@1:
duke@1: /** Convert signature to type, where signature is implicit.
duke@1: */
duke@1: Type sigToType() {
duke@1: switch ((char) signature[sigp]) {
duke@1: case 'T':
duke@1: sigp++;
duke@1: int start = sigp;
duke@1: while (signature[sigp] != ';') sigp++;
duke@1: sigp++;
duke@1: return sigEnterPhase
duke@1: ? Type.noType
duke@1: : findTypeVar(names.fromUtf(signature, start, sigp - 1 - start));
duke@1: case '+': {
duke@1: sigp++;
duke@1: Type t = sigToType();
duke@1: return new WildcardType(t, BoundKind.EXTENDS,
duke@1: syms.boundClass);
duke@1: }
duke@1: case '*':
duke@1: sigp++;
duke@1: return new WildcardType(syms.objectType, BoundKind.UNBOUND,
duke@1: syms.boundClass);
duke@1: case '-': {
duke@1: sigp++;
duke@1: Type t = sigToType();
duke@1: return new WildcardType(t, BoundKind.SUPER,
duke@1: syms.boundClass);
duke@1: }
duke@1: case 'B':
duke@1: sigp++;
duke@1: return syms.byteType;
duke@1: case 'C':
duke@1: sigp++;
duke@1: return syms.charType;
duke@1: case 'D':
duke@1: sigp++;
duke@1: return syms.doubleType;
duke@1: case 'F':
duke@1: sigp++;
duke@1: return syms.floatType;
duke@1: case 'I':
duke@1: sigp++;
duke@1: return syms.intType;
duke@1: case 'J':
duke@1: sigp++;
duke@1: return syms.longType;
duke@1: case 'L':
duke@1: {
duke@1: // int oldsigp = sigp;
duke@1: Type t = classSigToType();
duke@1: if (sigp < siglimit && signature[sigp] == '.')
duke@1: throw badClassFile("deprecated inner class signature syntax " +
duke@1: "(please recompile from source)");
duke@1: /*
duke@1: System.err.println(" decoded " +
duke@1: new String(signature, oldsigp, sigp-oldsigp) +
duke@1: " => " + t + " outer " + t.outer());
duke@1: */
duke@1: return t;
duke@1: }
duke@1: case 'S':
duke@1: sigp++;
duke@1: return syms.shortType;
duke@1: case 'V':
duke@1: sigp++;
duke@1: return syms.voidType;
duke@1: case 'Z':
duke@1: sigp++;
duke@1: return syms.booleanType;
duke@1: case '[':
duke@1: sigp++;
duke@1: return new ArrayType(sigToType(), syms.arrayClass);
duke@1: case '(':
duke@1: sigp++;
duke@1: List argtypes = sigToTypes(')');
duke@1: Type restype = sigToType();
duke@1: List thrown = List.nil();
duke@1: while (signature[sigp] == '^') {
duke@1: sigp++;
duke@1: thrown = thrown.prepend(sigToType());
duke@1: }
duke@1: return new MethodType(argtypes,
duke@1: restype,
duke@1: thrown.reverse(),
duke@1: syms.methodClass);
duke@1: case '<':
duke@1: typevars = typevars.dup(currentOwner);
duke@1: Type poly = new ForAll(sigToTypeParams(), sigToType());
duke@1: typevars = typevars.leave();
duke@1: return poly;
duke@1: default:
duke@1: throw badClassFile("bad.signature",
duke@1: Convert.utf2string(signature, sigp, 10));
duke@1: }
duke@1: }
duke@1:
duke@1: byte[] signatureBuffer = new byte[0];
duke@1: int sbp = 0;
duke@1: /** Convert class signature to type, where signature is implicit.
duke@1: */
duke@1: Type classSigToType() {
duke@1: if (signature[sigp] != 'L')
duke@1: throw badClassFile("bad.class.signature",
duke@1: Convert.utf2string(signature, sigp, 10));
duke@1: sigp++;
duke@1: Type outer = Type.noType;
duke@1: int startSbp = sbp;
duke@1:
duke@1: while (true) {
duke@1: final byte c = signature[sigp++];
duke@1: switch (c) {
duke@1:
duke@1: case ';': { // end
duke@1: ClassSymbol t = enterClass(names.fromUtf(signatureBuffer,
duke@1: startSbp,
duke@1: sbp - startSbp));
duke@1: if (outer == Type.noType)
duke@1: outer = t.erasure(types);
duke@1: else
duke@1: outer = new ClassType(outer, List.nil(), t);
duke@1: sbp = startSbp;
duke@1: return outer;
duke@1: }
duke@1:
duke@1: case '<': // generic arguments
duke@1: ClassSymbol t = enterClass(names.fromUtf(signatureBuffer,
duke@1: startSbp,
duke@1: sbp - startSbp));
duke@1: outer = new ClassType(outer, sigToTypes('>'), t) {
duke@1: boolean completed = false;
duke@1: public Type getEnclosingType() {
duke@1: if (!completed) {
duke@1: completed = true;
duke@1: tsym.complete();
duke@1: Type enclosingType = tsym.type.getEnclosingType();
duke@1: if (enclosingType != Type.noType) {
duke@1: List typeArgs =
duke@1: super.getEnclosingType().allparams();
duke@1: List typeParams =
duke@1: enclosingType.allparams();
duke@1: if (typeParams.length() != typeArgs.length()) {
duke@1: // no "rare" types
duke@1: super.setEnclosingType(types.erasure(enclosingType));
duke@1: } else {
duke@1: super.setEnclosingType(types.subst(enclosingType,
duke@1: typeParams,
duke@1: typeArgs));
duke@1: }
duke@1: } else {
duke@1: super.setEnclosingType(Type.noType);
duke@1: }
duke@1: }
duke@1: return super.getEnclosingType();
duke@1: }
duke@1: public void setEnclosingType(Type outer) {
duke@1: throw new UnsupportedOperationException();
duke@1: }
duke@1: };
duke@1: switch (signature[sigp++]) {
duke@1: case ';':
duke@1: if (sigp < signature.length && signature[sigp] == '.') {
duke@1: // support old-style GJC signatures
duke@1: // The signature produced was
duke@1: // Lfoo/Outer;.Lfoo/Outer$Inner;
duke@1: // rather than say
duke@1: // Lfoo/Outer.Inner;
duke@1: // so we skip past ".Lfoo/Outer$"
duke@1: sigp += (sbp - startSbp) + // "foo/Outer"
duke@1: 3; // ".L" and "$"
duke@1: signatureBuffer[sbp++] = (byte)'$';
duke@1: break;
duke@1: } else {
duke@1: sbp = startSbp;
duke@1: return outer;
duke@1: }
duke@1: case '.':
duke@1: signatureBuffer[sbp++] = (byte)'$';
duke@1: break;
duke@1: default:
duke@1: throw new AssertionError(signature[sigp-1]);
duke@1: }
duke@1: continue;
duke@1:
duke@1: case '.':
duke@1: signatureBuffer[sbp++] = (byte)'$';
duke@1: continue;
duke@1: case '/':
duke@1: signatureBuffer[sbp++] = (byte)'.';
duke@1: continue;
duke@1: default:
duke@1: signatureBuffer[sbp++] = c;
duke@1: continue;
duke@1: }
duke@1: }
duke@1: }
duke@1:
duke@1: /** Convert (implicit) signature to list of types
duke@1: * until `terminator' is encountered.
duke@1: */
duke@1: List sigToTypes(char terminator) {
duke@1: List head = List.of(null);
duke@1: List tail = head;
duke@1: while (signature[sigp] != terminator)
duke@1: tail = tail.setTail(List.of(sigToType()));
duke@1: sigp++;
duke@1: return head.tail;
duke@1: }
duke@1:
duke@1: /** Convert signature to type parameters, where signature is a byte
duke@1: * array segment.
duke@1: */
duke@1: List sigToTypeParams(byte[] sig, int offset, int len) {
duke@1: signature = sig;
duke@1: sigp = offset;
duke@1: siglimit = offset + len;
duke@1: return sigToTypeParams();
duke@1: }
duke@1:
duke@1: /** Convert signature to type parameters, where signature is implicit.
duke@1: */
duke@1: List sigToTypeParams() {
duke@1: List tvars = List.nil();
duke@1: if (signature[sigp] == '<') {
duke@1: sigp++;
duke@1: int start = sigp;
duke@1: sigEnterPhase = true;
duke@1: while (signature[sigp] != '>')
duke@1: tvars = tvars.prepend(sigToTypeParam());
duke@1: sigEnterPhase = false;
duke@1: sigp = start;
duke@1: while (signature[sigp] != '>')
duke@1: sigToTypeParam();
duke@1: sigp++;
duke@1: }
duke@1: return tvars.reverse();
duke@1: }
duke@1:
duke@1: /** Convert (implicit) signature to type parameter.
duke@1: */
duke@1: Type sigToTypeParam() {
duke@1: int start = sigp;
duke@1: while (signature[sigp] != ':') sigp++;
duke@1: Name name = names.fromUtf(signature, start, sigp - start);
duke@1: TypeVar tvar;
duke@1: if (sigEnterPhase) {
duke@1: tvar = new TypeVar(name, currentOwner, syms.botType);
duke@1: typevars.enter(tvar.tsym);
duke@1: } else {
duke@1: tvar = (TypeVar)findTypeVar(name);
duke@1: }
duke@1: List bounds = List.nil();
duke@1: Type st = null;
duke@1: if (signature[sigp] == ':' && signature[sigp+1] == ':') {
duke@1: sigp++;
duke@1: st = syms.objectType;
duke@1: }
duke@1: while (signature[sigp] == ':') {
duke@1: sigp++;
duke@1: bounds = bounds.prepend(sigToType());
duke@1: }
duke@1: if (!sigEnterPhase) {
duke@1: types.setBounds(tvar, bounds.reverse(), st);
duke@1: }
duke@1: return tvar;
duke@1: }
duke@1:
duke@1: /** Find type variable with given name in `typevars' scope.
duke@1: */
duke@1: Type findTypeVar(Name name) {
duke@1: Scope.Entry e = typevars.lookup(name);
duke@1: if (e.scope != null) {
duke@1: return e.sym.type;
duke@1: } else {
duke@1: if (readingClassAttr) {
duke@1: // While reading the class attribute, the supertypes
duke@1: // might refer to a type variable from an enclosing element
duke@1: // (method or class).
duke@1: // If the type variable is defined in the enclosing class,
duke@1: // we can actually find it in
duke@1: // currentOwner.owner.type.getTypeArguments()
duke@1: // However, until we have read the enclosing method attribute
duke@1: // we don't know for sure if this owner is correct. It could
duke@1: // be a method and there is no way to tell before reading the
duke@1: // enclosing method attribute.
duke@1: TypeVar t = new TypeVar(name, currentOwner, syms.botType);
duke@1: missingTypeVariables = missingTypeVariables.prepend(t);
duke@1: // System.err.println("Missing type var " + name);
duke@1: return t;
duke@1: }
duke@1: throw badClassFile("undecl.type.var", name);
duke@1: }
duke@1: }
duke@1:
duke@1: /************************************************************************
duke@1: * Reading Attributes
duke@1: ***********************************************************************/
duke@1:
duke@1: /** Report unrecognized attribute.
duke@1: */
duke@1: void unrecognized(Name attrName) {
duke@1: if (checkClassFile)
duke@1: printCCF("ccf.unrecognized.attribute", attrName);
duke@1: }
duke@1:
duke@1: /** Read member attribute.
duke@1: */
duke@1: void readMemberAttr(Symbol sym, Name attrName, int attrLen) {
duke@1: //- System.err.println(" z " + sym + ", " + attrName + ", " + attrLen);
duke@1: if (attrName == names.ConstantValue) {
duke@1: Object v = readPool(nextChar());
duke@1: // Ignore ConstantValue attribute if field not final.
duke@1: if ((sym.flags() & FINAL) != 0)
duke@1: ((VarSymbol)sym).setData(v);
duke@1: } else if (attrName == names.Code) {
duke@1: if (readAllOfClassFile || saveParameterNames)
duke@1: ((MethodSymbol)sym).code = readCode(sym);
duke@1: else
duke@1: bp = bp + attrLen;
duke@1: } else if (attrName == names.Exceptions) {
duke@1: int nexceptions = nextChar();
duke@1: List thrown = List.nil();
duke@1: for (int j = 0; j < nexceptions; j++)
duke@1: thrown = thrown.prepend(readClassSymbol(nextChar()).type);
duke@1: if (sym.type.getThrownTypes().isEmpty())
duke@1: sym.type.asMethodType().thrown = thrown.reverse();
duke@1: } else if (attrName == names.Synthetic) {
duke@1: // bridge methods are visible when generics not enabled
duke@1: if (allowGenerics || (sym.flags_field & BRIDGE) == 0)
duke@1: sym.flags_field |= SYNTHETIC;
duke@1: } else if (attrName == names.Bridge) {
duke@1: sym.flags_field |= BRIDGE;
duke@1: if (!allowGenerics)
duke@1: sym.flags_field &= ~SYNTHETIC;
duke@1: } else if (attrName == names.Deprecated) {
duke@1: sym.flags_field |= DEPRECATED;
duke@1: } else if (attrName == names.Varargs) {
duke@1: if (allowVarargs) sym.flags_field |= VARARGS;
duke@1: } else if (attrName == names.Annotation) {
duke@1: if (allowAnnotations) sym.flags_field |= ANNOTATION;
duke@1: } else if (attrName == names.Enum) {
duke@1: sym.flags_field |= ENUM;
duke@1: } else if (allowGenerics && attrName == names.Signature) {
duke@1: List thrown = sym.type.getThrownTypes();
duke@1: sym.type = readType(nextChar());
duke@1: //- System.err.println(" # " + sym.type);
duke@1: if (sym.kind == MTH && sym.type.getThrownTypes().isEmpty())
duke@1: sym.type.asMethodType().thrown = thrown;
duke@1: } else if (attrName == names.RuntimeVisibleAnnotations) {
duke@1: attachAnnotations(sym);
duke@1: } else if (attrName == names.RuntimeInvisibleAnnotations) {
duke@1: attachAnnotations(sym);
duke@1: } else if (attrName == names.RuntimeVisibleParameterAnnotations) {
duke@1: attachParameterAnnotations(sym);
duke@1: } else if (attrName == names.RuntimeInvisibleParameterAnnotations) {
duke@1: attachParameterAnnotations(sym);
duke@1: } else if (attrName == names.LocalVariableTable) {
duke@1: int newbp = bp + attrLen;
duke@1: if (saveParameterNames) {
duke@1: // pick up parameter names from the variable table
duke@1: List parameterNames = List.nil();
duke@1: int firstParam = ((sym.flags() & STATIC) == 0) ? 1 : 0;
duke@1: int endParam = firstParam + Code.width(sym.type.getParameterTypes());
duke@1: int numEntries = nextChar();
duke@1: for (int i=0; i typeVars = new ListBuffer();
duke@1: for (Type typevar : missingTypeVariables) {
duke@1: typeVars.append(findTypeVar(typevar.tsym.name));
duke@1: }
duke@1: foundTypeVariables = typeVars.toList();
duke@1: } else {
duke@1: foundTypeVariables = List.nil();
duke@1: }
duke@1: }
duke@1:
duke@1: // See java.lang.Class
duke@1: private Name simpleBinaryName(Name self, Name enclosing) {
duke@1: String simpleBinaryName = self.toString().substring(enclosing.toString().length());
duke@1: if (simpleBinaryName.length() < 1 || simpleBinaryName.charAt(0) != '$')
duke@1: throw badClassFile("bad.enclosing.method", self);
duke@1: int index = 1;
duke@1: while (index < simpleBinaryName.length() &&
duke@1: isAsciiDigit(simpleBinaryName.charAt(index)))
duke@1: index++;
duke@1: return names.fromString(simpleBinaryName.substring(index));
duke@1: }
duke@1:
duke@1: private MethodSymbol findMethod(NameAndType nt, Scope scope, long flags) {
duke@1: if (nt == null)
duke@1: return null;
duke@1:
duke@1: MethodType type = nt.type.asMethodType();
duke@1:
duke@1: for (Scope.Entry e = scope.lookup(nt.name); e.scope != null; e = e.next())
duke@1: if (e.sym.kind == MTH && isSameBinaryType(e.sym.type.asMethodType(), type))
duke@1: return (MethodSymbol)e.sym;
duke@1:
duke@1: if (nt.name != names.init)
duke@1: // not a constructor
duke@1: return null;
duke@1: if ((flags & INTERFACE) != 0)
duke@1: // no enclosing instance
duke@1: return null;
duke@1: if (nt.type.getParameterTypes().isEmpty())
duke@1: // no parameters
duke@1: return null;
duke@1:
duke@1: // A constructor of an inner class.
duke@1: // Remove the first argument (the enclosing instance)
duke@1: nt.type = new MethodType(nt.type.getParameterTypes().tail,
duke@1: nt.type.getReturnType(),
duke@1: nt.type.getThrownTypes(),
duke@1: syms.methodClass);
duke@1: // Try searching again
duke@1: return findMethod(nt, scope, flags);
duke@1: }
duke@1:
duke@1: /** Similar to Types.isSameType but avoids completion */
duke@1: private boolean isSameBinaryType(MethodType mt1, MethodType mt2) {
duke@1: List types1 = types.erasure(mt1.getParameterTypes())
duke@1: .prepend(types.erasure(mt1.getReturnType()));
duke@1: List types2 = mt2.getParameterTypes().prepend(mt2.getReturnType());
duke@1: while (!types1.isEmpty() && !types2.isEmpty()) {
duke@1: if (types1.head.tsym != types2.head.tsym)
duke@1: return false;
duke@1: types1 = types1.tail;
duke@1: types2 = types2.tail;
duke@1: }
duke@1: return types1.isEmpty() && types2.isEmpty();
duke@1: }
duke@1:
duke@1: /**
duke@1: * Character.isDigit answers true to some non-ascii
duke@1: * digits. This one does not. copied from java.lang.Class
duke@1: */
duke@1: private static boolean isAsciiDigit(char c) {
duke@1: return '0' <= c && c <= '9';
duke@1: }
duke@1:
duke@1: /** Read member attributes.
duke@1: */
duke@1: void readMemberAttrs(Symbol sym) {
duke@1: char ac = nextChar();
duke@1: for (int i = 0; i < ac; i++) {
duke@1: Name attrName = readName(nextChar());
duke@1: int attrLen = nextInt();
duke@1: readMemberAttr(sym, attrName, attrLen);
duke@1: }
duke@1: }
duke@1:
duke@1: /** Read class attribute.
duke@1: */
duke@1: void readClassAttr(ClassSymbol c, Name attrName, int attrLen) {
duke@1: if (attrName == names.SourceFile) {
duke@1: Name n = readName(nextChar());
jjg@57: c.sourcefile = new SourceFileObject(n, c.flatname);
duke@1: } else if (attrName == names.InnerClasses) {
duke@1: readInnerClasses(c);
duke@1: } else if (allowGenerics && attrName == names.Signature) {
duke@1: readingClassAttr = true;
duke@1: try {
duke@1: ClassType ct1 = (ClassType)c.type;
duke@1: assert c == currentOwner;
duke@1: ct1.typarams_field = readTypeParams(nextChar());
duke@1: ct1.supertype_field = sigToType();
duke@1: ListBuffer is = new ListBuffer();
duke@1: while (sigp != siglimit) is.append(sigToType());
duke@1: ct1.interfaces_field = is.toList();
duke@1: } finally {
duke@1: readingClassAttr = false;
duke@1: }
duke@1: } else {
duke@1: readMemberAttr(c, attrName, attrLen);
duke@1: }
duke@1: }
duke@1: private boolean readingClassAttr = false;
duke@1: private List missingTypeVariables = List.nil();
duke@1: private List foundTypeVariables = List.nil();
duke@1:
duke@1: /** Read class attributes.
duke@1: */
duke@1: void readClassAttrs(ClassSymbol c) {
duke@1: char ac = nextChar();
duke@1: for (int i = 0; i < ac; i++) {
duke@1: Name attrName = readName(nextChar());
duke@1: int attrLen = nextInt();
duke@1: readClassAttr(c, attrName, attrLen);
duke@1: }
duke@1: }
duke@1:
duke@1: /** Read code block.
duke@1: */
duke@1: Code readCode(Symbol owner) {
duke@1: nextChar(); // max_stack
duke@1: nextChar(); // max_locals
duke@1: final int code_length = nextInt();
duke@1: bp += code_length;
duke@1: final char exception_table_length = nextChar();
duke@1: bp += exception_table_length * 8;
duke@1: readMemberAttrs(owner);
duke@1: return null;
duke@1: }
duke@1:
duke@1: /************************************************************************
duke@1: * Reading Java-language annotations
duke@1: ***********************************************************************/
duke@1:
duke@1: /** Attach annotations.
duke@1: */
duke@1: void attachAnnotations(final Symbol sym) {
duke@1: int numAttributes = nextChar();
duke@1: if (numAttributes != 0) {
duke@1: ListBuffer proxies =
duke@1: new ListBuffer();
duke@1: for (int i = 0; i parameters = meth.params();
duke@1: int pnum = 0;
duke@1: while (parameters.tail != null) {
duke@1: attachAnnotations(parameters.head);
duke@1: parameters = parameters.tail;
duke@1: pnum++;
duke@1: }
duke@1: if (pnum != numParameters) {
duke@1: throw badClassFile("bad.runtime.invisible.param.annotations", meth);
duke@1: }
duke@1: }
duke@1:
duke@1: /** Attach the default value for an annotation element.
duke@1: */
duke@1: void attachAnnotationDefault(final Symbol sym) {
duke@1: final MethodSymbol meth = (MethodSymbol)sym; // only on methods
duke@1: final Attribute value = readAttributeValue();
duke@1: annotate.later(new AnnotationDefaultCompleter(meth, value));
duke@1: }
duke@1:
duke@1: Type readTypeOrClassSymbol(int i) {
duke@1: // support preliminary jsr175-format class files
duke@1: if (buf[poolIdx[i]] == CONSTANT_Class)
duke@1: return readClassSymbol(i).type;
duke@1: return readType(i);
duke@1: }
duke@1: Type readEnumType(int i) {
duke@1: // support preliminary jsr175-format class files
duke@1: int index = poolIdx[i];
duke@1: int length = getChar(index + 1);
duke@1: if (buf[index + length + 2] != ';')
duke@1: return enterClass(readName(i)).type;
duke@1: return readType(i);
duke@1: }
duke@1:
duke@1: CompoundAnnotationProxy readCompoundAnnotation() {
duke@1: Type t = readTypeOrClassSymbol(nextChar());
duke@1: int numFields = nextChar();
duke@1: ListBuffer> pairs =
duke@1: new ListBuffer>();
duke@1: for (int i=0; i(name, value));
duke@1: }
duke@1: return new CompoundAnnotationProxy(t, pairs.toList());
duke@1: }
duke@1:
duke@1: Attribute readAttributeValue() {
duke@1: char c = (char) buf[bp++];
duke@1: switch (c) {
duke@1: case 'B':
duke@1: return new Attribute.Constant(syms.byteType, readPool(nextChar()));
duke@1: case 'C':
duke@1: return new Attribute.Constant(syms.charType, readPool(nextChar()));
duke@1: case 'D':
duke@1: return new Attribute.Constant(syms.doubleType, readPool(nextChar()));
duke@1: case 'F':
duke@1: return new Attribute.Constant(syms.floatType, readPool(nextChar()));
duke@1: case 'I':
duke@1: return new Attribute.Constant(syms.intType, readPool(nextChar()));
duke@1: case 'J':
duke@1: return new Attribute.Constant(syms.longType, readPool(nextChar()));
duke@1: case 'S':
duke@1: return new Attribute.Constant(syms.shortType, readPool(nextChar()));
duke@1: case 'Z':
duke@1: return new Attribute.Constant(syms.booleanType, readPool(nextChar()));
duke@1: case 's':
duke@1: return new Attribute.Constant(syms.stringType, readPool(nextChar()).toString());
duke@1: case 'e':
duke@1: return new EnumAttributeProxy(readEnumType(nextChar()), readName(nextChar()));
duke@1: case 'c':
duke@1: return new Attribute.Class(types, readTypeOrClassSymbol(nextChar()));
duke@1: case '[': {
duke@1: int n = nextChar();
duke@1: ListBuffer l = new ListBuffer();
duke@1: for (int i=0; i values;
duke@1: ArrayAttributeProxy(List values) {
duke@1: super(null);
duke@1: this.values = values;
duke@1: }
duke@1: public void accept(Visitor v) { ((ProxyVisitor)v).visitArrayAttributeProxy(this); }
duke@1: public String toString() {
duke@1: return "{" + values + "}";
duke@1: }
duke@1: }
duke@1:
duke@1: /** A temporary proxy representing a compound attribute.
duke@1: */
duke@1: static class CompoundAnnotationProxy extends Attribute {
duke@1: final List> values;
duke@1: public CompoundAnnotationProxy(Type type,
duke@1: List> values) {
duke@1: super(type);
duke@1: this.values = values;
duke@1: }
duke@1: public void accept(Visitor v) { ((ProxyVisitor)v).visitCompoundAnnotationProxy(this); }
duke@1: public String toString() {
duke@1: StringBuffer buf = new StringBuffer();
duke@1: buf.append("@");
duke@1: buf.append(type.tsym.getQualifiedName());
duke@1: buf.append("/*proxy*/{");
duke@1: boolean first = true;
duke@1: for (List> v = values;
duke@1: v.nonEmpty(); v = v.tail) {
duke@1: Pair value = v.head;
duke@1: if (!first) buf.append(",");
duke@1: first = false;
duke@1: buf.append(value.fst);
duke@1: buf.append("=");
duke@1: buf.append(value.snd);
duke@1: }
duke@1: buf.append("}");
duke@1: return buf.toString();
duke@1: }
duke@1: }
duke@1:
duke@1: class AnnotationDeproxy implements ProxyVisitor {
duke@1: private ClassSymbol requestingOwner = currentOwner.kind == MTH
duke@1: ? currentOwner.enclClass() : (ClassSymbol)currentOwner;
duke@1:
duke@1: List deproxyCompoundList(List pl) {
duke@1: // also must fill in types!!!!
duke@1: ListBuffer buf =
duke@1: new ListBuffer();
duke@1: for (List l = pl; l.nonEmpty(); l=l.tail) {
duke@1: buf.append(deproxyCompound(l.head));
duke@1: }
duke@1: return buf.toList();
duke@1: }
duke@1:
duke@1: Attribute.Compound deproxyCompound(CompoundAnnotationProxy a) {
duke@1: ListBuffer> buf =
duke@1: new ListBuffer>();
duke@1: for (List> l = a.values;
duke@1: l.nonEmpty();
duke@1: l = l.tail) {
duke@1: MethodSymbol meth = findAccessMethod(a.type, l.head.fst);
duke@1: buf.append(new Pair
duke@1: (meth, deproxy(meth.type.getReturnType(), l.head.snd)));
duke@1: }
duke@1: return new Attribute.Compound(a.type, buf.toList());
duke@1: }
duke@1:
duke@1: MethodSymbol findAccessMethod(Type container, Name name) {
duke@1: CompletionFailure failure = null;
duke@1: try {
duke@1: for (Scope.Entry e = container.tsym.members().lookup(name);
duke@1: e.scope != null;
duke@1: e = e.next()) {
duke@1: Symbol sym = e.sym;
duke@1: if (sym.kind == MTH && sym.type.getParameterTypes().length() == 0)
duke@1: return (MethodSymbol) sym;
duke@1: }
duke@1: } catch (CompletionFailure ex) {
duke@1: failure = ex;
duke@1: }
duke@1: // The method wasn't found: emit a warning and recover
duke@1: JavaFileObject prevSource = log.useSource(requestingOwner.classfile);
duke@1: try {
duke@1: if (failure == null) {
duke@1: log.warning("annotation.method.not.found",
duke@1: container,
duke@1: name);
duke@1: } else {
duke@1: log.warning("annotation.method.not.found.reason",
duke@1: container,
duke@1: name,
mcimadamore@80: failure.getDetailValue());//diagnostic, if present
duke@1: }
duke@1: } finally {
duke@1: log.useSource(prevSource);
duke@1: }
duke@1: // Construct a new method type and symbol. Use bottom
duke@1: // type (typeof null) as return type because this type is
duke@1: // a subtype of all reference types and can be converted
duke@1: // to primitive types by unboxing.
duke@1: MethodType mt = new MethodType(List.nil(),
duke@1: syms.botType,
duke@1: List.nil(),
duke@1: syms.methodClass);
duke@1: return new MethodSymbol(PUBLIC | ABSTRACT, name, mt, container.tsym);
duke@1: }
duke@1:
duke@1: Attribute result;
duke@1: Type type;
duke@1: Attribute deproxy(Type t, Attribute a) {
duke@1: Type oldType = type;
duke@1: try {
duke@1: type = t;
duke@1: a.accept(this);
duke@1: return result;
duke@1: } finally {
duke@1: type = oldType;
duke@1: }
duke@1: }
duke@1:
duke@1: // implement Attribute.Visitor below
duke@1:
duke@1: public void visitConstant(Attribute.Constant value) {
duke@1: // assert value.type == type;
duke@1: result = value;
duke@1: }
duke@1:
duke@1: public void visitClass(Attribute.Class clazz) {
duke@1: result = clazz;
duke@1: }
duke@1:
duke@1: public void visitEnum(Attribute.Enum e) {
duke@1: throw new AssertionError(); // shouldn't happen
duke@1: }
duke@1:
duke@1: public void visitCompound(Attribute.Compound compound) {
duke@1: throw new AssertionError(); // shouldn't happen
duke@1: }
duke@1:
duke@1: public void visitArray(Attribute.Array array) {
duke@1: throw new AssertionError(); // shouldn't happen
duke@1: }
duke@1:
duke@1: public void visitError(Attribute.Error e) {
duke@1: throw new AssertionError(); // shouldn't happen
duke@1: }
duke@1:
duke@1: public void visitEnumAttributeProxy(EnumAttributeProxy proxy) {
duke@1: // type.tsym.flatName() should == proxy.enumFlatName
duke@1: TypeSymbol enumTypeSym = proxy.enumType.tsym;
duke@1: VarSymbol enumerator = null;
duke@1: for (Scope.Entry e = enumTypeSym.members().lookup(proxy.enumerator);
duke@1: e.scope != null;
duke@1: e = e.next()) {
duke@1: if (e.sym.kind == VAR) {
duke@1: enumerator = (VarSymbol)e.sym;
duke@1: break;
duke@1: }
duke@1: }
duke@1: if (enumerator == null) {
duke@1: log.error("unknown.enum.constant",
duke@1: currentClassFile, enumTypeSym, proxy.enumerator);
duke@1: result = new Attribute.Error(enumTypeSym.type);
duke@1: } else {
duke@1: result = new Attribute.Enum(enumTypeSym.type, enumerator);
duke@1: }
duke@1: }
duke@1:
duke@1: public void visitArrayAttributeProxy(ArrayAttributeProxy proxy) {
duke@1: int length = proxy.values.length();
duke@1: Attribute[] ats = new Attribute[length];
duke@1: Type elemtype = types.elemtype(type);
duke@1: int i = 0;
duke@1: for (List p = proxy.values; p.nonEmpty(); p = p.tail) {
duke@1: ats[i++] = deproxy(elemtype, p.head);
duke@1: }
duke@1: result = new Attribute.Array(type, ats);
duke@1: }
duke@1:
duke@1: public void visitCompoundAnnotationProxy(CompoundAnnotationProxy proxy) {
duke@1: result = deproxyCompound(proxy);
duke@1: }
duke@1: }
duke@1:
duke@1: class AnnotationDefaultCompleter extends AnnotationDeproxy implements Annotate.Annotator {
duke@1: final MethodSymbol sym;
duke@1: final Attribute value;
duke@1: final JavaFileObject classFile = currentClassFile;
duke@1: public String toString() {
duke@1: return " ClassReader store default for " + sym.owner + "." + sym + " is " + value;
duke@1: }
duke@1: AnnotationDefaultCompleter(MethodSymbol sym, Attribute value) {
duke@1: this.sym = sym;
duke@1: this.value = value;
duke@1: }
duke@1: // implement Annotate.Annotator.enterAnnotation()
duke@1: public void enterAnnotation() {
duke@1: JavaFileObject previousClassFile = currentClassFile;
duke@1: try {
duke@1: currentClassFile = classFile;
duke@1: sym.defaultValue = deproxy(sym.type.getReturnType(), value);
duke@1: } finally {
duke@1: currentClassFile = previousClassFile;
duke@1: }
duke@1: }
duke@1: }
duke@1:
duke@1: class AnnotationCompleter extends AnnotationDeproxy implements Annotate.Annotator {
duke@1: final Symbol sym;
duke@1: final List l;
duke@1: final JavaFileObject classFile;
duke@1: public String toString() {
duke@1: return " ClassReader annotate " + sym.owner + "." + sym + " with " + l;
duke@1: }
duke@1: AnnotationCompleter(Symbol sym, List l) {
duke@1: this.sym = sym;
duke@1: this.l = l;
duke@1: this.classFile = currentClassFile;
duke@1: }
duke@1: // implement Annotate.Annotator.enterAnnotation()
duke@1: public void enterAnnotation() {
duke@1: JavaFileObject previousClassFile = currentClassFile;
duke@1: try {
duke@1: currentClassFile = classFile;
duke@1: List newList = deproxyCompoundList(l);
duke@1: sym.attributes_field = ((sym.attributes_field == null)
duke@1: ? newList
duke@1: : newList.prependList(sym.attributes_field));
duke@1: } finally {
duke@1: currentClassFile = previousClassFile;
duke@1: }
duke@1: }
duke@1: }
duke@1:
duke@1:
duke@1: /************************************************************************
duke@1: * Reading Symbols
duke@1: ***********************************************************************/
duke@1:
duke@1: /** Read a field.
duke@1: */
duke@1: VarSymbol readField() {
duke@1: long flags = adjustFieldFlags(nextChar());
duke@1: Name name = readName(nextChar());
duke@1: Type type = readType(nextChar());
duke@1: VarSymbol v = new VarSymbol(flags, name, type, currentOwner);
duke@1: readMemberAttrs(v);
duke@1: return v;
duke@1: }
duke@1:
duke@1: /** Read a method.
duke@1: */
duke@1: MethodSymbol readMethod() {
duke@1: long flags = adjustMethodFlags(nextChar());
duke@1: Name name = readName(nextChar());
duke@1: Type type = readType(nextChar());
duke@1: if (name == names.init && currentOwner.hasOuterInstance()) {
duke@1: // Sometimes anonymous classes don't have an outer
duke@1: // instance, however, there is no reliable way to tell so
duke@1: // we never strip this$n
jjg@113: if (!currentOwner.name.isEmpty())
duke@1: type = new MethodType(type.getParameterTypes().tail,
duke@1: type.getReturnType(),
duke@1: type.getThrownTypes(),
duke@1: syms.methodClass);
duke@1: }
duke@1: MethodSymbol m = new MethodSymbol(flags, name, type, currentOwner);
duke@1: Symbol prevOwner = currentOwner;
duke@1: currentOwner = m;
duke@1: try {
duke@1: readMemberAttrs(m);
duke@1: } finally {
duke@1: currentOwner = prevOwner;
duke@1: }
duke@1: return m;
duke@1: }
duke@1:
duke@1: /** Skip a field or method
duke@1: */
duke@1: void skipMember() {
duke@1: bp = bp + 6;
duke@1: char ac = nextChar();
duke@1: for (int i = 0; i < ac; i++) {
duke@1: bp = bp + 2;
duke@1: int attrLen = nextInt();
duke@1: bp = bp + attrLen;
duke@1: }
duke@1: }
duke@1:
duke@1: /** Enter type variables of this classtype and all enclosing ones in
duke@1: * `typevars'.
duke@1: */
duke@1: protected void enterTypevars(Type t) {
duke@1: if (t.getEnclosingType() != null && t.getEnclosingType().tag == CLASS)
duke@1: enterTypevars(t.getEnclosingType());
duke@1: for (List xs = t.getTypeArguments(); xs.nonEmpty(); xs = xs.tail)
duke@1: typevars.enter(xs.head.tsym);
duke@1: }
duke@1:
duke@1: protected void enterTypevars(Symbol sym) {
duke@1: if (sym.owner.kind == MTH) {
duke@1: enterTypevars(sym.owner);
duke@1: enterTypevars(sym.owner.owner);
duke@1: }
duke@1: enterTypevars(sym.type);
duke@1: }
duke@1:
duke@1: /** Read contents of a given class symbol `c'. Both external and internal
duke@1: * versions of an inner class are read.
duke@1: */
duke@1: void readClass(ClassSymbol c) {
duke@1: ClassType ct = (ClassType)c.type;
duke@1:
duke@1: // allocate scope for members
duke@1: c.members_field = new Scope(c);
duke@1:
duke@1: // prepare type variable table
duke@1: typevars = typevars.dup(currentOwner);
duke@1: if (ct.getEnclosingType().tag == CLASS) enterTypevars(ct.getEnclosingType());
duke@1:
duke@1: // read flags, or skip if this is an inner class
duke@1: long flags = adjustClassFlags(nextChar());
duke@1: if (c.owner.kind == PCK) c.flags_field = flags;
duke@1:
duke@1: // read own class name and check that it matches
duke@1: ClassSymbol self = readClassSymbol(nextChar());
duke@1: if (c != self)
duke@1: throw badClassFile("class.file.wrong.class",
duke@1: self.flatname);
duke@1:
duke@1: // class attributes must be read before class
duke@1: // skip ahead to read class attributes
duke@1: int startbp = bp;
duke@1: nextChar();
duke@1: char interfaceCount = nextChar();
duke@1: bp += interfaceCount * 2;
duke@1: char fieldCount = nextChar();
duke@1: for (int i = 0; i < fieldCount; i++) skipMember();
duke@1: char methodCount = nextChar();
duke@1: for (int i = 0; i < methodCount; i++) skipMember();
duke@1: readClassAttrs(c);
duke@1:
duke@1: if (readAllOfClassFile) {
duke@1: for (int i = 1; i < poolObj.length; i++) readPool(i);
duke@1: c.pool = new Pool(poolObj.length, poolObj);
duke@1: }
duke@1:
duke@1: // reset and read rest of classinfo
duke@1: bp = startbp;
duke@1: int n = nextChar();
duke@1: if (ct.supertype_field == null)
duke@1: ct.supertype_field = (n == 0)
duke@1: ? Type.noType
duke@1: : readClassSymbol(n).erasure(types);
duke@1: n = nextChar();
duke@1: List is = List.nil();
duke@1: for (int i = 0; i < n; i++) {
duke@1: Type _inter = readClassSymbol(nextChar()).erasure(types);
duke@1: is = is.prepend(_inter);
duke@1: }
duke@1: if (ct.interfaces_field == null)
duke@1: ct.interfaces_field = is.reverse();
duke@1:
duke@1: if (fieldCount != nextChar()) assert false;
duke@1: for (int i = 0; i < fieldCount; i++) enterMember(c, readField());
duke@1: if (methodCount != nextChar()) assert false;
duke@1: for (int i = 0; i < methodCount; i++) enterMember(c, readMethod());
duke@1:
duke@1: typevars = typevars.leave();
duke@1: }
duke@1:
duke@1: /** Read inner class info. For each inner/outer pair allocate a
duke@1: * member class.
duke@1: */
duke@1: void readInnerClasses(ClassSymbol c) {
duke@1: int n = nextChar();
duke@1: for (int i = 0; i < n; i++) {
duke@1: nextChar(); // skip inner class symbol
duke@1: ClassSymbol outer = readClassSymbol(nextChar());
duke@1: Name name = readName(nextChar());
duke@1: if (name == null) name = names.empty;
duke@1: long flags = adjustClassFlags(nextChar());
duke@1: if (outer != null) { // we have a member class
duke@1: if (name == names.empty)
duke@1: name = names.one;
duke@1: ClassSymbol member = enterClass(name, outer);
duke@1: if ((flags & STATIC) == 0) {
duke@1: ((ClassType)member.type).setEnclosingType(outer.type);
duke@1: if (member.erasure_field != null)
duke@1: ((ClassType)member.erasure_field).setEnclosingType(types.erasure(outer.type));
duke@1: }
duke@1: if (c == outer) {
duke@1: member.flags_field = flags;
duke@1: enterMember(c, member);
duke@1: }
duke@1: }
duke@1: }
duke@1: }
duke@1:
duke@1: /** Read a class file.
duke@1: */
duke@1: private void readClassFile(ClassSymbol c) throws IOException {
duke@1: int magic = nextInt();
duke@1: if (magic != JAVA_MAGIC)
duke@1: throw badClassFile("illegal.start.of.class.file");
duke@1:
duke@1: int minorVersion = nextChar();
duke@1: int majorVersion = nextChar();
duke@1: int maxMajor = Target.MAX().majorVersion;
duke@1: int maxMinor = Target.MAX().minorVersion;
duke@1: if (majorVersion > maxMajor ||
duke@1: majorVersion * 1000 + minorVersion <
duke@1: Target.MIN().majorVersion * 1000 + Target.MIN().minorVersion)
duke@1: {
duke@1: if (majorVersion == (maxMajor + 1))
duke@1: log.warning("big.major.version",
duke@1: currentClassFile,
duke@1: majorVersion,
duke@1: maxMajor);
duke@1: else
duke@1: throw badClassFile("wrong.version",
duke@1: Integer.toString(majorVersion),
duke@1: Integer.toString(minorVersion),
duke@1: Integer.toString(maxMajor),
duke@1: Integer.toString(maxMinor));
duke@1: }
duke@1: else if (checkClassFile &&
duke@1: majorVersion == maxMajor &&
duke@1: minorVersion > maxMinor)
duke@1: {
duke@1: printCCF("found.later.version",
duke@1: Integer.toString(minorVersion));
duke@1: }
duke@1: indexPool();
duke@1: if (signatureBuffer.length < bp) {
duke@1: int ns = Integer.highestOneBit(bp) << 1;
duke@1: signatureBuffer = new byte[ns];
duke@1: }
duke@1: readClass(c);
duke@1: }
duke@1:
duke@1: /************************************************************************
duke@1: * Adjusting flags
duke@1: ***********************************************************************/
duke@1:
duke@1: long adjustFieldFlags(long flags) {
duke@1: return flags;
duke@1: }
duke@1: long adjustMethodFlags(long flags) {
duke@1: if ((flags & ACC_BRIDGE) != 0) {
duke@1: flags &= ~ACC_BRIDGE;
duke@1: flags |= BRIDGE;
duke@1: if (!allowGenerics)
duke@1: flags &= ~SYNTHETIC;
duke@1: }
duke@1: if ((flags & ACC_VARARGS) != 0) {
duke@1: flags &= ~ACC_VARARGS;
duke@1: flags |= VARARGS;
duke@1: }
duke@1: return flags;
duke@1: }
duke@1: long adjustClassFlags(long flags) {
duke@1: return flags & ~ACC_SUPER; // SUPER and SYNCHRONIZED bits overloaded
duke@1: }
duke@1:
duke@1: /************************************************************************
duke@1: * Loading Classes
duke@1: ***********************************************************************/
duke@1:
duke@1: /** Define a new class given its name and owner.
duke@1: */
duke@1: public ClassSymbol defineClass(Name name, Symbol owner) {
duke@1: ClassSymbol c = new ClassSymbol(0, name, owner);
duke@1: if (owner.kind == PCK)
duke@1: assert classes.get(c.flatname) == null : c;
duke@1: c.completer = this;
duke@1: return c;
duke@1: }
duke@1:
duke@1: /** Create a new toplevel or member class symbol with given name
duke@1: * and owner and enter in `classes' unless already there.
duke@1: */
duke@1: public ClassSymbol enterClass(Name name, TypeSymbol owner) {
duke@1: Name flatname = TypeSymbol.formFlatName(name, owner);
duke@1: ClassSymbol c = classes.get(flatname);
duke@1: if (c == null) {
duke@1: c = defineClass(name, owner);
duke@1: classes.put(flatname, c);
duke@1: } else if ((c.name != name || c.owner != owner) && owner.kind == TYP && c.owner.kind == PCK) {
duke@1: // reassign fields of classes that might have been loaded with
duke@1: // their flat names.
duke@1: c.owner.members().remove(c);
duke@1: c.name = name;
duke@1: c.owner = owner;
duke@1: c.fullname = ClassSymbol.formFullName(name, owner);
duke@1: }
duke@1: return c;
duke@1: }
duke@1:
duke@1: /**
duke@1: * Creates a new toplevel class symbol with given flat name and
duke@1: * given class (or source) file.
duke@1: *
duke@1: * @param flatName a fully qualified binary class name
duke@1: * @param classFile the class file or compilation unit defining
duke@1: * the class (may be {@code null})
duke@1: * @return a newly created class symbol
duke@1: * @throws AssertionError if the class symbol already exists
duke@1: */
duke@1: public ClassSymbol enterClass(Name flatName, JavaFileObject classFile) {
duke@1: ClassSymbol cs = classes.get(flatName);
duke@1: if (cs != null) {
duke@1: String msg = Log.format("%s: completer = %s; class file = %s; source file = %s",
duke@1: cs.fullname,
duke@1: cs.completer,
duke@1: cs.classfile,
duke@1: cs.sourcefile);
duke@1: throw new AssertionError(msg);
duke@1: }
duke@1: Name packageName = Convert.packagePart(flatName);
duke@1: PackageSymbol owner = packageName.isEmpty()
duke@1: ? syms.unnamedPackage
duke@1: : enterPackage(packageName);
duke@1: cs = defineClass(Convert.shortName(flatName), owner);
duke@1: cs.classfile = classFile;
duke@1: classes.put(flatName, cs);
duke@1: return cs;
duke@1: }
duke@1:
duke@1: /** Create a new member or toplevel class symbol with given flat name
duke@1: * and enter in `classes' unless already there.
duke@1: */
duke@1: public ClassSymbol enterClass(Name flatname) {
duke@1: ClassSymbol c = classes.get(flatname);
duke@1: if (c == null)
duke@1: return enterClass(flatname, (JavaFileObject)null);
duke@1: else
duke@1: return c;
duke@1: }
duke@1:
duke@1: private boolean suppressFlush = false;
duke@1:
duke@1: /** Completion for classes to be loaded. Before a class is loaded
duke@1: * we make sure its enclosing class (if any) is loaded.
duke@1: */
duke@1: public void complete(Symbol sym) throws CompletionFailure {
duke@1: if (sym.kind == TYP) {
duke@1: ClassSymbol c = (ClassSymbol)sym;
duke@1: c.members_field = new Scope.ErrorScope(c); // make sure it's always defined
duke@1: boolean suppressFlush = this.suppressFlush;
duke@1: this.suppressFlush = true;
duke@1: try {
duke@1: completeOwners(c.owner);
duke@1: completeEnclosing(c);
duke@1: } finally {
duke@1: this.suppressFlush = suppressFlush;
duke@1: }
duke@1: fillIn(c);
duke@1: } else if (sym.kind == PCK) {
duke@1: PackageSymbol p = (PackageSymbol)sym;
duke@1: try {
duke@1: fillIn(p);
duke@1: } catch (IOException ex) {
duke@1: throw new CompletionFailure(sym, ex.getLocalizedMessage()).initCause(ex);
duke@1: }
duke@1: }
duke@1: if (!filling && !suppressFlush)
duke@1: annotate.flush(); // finish attaching annotations
duke@1: }
duke@1:
duke@1: /** complete up through the enclosing package. */
duke@1: private void completeOwners(Symbol o) {
duke@1: if (o.kind != PCK) completeOwners(o.owner);
duke@1: o.complete();
duke@1: }
duke@1:
duke@1: /**
duke@1: * Tries to complete lexically enclosing classes if c looks like a
duke@1: * nested class. This is similar to completeOwners but handles
duke@1: * the situation when a nested class is accessed directly as it is
duke@1: * possible with the Tree API or javax.lang.model.*.
duke@1: */
duke@1: private void completeEnclosing(ClassSymbol c) {
duke@1: if (c.owner.kind == PCK) {
duke@1: Symbol owner = c.owner;
duke@1: for (Name name : Convert.enclosingCandidates(Convert.shortName(c.name))) {
duke@1: Symbol encl = owner.members().lookup(name).sym;
duke@1: if (encl == null)
duke@1: encl = classes.get(TypeSymbol.formFlatName(name, owner));
duke@1: if (encl != null)
duke@1: encl.complete();
duke@1: }
duke@1: }
duke@1: }
duke@1:
duke@1: /** We can only read a single class file at a time; this
duke@1: * flag keeps track of when we are currently reading a class
duke@1: * file.
duke@1: */
duke@1: private boolean filling = false;
duke@1:
duke@1: /** Fill in definition of class `c' from corresponding class or
duke@1: * source file.
duke@1: */
duke@1: private void fillIn(ClassSymbol c) {
duke@1: if (completionFailureName == c.fullname) {
duke@1: throw new CompletionFailure(c, "user-selected completion failure by class name");
duke@1: }
duke@1: currentOwner = c;
duke@1: JavaFileObject classfile = c.classfile;
duke@1: if (classfile != null) {
duke@1: JavaFileObject previousClassFile = currentClassFile;
duke@1: try {
duke@1: assert !filling :
duke@1: "Filling " + classfile.toUri() +
duke@1: " during " + previousClassFile;
duke@1: currentClassFile = classfile;
duke@1: if (verbose) {
duke@1: printVerbose("loading", currentClassFile.toString());
duke@1: }
duke@1: if (classfile.getKind() == JavaFileObject.Kind.CLASS) {
duke@1: filling = true;
duke@1: try {
duke@1: bp = 0;
duke@1: buf = readInputStream(buf, classfile.openInputStream());
duke@1: readClassFile(c);
duke@1: if (!missingTypeVariables.isEmpty() && !foundTypeVariables.isEmpty()) {
duke@1: List missing = missingTypeVariables;
duke@1: List found = foundTypeVariables;
duke@1: missingTypeVariables = List.nil();
duke@1: foundTypeVariables = List.nil();
duke@1: filling = false;
duke@1: ClassType ct = (ClassType)currentOwner.type;
duke@1: ct.supertype_field =
duke@1: types.subst(ct.supertype_field, missing, found);
duke@1: ct.interfaces_field =
duke@1: types.subst(ct.interfaces_field, missing, found);
duke@1: } else if (missingTypeVariables.isEmpty() !=
duke@1: foundTypeVariables.isEmpty()) {
duke@1: Name name = missingTypeVariables.head.tsym.name;
duke@1: throw badClassFile("undecl.type.var", name);
duke@1: }
duke@1: } finally {
duke@1: missingTypeVariables = List.nil();
duke@1: foundTypeVariables = List.nil();
duke@1: filling = false;
duke@1: }
duke@1: } else {
duke@1: if (sourceCompleter != null) {
duke@1: sourceCompleter.complete(c);
duke@1: } else {
duke@1: throw new IllegalStateException("Source completer required to read "
duke@1: + classfile.toUri());
duke@1: }
duke@1: }
duke@1: return;
duke@1: } catch (IOException ex) {
duke@1: throw badClassFile("unable.to.access.file", ex.getMessage());
duke@1: } finally {
duke@1: currentClassFile = previousClassFile;
duke@1: }
duke@1: } else {
jjg@12: JCDiagnostic diag =
jjg@12: diagFactory.fragment("class.file.not.found", c.flatname);
duke@1: throw
jjg@12: newCompletionFailure(c, diag);
duke@1: }
duke@1: }
duke@1: // where
duke@1: private static byte[] readInputStream(byte[] buf, InputStream s) throws IOException {
duke@1: try {
duke@1: buf = ensureCapacity(buf, s.available());
duke@1: int r = s.read(buf);
duke@1: int bp = 0;
duke@1: while (r != -1) {
duke@1: bp += r;
duke@1: buf = ensureCapacity(buf, bp);
duke@1: r = s.read(buf, bp, buf.length - bp);
duke@1: }
duke@1: return buf;
duke@1: } finally {
duke@1: try {
duke@1: s.close();
duke@1: } catch (IOException e) {
duke@1: /* Ignore any errors, as this stream may have already
duke@1: * thrown a related exception which is the one that
duke@1: * should be reported.
duke@1: */
duke@1: }
duke@1: }
duke@1: }
duke@1: private static byte[] ensureCapacity(byte[] buf, int needed) {
duke@1: if (buf.length < needed) {
duke@1: byte[] old = buf;
duke@1: buf = new byte[Integer.highestOneBit(needed) << 1];
duke@1: System.arraycopy(old, 0, buf, 0, old.length);
duke@1: }
duke@1: return buf;
duke@1: }
duke@1: /** Static factory for CompletionFailure objects.
duke@1: * In practice, only one can be used at a time, so we share one
duke@1: * to reduce the expense of allocating new exception objects.
duke@1: */
jjg@12: private CompletionFailure newCompletionFailure(TypeSymbol c,
jjg@12: JCDiagnostic diag) {
duke@1: if (!cacheCompletionFailure) {
duke@1: // log.warning("proc.messager",
duke@1: // Log.getLocalizedString("class.file.not.found", c.flatname));
duke@1: // c.debug.printStackTrace();
jjg@12: return new CompletionFailure(c, diag);
duke@1: } else {
duke@1: CompletionFailure result = cachedCompletionFailure;
duke@1: result.sym = c;
jjg@12: result.diag = diag;
duke@1: return result;
duke@1: }
duke@1: }
duke@1: private CompletionFailure cachedCompletionFailure =
jjg@12: new CompletionFailure(null, (JCDiagnostic) null);
duke@1: {
duke@1: cachedCompletionFailure.setStackTrace(new StackTraceElement[0]);
duke@1: }
duke@1:
duke@1: /** Load a toplevel class with given fully qualified name
duke@1: * The class is entered into `classes' only if load was successful.
duke@1: */
duke@1: public ClassSymbol loadClass(Name flatname) throws CompletionFailure {
duke@1: boolean absent = classes.get(flatname) == null;
duke@1: ClassSymbol c = enterClass(flatname);
duke@1: if (c.members_field == null && c.completer != null) {
duke@1: try {
duke@1: c.complete();
duke@1: } catch (CompletionFailure ex) {
duke@1: if (absent) classes.remove(flatname);
duke@1: throw ex;
duke@1: }
duke@1: }
duke@1: return c;
duke@1: }
duke@1:
duke@1: /************************************************************************
duke@1: * Loading Packages
duke@1: ***********************************************************************/
duke@1:
duke@1: /** Check to see if a package exists, given its fully qualified name.
duke@1: */
duke@1: public boolean packageExists(Name fullname) {
duke@1: return enterPackage(fullname).exists();
duke@1: }
duke@1:
duke@1: /** Make a package, given its fully qualified name.
duke@1: */
duke@1: public PackageSymbol enterPackage(Name fullname) {
duke@1: PackageSymbol p = packages.get(fullname);
duke@1: if (p == null) {
duke@1: assert !fullname.isEmpty() : "rootPackage missing!";
duke@1: p = new PackageSymbol(
duke@1: Convert.shortName(fullname),
duke@1: enterPackage(Convert.packagePart(fullname)));
duke@1: p.completer = this;
duke@1: packages.put(fullname, p);
duke@1: }
duke@1: return p;
duke@1: }
duke@1:
duke@1: /** Make a package, given its unqualified name and enclosing package.
duke@1: */
duke@1: public PackageSymbol enterPackage(Name name, PackageSymbol owner) {
duke@1: return enterPackage(TypeSymbol.formFullName(name, owner));
duke@1: }
duke@1:
duke@1: /** Include class corresponding to given class file in package,
duke@1: * unless (1) we already have one the same kind (.class or .java), or
duke@1: * (2) we have one of the other kind, and the given class file
duke@1: * is older.
duke@1: */
duke@1: protected void includeClassFile(PackageSymbol p, JavaFileObject file) {
duke@1: if ((p.flags_field & EXISTS) == 0)
duke@1: for (Symbol q = p; q != null && q.kind == PCK; q = q.owner)
duke@1: q.flags_field |= EXISTS;
duke@1: JavaFileObject.Kind kind = file.getKind();
duke@1: int seen;
duke@1: if (kind == JavaFileObject.Kind.CLASS)
duke@1: seen = CLASS_SEEN;
duke@1: else
duke@1: seen = SOURCE_SEEN;
duke@1: String binaryName = fileManager.inferBinaryName(currentLoc, file);
duke@1: int lastDot = binaryName.lastIndexOf(".");
duke@1: Name classname = names.fromString(binaryName.substring(lastDot + 1));
duke@1: boolean isPkgInfo = classname == names.package_info;
duke@1: ClassSymbol c = isPkgInfo
duke@1: ? p.package_info
duke@1: : (ClassSymbol) p.members_field.lookup(classname).sym;
duke@1: if (c == null) {
duke@1: c = enterClass(classname, p);
duke@1: if (c.classfile == null) // only update the file if's it's newly created
duke@1: c.classfile = file;
duke@1: if (isPkgInfo) {
duke@1: p.package_info = c;
duke@1: } else {
duke@1: if (c.owner == p) // it might be an inner class
duke@1: p.members_field.enter(c);
duke@1: }
duke@1: } else if (c.classfile != null && (c.flags_field & seen) == 0) {
duke@1: // if c.classfile == null, we are currently compiling this class
duke@1: // and no further action is necessary.
duke@1: // if (c.flags_field & seen) != 0, we have already encountered
duke@1: // a file of the same kind; again no further action is necessary.
duke@1: if ((c.flags_field & (CLASS_SEEN | SOURCE_SEEN)) != 0)
duke@1: c.classfile = preferredFileObject(file, c.classfile);
duke@1: }
duke@1: c.flags_field |= seen;
duke@1: }
duke@1:
duke@1: /** Implement policy to choose to derive information from a source
duke@1: * file or a class file when both are present. May be overridden
duke@1: * by subclasses.
duke@1: */
duke@1: protected JavaFileObject preferredFileObject(JavaFileObject a,
duke@1: JavaFileObject b) {
duke@1:
duke@1: if (preferSource)
duke@1: return (a.getKind() == JavaFileObject.Kind.SOURCE) ? a : b;
duke@1: else {
duke@1: long adate = a.getLastModified();
duke@1: long bdate = b.getLastModified();
duke@1: // 6449326: policy for bad lastModifiedTime in ClassReader
duke@1: //assert adate >= 0 && bdate >= 0;
duke@1: return (adate > bdate) ? a : b;
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * specifies types of files to be read when filling in a package symbol
duke@1: */
duke@1: protected EnumSet getPackageFileKinds() {
duke@1: return EnumSet.of(JavaFileObject.Kind.CLASS, JavaFileObject.Kind.SOURCE);
duke@1: }
duke@1:
duke@1: /**
duke@1: * this is used to support javadoc
duke@1: */
duke@1: protected void extraFileActions(PackageSymbol pack, JavaFileObject fe) {
duke@1: }
duke@1:
duke@1: protected Location currentLoc; // FIXME
duke@1:
duke@1: private boolean verbosePath = true;
duke@1:
duke@1: /** Load directory of package into members scope.
duke@1: */
duke@1: private void fillIn(PackageSymbol p) throws IOException {
duke@1: if (p.members_field == null) p.members_field = new Scope(p);
duke@1: String packageName = p.fullname.toString();
duke@1:
duke@1: Set kinds = getPackageFileKinds();
duke@1:
duke@1: fillIn(p, PLATFORM_CLASS_PATH,
duke@1: fileManager.list(PLATFORM_CLASS_PATH,
duke@1: packageName,
duke@1: EnumSet.of(JavaFileObject.Kind.CLASS),
duke@1: false));
duke@1:
duke@1: Set classKinds = EnumSet.copyOf(kinds);
duke@1: classKinds.remove(JavaFileObject.Kind.SOURCE);
duke@1: boolean wantClassFiles = !classKinds.isEmpty();
duke@1:
duke@1: Set sourceKinds = EnumSet.copyOf(kinds);
duke@1: sourceKinds.remove(JavaFileObject.Kind.CLASS);
duke@1: boolean wantSourceFiles = !sourceKinds.isEmpty();
duke@1:
duke@1: boolean haveSourcePath = fileManager.hasLocation(SOURCE_PATH);
duke@1:
duke@1: if (verbose && verbosePath) {
duke@1: if (fileManager instanceof StandardJavaFileManager) {
duke@1: StandardJavaFileManager fm = (StandardJavaFileManager)fileManager;
duke@1: if (haveSourcePath && wantSourceFiles) {
duke@1: List path = List.nil();
duke@1: for (File file : fm.getLocation(SOURCE_PATH)) {
duke@1: path = path.prepend(file);
duke@1: }
duke@1: printVerbose("sourcepath", path.reverse().toString());
duke@1: } else if (wantSourceFiles) {
duke@1: List path = List.nil();
duke@1: for (File file : fm.getLocation(CLASS_PATH)) {
duke@1: path = path.prepend(file);
duke@1: }
duke@1: printVerbose("sourcepath", path.reverse().toString());
duke@1: }
duke@1: if (wantClassFiles) {
duke@1: List path = List.nil();
duke@1: for (File file : fm.getLocation(PLATFORM_CLASS_PATH)) {
duke@1: path = path.prepend(file);
duke@1: }
duke@1: for (File file : fm.getLocation(CLASS_PATH)) {
duke@1: path = path.prepend(file);
duke@1: }
duke@1: printVerbose("classpath", path.reverse().toString());
duke@1: }
duke@1: }
duke@1: }
duke@1:
duke@1: if (wantSourceFiles && !haveSourcePath) {
duke@1: fillIn(p, CLASS_PATH,
duke@1: fileManager.list(CLASS_PATH,
duke@1: packageName,
duke@1: kinds,
duke@1: false));
duke@1: } else {
duke@1: if (wantClassFiles)
duke@1: fillIn(p, CLASS_PATH,
duke@1: fileManager.list(CLASS_PATH,
duke@1: packageName,
duke@1: classKinds,
duke@1: false));
duke@1: if (wantSourceFiles)
duke@1: fillIn(p, SOURCE_PATH,
duke@1: fileManager.list(SOURCE_PATH,
duke@1: packageName,
duke@1: sourceKinds,
duke@1: false));
duke@1: }
duke@1: verbosePath = false;
duke@1: }
duke@1: // where
duke@1: private void fillIn(PackageSymbol p,
duke@1: Location location,
duke@1: Iterable files)
duke@1: {
duke@1: currentLoc = location;
duke@1: for (JavaFileObject fo : files) {
duke@1: switch (fo.getKind()) {
duke@1: case CLASS:
duke@1: case SOURCE: {
duke@1: // TODO pass binaryName to includeClassFile
duke@1: String binaryName = fileManager.inferBinaryName(currentLoc, fo);
duke@1: String simpleName = binaryName.substring(binaryName.lastIndexOf(".") + 1);
duke@1: if (SourceVersion.isIdentifier(simpleName) ||
duke@1: simpleName.equals("package-info"))
duke@1: includeClassFile(p, fo);
duke@1: break;
duke@1: }
duke@1: default:
duke@1: extraFileActions(p, fo);
duke@1: }
duke@1: }
duke@1: }
duke@1:
duke@1: /** Output for "-verbose" option.
duke@1: * @param key The key to look up the correct internationalized string.
duke@1: * @param arg An argument for substitution into the output string.
duke@1: */
duke@1: private void printVerbose(String key, CharSequence arg) {
duke@1: Log.printLines(log.noticeWriter, Log.getLocalizedString("verbose." + key, arg));
duke@1: }
duke@1:
duke@1: /** Output for "-checkclassfile" option.
duke@1: * @param key The key to look up the correct internationalized string.
duke@1: * @param arg An argument for substitution into the output string.
duke@1: */
duke@1: private void printCCF(String key, Object arg) {
duke@1: Log.printLines(log.noticeWriter, Log.getLocalizedString(key, arg));
duke@1: }
duke@1:
duke@1:
duke@1: public interface SourceCompleter {
duke@1: void complete(ClassSymbol sym)
duke@1: throws CompletionFailure;
duke@1: }
duke@1:
duke@1: /**
duke@1: * A subclass of JavaFileObject for the sourcefile attribute found in a classfile.
duke@1: * The attribute is only the last component of the original filename, so is unlikely
duke@1: * to be valid as is, so operations other than those to access the name throw
duke@1: * UnsupportedOperationException
duke@1: */
duke@1: private static class SourceFileObject extends BaseFileObject {
duke@1:
duke@1: /** The file's name.
duke@1: */
duke@1: private Name name;
jjg@57: private Name flatname;
duke@1:
jjg@57: public SourceFileObject(Name name, Name flatname) {
jjg@57: super(null); // no file manager; never referenced for this file object
duke@1: this.name = name;
jjg@57: this.flatname = flatname;
duke@1: }
duke@1:
duke@1: public InputStream openInputStream() {
duke@1: throw new UnsupportedOperationException();
duke@1: }
duke@1:
duke@1: public OutputStream openOutputStream() {
duke@1: throw new UnsupportedOperationException();
duke@1: }
duke@1:
duke@1: public Reader openReader() {
duke@1: throw new UnsupportedOperationException();
duke@1: }
duke@1:
duke@1: public Writer openWriter() {
duke@1: throw new UnsupportedOperationException();
duke@1: }
duke@1:
duke@1: /** @deprecated see bug 6410637 */
duke@1: @Deprecated
duke@1: public String getName() {
duke@1: return name.toString();
duke@1: }
duke@1:
duke@1: public long getLastModified() {
duke@1: throw new UnsupportedOperationException();
duke@1: }
duke@1:
duke@1: public boolean delete() {
duke@1: throw new UnsupportedOperationException();
duke@1: }
duke@1:
duke@1: public CharBuffer getCharContent(boolean ignoreEncodingErrors) {
duke@1: throw new UnsupportedOperationException();
duke@1: }
duke@1:
duke@1: @Override
duke@1: public boolean equals(Object other) {
duke@1: if (!(other instanceof SourceFileObject))
duke@1: return false;
duke@1: SourceFileObject o = (SourceFileObject) other;
duke@1: return name.equals(o.name);
duke@1: }
duke@1:
duke@1: @Override
duke@1: public int hashCode() {
duke@1: return name.hashCode();
duke@1: }
duke@1:
duke@1: public boolean isNameCompatible(String simpleName, JavaFileObject.Kind kind) {
duke@1: return true; // fail-safe mode
duke@1: }
duke@1:
duke@1: public URI toUri() {
duke@1: return URI.create(name.toString());
duke@1: }
duke@1:
duke@1: public Reader openReader(boolean ignoreEncodingErrors) throws IOException {
duke@1: throw new UnsupportedOperationException();
duke@1: }
duke@1:
jjg@57: @Override
jjg@57: protected String inferBinaryName(Iterable extends File> path) {
jjg@57: return flatname.toString();
jjg@57: }
duke@1: }
duke@1: }