/*

 * Copyright (c) 1999, 2017, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package com.sun.tools.javac.jvm;

import java.io.*;

import java.net.URI;

import java.net.URISyntaxException;

import java.nio.CharBuffer;

import java.nio.file.ClosedFileSystemException;

import java.util.Arrays;

import java.util.EnumSet;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Map;

import java.util.Set;

import javax.lang.model.element.Modifier;

import javax.lang.model.element.NestingKind;

import javax.tools.JavaFileManager;

import javax.tools.JavaFileObject;

import com.sun.tools.javac.comp.Annotate;

import com.sun.tools.javac.comp.Annotate.AnnotationTypeCompleter;

import com.sun.tools.javac.code.*;

import com.sun.tools.javac.code.Directive.*;

import com.sun.tools.javac.code.Lint.LintCategory;

import com.sun.tools.javac.code.Scope.WriteableScope;

import com.sun.tools.javac.code.Symbol.*;

import com.sun.tools.javac.code.Symtab;

import com.sun.tools.javac.code.Type.*;

import com.sun.tools.javac.comp.Annotate.AnnotationTypeMetadata;

import com.sun.tools.javac.file.BaseFileManager;

import com.sun.tools.javac.file.PathFileObject;

import com.sun.tools.javac.jvm.ClassFile.NameAndType;

import com.sun.tools.javac.jvm.ClassFile.Version;

import com.sun.tools.javac.main.Option;

import com.sun.tools.javac.util.*;

import com.sun.tools.javac.util.DefinedBy.Api;

import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;

import static com.sun.tools.javac.code.Flags.*;

import static com.sun.tools.javac.code.Kinds.Kind.*;

import com.sun.tools.javac.code.Scope.LookupKind;

import static com.sun.tools.javac.code.TypeTag.ARRAY;

import static com.sun.tools.javac.code.TypeTag.CLASS;

import static com.sun.tools.javac.code.TypeTag.TYPEVAR;

import static com.sun.tools.javac.jvm.ClassFile.*;

import static com.sun.tools.javac.jvm.ClassFile.Version.*;

import static com.sun.tools.javac.main.Option.PARAMETERS;

/** This class provides operations to read a classfile into an internal

 *  representation. The internal representation is anchored in a

 *  ClassSymbol which contains in its scope symbol representations

 *  for all other definitions in the classfile. Top-level Classes themselves

 *  appear as members of the scopes of PackageSymbols.

 *

 *  <p><b>This is NOT part of any supported API.

 *  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 ClassReader {

    /** The context key for the class reader. */

    public static final Context.Key<ClassReader> classReaderKey = new Context.Key<>();

    public static final int INITIAL_BUFFER_SIZE = 0x0fff0;

    private final Annotate annotate;

    /** Switch: verbose output.

     */

    boolean verbose;

    /** Switch: read constant pool and code sections. This switch is initially

     *  set to false but can be turned on from outside.

     */

    public boolean readAllOfClassFile = false;

    /** Switch: allow simplified varargs.

     */

    boolean allowSimplifiedVarargs;

    /** Switch: allow modules.

     */

    boolean allowModules;

   /** Lint option: warn about classfile issues

     */

    boolean lintClassfile;

    /** Switch: preserve parameter names from the variable table.

     */

    public boolean saveParameterNames;

    /**

     * The currently selected profile.

     */

    public final Profile profile;

    /** The log to use for verbose output

     */

    final Log log;

    /** The symbol table. */

    Symtab syms;

    Types types;

    /** The name table. */

    final Names names;

    /** Access to files

     */

    private final JavaFileManager fileManager;

    /** Factory for diagnostics

     */

    JCDiagnostic.Factory diagFactory;

    private final boolean ideMode;

    /** The current scope where type variables are entered.

     */

    protected WriteableScope typevars;

    private List<InterimUsesDirective> interimUses = List.nil();

    private List<InterimProvidesDirective> interimProvides = List.nil();

    /** The path name of the class file currently being read.

     */

    protected JavaFileObject currentClassFile = null;

    /** The class or method currently being read.

     */

    protected Symbol currentOwner = null;

    /** The module containing the class currently being read.

     */

    protected ModuleSymbol currentModule = null;

    /** The buffer containing the currently read class file.

     */

    byte[] buf = new byte[INITIAL_BUFFER_SIZE];

    /** The current input pointer.

     */

    protected int bp;

    /** The objects of the constant pool.

     */

    Object[] poolObj;

    /** For every constant pool entry, an index into buf where the

     *  defining section of the entry is found.

     */

    int[] poolIdx;

    /** The major version number of the class file being read. */

    int majorVersion;

    /** The minor version number of the class file being read. */

    int minorVersion;

    /** A table to hold the constant pool indices for method parameter

     * names, as given in LocalVariableTable attributes.

     */

    int[] parameterNameIndices;

    /**

     * Whether or not any parameter names have been found.

     */

    boolean haveParameterNameIndices;

    /** Set this to false every time we start reading a method

     * and are saving parameter names.  Set it to true when we see

     * MethodParameters, if it's set when we see a LocalVariableTable,

     * then we ignore the parameter names from the LVT.

     */

    boolean sawMethodParameters;

    /**

     * The set of attribute names for which warnings have been generated for the current class

     */

    Set<Name> warnedAttrs = new HashSet<>();

    /**

     * The prototype @Target Attribute.Compound if this class is an annotation annotated with

     * @Target

     */

    CompoundAnnotationProxy target;

    /**

     * The prototype @Repetable Attribute.Compound if this class is an annotation annotated with

     * @Repeatable

     */

    CompoundAnnotationProxy repeatable;

    /** 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);

        return instance;

    }

    /** Construct a new class reader. */

    protected ClassReader(Context context) {

        context.put(classReaderKey, this);

        annotate = Annotate.instance(context);

        names = Names.instance(context);

        syms = Symtab.instance(context);

        types = Types.instance(context);

        fileManager = context.get(JavaFileManager.class);

        if (fileManager == null)

            throw new AssertionError("FileManager initialization error");

        diagFactory = JCDiagnostic.Factory.instance(context);

        log = Log.instance(context);

        Options options = Options.instance(context);

        verbose         = options.isSet(Option.VERBOSE);

        ideMode = options.get("ide") != null;

        Source source = Source.instance(context);

        allowSimplifiedVarargs = source.allowSimplifiedVarargs();

        allowModules     = source.allowModules();

        saveParameterNames = options.isSet(PARAMETERS);

        profile = Profile.instance(context);

        typevars = WriteableScope.create(syms.noSymbol);

        lintClassfile = Lint.instance(context).isEnabled(LintCategory.CLASSFILE);

        initAttributeReaders();

    }

    /** Add member to class unless it is synthetic.

     */

    private void enterMember(ClassSymbol c, Symbol sym) {

        // Synthetic members are not entered -- reason lost to history (optimization?).

        // Lambda methods must be entered because they may have inner classes (which reference them)

        if ((sym.flags_field & (SYNTHETIC|BRIDGE)) != SYNTHETIC || sym.name.startsWith(names.lambda))

            c.members_field.enter(sym);

    }

/************************************************************************

 * Error Diagnoses

 ***********************************************************************/

    public ClassFinder.BadClassFile badClassFile(String key, Object... args) {

        return new ClassFinder.BadClassFile (

            currentOwner.enclClass(),

            currentClassFile,

            diagFactory.fragment(key, args),

            diagFactory);

    }

    public ClassFinder.BadEnclosingMethodAttr badEnclosingMethod(Object... args) {

        return new ClassFinder.BadEnclosingMethodAttr (

            currentOwner.enclClass(),

            currentClassFile,

            diagFactory.fragment("bad.enclosing.method", args),

            diagFactory);

    }

/************************************************************************

 * Buffer Access

 ***********************************************************************/

    /** Read a character.

     */

    protected char nextChar() {

        return (char)(((buf[bp++] & 0xFF) << 8) + (buf[bp++] & 0xFF));

    }

    /** Read a byte.

     */

    int nextByte() {

        return buf[bp++] & 0xFF;

    }

    /** Read an integer.

     */

    int nextInt() {

        return

            ((buf[bp++] & 0xFF) << 24) +

            ((buf[bp++] & 0xFF) << 16) +

            ((buf[bp++] & 0xFF) << 8) +

            (buf[bp++] & 0xFF);

    }

    /** Extract a character at position bp from buf.

     */

    char getChar(int bp) {

        return

            (char)(((buf[bp] & 0xFF) << 8) + (buf[bp+1] & 0xFF));

    }

    /** Extract an integer at position bp from buf.

     */

    int getInt(int bp) {

        return

            ((buf[bp] & 0xFF) << 24) +

            ((buf[bp+1] & 0xFF) << 16) +

            ((buf[bp+2] & 0xFF) << 8) +

            (buf[bp+3] & 0xFF);

    }

    /** Extract a long integer at position bp from buf.

     */

    long getLong(int bp) {

        DataInputStream bufin =

            new DataInputStream(new ByteArrayInputStream(buf, bp, 8));

        try {

            return bufin.readLong();

        } catch (IOException e) {

            throw new AssertionError(e);

        }

    }

    /** Extract a float at position bp from buf.

     */

    float getFloat(int bp) {

        DataInputStream bufin =

            new DataInputStream(new ByteArrayInputStream(buf, bp, 4));

        try {

            return bufin.readFloat();

        } catch (IOException e) {

            throw new AssertionError(e);

        }

    }

    /** Extract a double at position bp from buf.

     */

    double getDouble(int bp) {

        DataInputStream bufin =

            new DataInputStream(new ByteArrayInputStream(buf, bp, 8));

        try {

            return bufin.readDouble();

        } catch (IOException e) {

            throw new AssertionError(e);

        }

    }

/************************************************************************

 * Constant Pool Access

 ***********************************************************************/

    /** Index all constant pool entries, writing their start addresses into

     *  poolIdx.

     */

    void indexPool() {

        poolIdx = new int[nextChar()];

        poolObj = new Object[poolIdx.length];

        int i = 1;

        while (i < poolIdx.length) {

            poolIdx[i++] = bp;

            byte tag = buf[bp++];

            switch (tag) {

            case CONSTANT_Utf8: case CONSTANT_Unicode: {

                int len = nextChar();

                bp = bp + len;

                break;

            }

            case CONSTANT_Class:

            case CONSTANT_String:

            case CONSTANT_MethodType:

            case CONSTANT_Module:

            case CONSTANT_Package:

                bp = bp + 2;

                break;

            case CONSTANT_MethodHandle:

                bp = bp + 3;

                break;

            case CONSTANT_Fieldref:

            case CONSTANT_Methodref:

            case CONSTANT_InterfaceMethodref:

            case CONSTANT_NameandType:

            case CONSTANT_Integer:

            case CONSTANT_Float:

            case CONSTANT_InvokeDynamic:

                bp = bp + 4;

                break;

            case CONSTANT_Long:

            case CONSTANT_Double:

                bp = bp + 8;

                i++;

                break;

            default:

                throw badClassFile("bad.const.pool.tag.at",

                                   Byte.toString(tag),

                                   Integer.toString(bp -1));

            }

        }

    }

    /** Read constant pool entry at start address i, use pool as a cache.

     */

    Object readPool(int i) {

        Object result = poolObj[i];

        if (result != null) return result;

        int index = poolIdx[i];

        if (index == 0) return null;

        byte tag = buf[index];

        switch (tag) {

        case CONSTANT_Utf8:

            poolObj[i] = names.fromUtf(buf, index + 3, getChar(index + 1));

            break;

        case CONSTANT_Unicode:

            throw badClassFile("unicode.str.not.supported");

        case CONSTANT_Class:

            poolObj[i] = readClassOrType(getChar(index + 1));

            break;

        case CONSTANT_String:

            // FIXME: (footprint) do not use toString here

            poolObj[i] = readName(getChar(index + 1)).toString();

            break;

        case CONSTANT_Fieldref: {

            ClassSymbol owner = readClassSymbol(getChar(index + 1));

            NameAndType nt = readNameAndType(getChar(index + 3));

            poolObj[i] = new VarSymbol(0, nt.name, nt.uniqueType.type, owner);

            break;

        }

        case CONSTANT_Methodref:

        case CONSTANT_InterfaceMethodref: {

            ClassSymbol owner = readClassSymbol(getChar(index + 1));

            NameAndType nt = readNameAndType(getChar(index + 3));

            poolObj[i] = new MethodSymbol(0, nt.name, nt.uniqueType.type, owner);

            break;

        }

        case CONSTANT_NameandType:

            poolObj[i] = new NameAndType(

                readName(getChar(index + 1)),

                readType(getChar(index + 3)), types);

            break;

        case CONSTANT_Integer:

            poolObj[i] = getInt(index + 1);

            break;

        case CONSTANT_Float:

            poolObj[i] = Float.valueOf(getFloat(index + 1));

            break;

        case CONSTANT_Long:

            poolObj[i] = Long.valueOf(getLong(index + 1));

            break;

        case CONSTANT_Double:

            poolObj[i] = Double.valueOf(getDouble(index + 1));

            break;

        case CONSTANT_MethodHandle:

            skipBytes(4);

            break;

        case CONSTANT_MethodType:

            skipBytes(3);

            break;

        case CONSTANT_InvokeDynamic:

            skipBytes(5);

            break;

        case CONSTANT_Module:

        case CONSTANT_Package:

            // this is temporary for now: treat as a simple reference to the underlying Utf8.

            poolObj[i] = readName(getChar(index + 1));

            break;

        default:

            throw badClassFile("bad.const.pool.tag", Byte.toString(tag));

        }

        return poolObj[i];

    }

    /** Read signature and convert to type.

     */

    protected Type readType(int i) {

        int index = poolIdx[i];

        return sigToType(buf, index + 3, getChar(index + 1));

    }

    /** 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)));

    }

    /** Read signature and convert to type parameters.

     */

    List<Type> readTypeParams(int i) {

        int index = poolIdx[i];

        return sigToTypeParams(buf, index + 3, getChar(index + 1));

    }

    /** Read class entry.

     */

    ClassSymbol readClassSymbol(int i) {

        Object obj = readPool(i);

        if (obj != null && !(obj instanceof ClassSymbol))

            throw badClassFile("bad.const.pool.entry",

                               currentClassFile.toString(),

                               "CONSTANT_Class_info", i);

        return (ClassSymbol)obj;

    }

    Name readClassName(int i) {

        int index = poolIdx[i];

        if (index == 0) return null;

        byte tag = buf[index];

        if (tag != CONSTANT_Class) {

            throw badClassFile("bad.const.pool.entry",

                               currentClassFile.toString(),

                               "CONSTANT_Class_info", i);

        }

        int nameIndex =  poolIdx[getChar(index + 1)];

        int len = getChar(nameIndex + 1);

        int start = nameIndex + 3;

        if (buf[start] == '[' || buf[start + len - 1] == ';')

            throw badClassFile("wrong class name"); //TODO: proper diagnostics

        return names.fromUtf(internalize(buf, start, len));

    }

    /** Read name.

     */

    protected Name readName(int i) {

        Object obj = readPool(i);

        if (obj != null && !(obj instanceof Name))

            throw badClassFile("bad.const.pool.entry",

                               currentClassFile.toString(),

                               "CONSTANT_Utf8_info or CONSTANT_String_info", i);

        return (Name)obj;

    }

    /** Read name and type.

     */

    NameAndType readNameAndType(int i) {

        Object obj = readPool(i);

        if (obj != null && !(obj instanceof NameAndType))

            throw badClassFile("bad.const.pool.entry",

                               currentClassFile.toString(),

                               "CONSTANT_NameAndType_info", i);

        return (NameAndType)obj;

    }

    /** Read the name of a module.

     * The name is stored in a CONSTANT_Module entry, in

     * JVMS 4.2 binary form (using ".", not "/")

     */

    Name readModuleName(int i) {

        return readName(i);

    }

    /** Read module_flags.

     */

    Set<ModuleFlags> readModuleFlags(int flags) {

        Set<ModuleFlags> set = EnumSet.noneOf(ModuleFlags.class);

        for (ModuleFlags f : ModuleFlags.values()) {

            if ((flags & f.value) != 0)

                set.add(f);

        }

        return set;

    }

    /** Read resolution_flags.

     */

    Set<ModuleResolutionFlags> readModuleResolutionFlags(int flags) {

        Set<ModuleResolutionFlags> set = EnumSet.noneOf(ModuleResolutionFlags.class);

        for (ModuleResolutionFlags f : ModuleResolutionFlags.values()) {

            if ((flags & f.value) != 0)

                set.add(f);

        }

        return set;

    }

    /** Read exports_flags.

     */

    Set<ExportsFlag> readExportsFlags(int flags) {

        Set<ExportsFlag> set = EnumSet.noneOf(ExportsFlag.class);

        for (ExportsFlag f: ExportsFlag.values()) {

            if ((flags & f.value) != 0)

                set.add(f);

        }

        return set;

    }

    /** Read opens_flags.

     */

    Set<OpensFlag> readOpensFlags(int flags) {

        Set<OpensFlag> set = EnumSet.noneOf(OpensFlag.class);

        for (OpensFlag f: OpensFlag.values()) {

            if ((flags & f.value) != 0)

                set.add(f);

        }

        return set;

    }

    /** Read requires_flags.

     */

    Set<RequiresFlag> readRequiresFlags(int flags) {

        Set<RequiresFlag> set = EnumSet.noneOf(RequiresFlag.class);

        for (RequiresFlag f: RequiresFlag.values()) {

            if ((flags & f.value) != 0)

                set.add(f);

        }

        return set;

    }

/************************************************************************

 * Reading Types

 ***********************************************************************/

    /** The unread portion of the currently read type is

     *  signature[sigp..siglimit-1].

     */

    byte[] signature;

    int sigp;

    int siglimit;

    boolean sigEnterPhase = false;

    /** Convert signature to type, where signature is a byte array segment.

     */

    Type sigToType(byte[] sig, int offset, int len) {

        signature = sig;

        sigp = offset;

        siglimit = offset + len;

        return sigToType();

    }

    /** Convert signature to type, where signature is implicit.

     */

    Type sigToType() {

        switch ((char) signature[sigp]) {

        case 'T':

            sigp++;

            int start = sigp;

            while (signature[sigp] != ';') sigp++;

            sigp++;

            return sigEnterPhase

                ? Type.noType

                : findTypeVar(names.fromUtf(signature, start, sigp - 1 - start));

        case '+': {

            sigp++;

            Type t = sigToType();

            return new WildcardType(t, BoundKind.EXTENDS, syms.boundClass);

        }

        case '*':

            sigp++;

            return new WildcardType(syms.objectType, BoundKind.UNBOUND,

                                    syms.boundClass);

        case '-': {

            sigp++;

            Type t = sigToType();

            return new WildcardType(t, BoundKind.SUPER, syms.boundClass);

        }

        case 'B':

            sigp++;

            return syms.byteType;

        case 'C':

            sigp++;

            return syms.charType;

        case 'D':

            sigp++;

            return syms.doubleType;

        case 'F':

            sigp++;

            return syms.floatType;

        case 'I':

            sigp++;

            return syms.intType;

        case 'J':

            sigp++;

            return syms.longType;

        case 'R':

        case 'L':

            {

                // int oldsigp = sigp;

                Type t = classSigToType();

                if (sigp < siglimit && signature[sigp] == '.')

                    throw badClassFile("deprecated inner class signature syntax " +

                                       "(please recompile from source)");

                /*

                System.err.println(" decoded " +

                                   new String(signature, oldsigp, sigp-oldsigp) +

                                   " => " + t + " outer " + t.outer());

                */

                return t;

            }

        case 'S':

            sigp++;

            return syms.shortType;

        case 'V':

            sigp++;

            return syms.voidType;

        case 'Z':

            sigp++;

            return syms.booleanType;

        case '[':

            sigp++;

            return new ArrayType(sigToType(), syms.arrayClass);

        case '(':

            sigp++;

            List<Type> argtypes = sigToTypes(')');

            Type restype = sigToType();

            List<Type> thrown = List.nil();

            while (signature[sigp] == '^') {

                sigp++;

                thrown = thrown.prepend(sigToType());

            }

            // if there is a typevar in the throws clause we should state it.

            for (List<Type> l = thrown; l.nonEmpty(); l = l.tail) {

                if (l.head.hasTag(TYPEVAR)) {

                    l.head.tsym.flags_field |= THROWS;

                }

            }

            return new MethodType(argtypes,

                                  restype,

                                  thrown.reverse(),

                                  syms.methodClass);

        case '<':

            typevars = typevars.dup(currentOwner);

            Type poly = new ForAll(sigToTypeParams(), sigToType());

            typevars = typevars.leave();

            return poly;

        default:

            throw badClassFile("bad.signature",

                               Convert.utf2string(signature, sigp, 10));

        }

    }

    byte[] signatureBuffer = new byte[0];

    int sbp = 0;

    /** Convert class signature to type, where signature is implicit.

     */

    Type classSigToType() {

        if (signature[sigp] != 'L' && signature[sigp] != 'R')

            throw badClassFile("bad.class.signature",

                               Convert.utf2string(signature, sigp, 10));

        boolean err = signature[sigp] == 'R';

        sigp++;

        Type outer = Type.noType;

        int startSbp = sbp;

        while (true) {

            final byte c = signature[sigp++];

            switch (c) {

            case ';': {         // end

                ClassSymbol t = enterClass(names.fromUtf(signatureBuffer,

                                                         startSbp,

                                                         sbp - startSbp));

                try {

                    return err ? new ErrorType(Type.noType, t) :

                            (outer == Type.noType) ?

                            t.erasure(types) :

                        new ClassType(outer, List.nil(), t);

                } finally {

                    sbp = startSbp;

                }

            }

            case '<':           // generic arguments

                ClassSymbol t = enterClass(names.fromUtf(signatureBuffer,

                                                         startSbp,

                                                         sbp - startSbp));

                outer = new ClassType(outer, sigToTypes('>'), t) {

                        boolean completed = false;

                        @Override @DefinedBy(Api.LANGUAGE_MODEL)

                        public Type getEnclosingType() {

                            if (!completed) {

                                completed = true;

                                try {

                                    tsym.complete();

                                } catch (CompletionFailure cf) {}

                                Type enclosingType = tsym.type.getEnclosingType();

                                if (enclosingType != Type.noType) {

                                    List<Type> typeArgs =

                                        super.getEnclosingType().allparams();

                                    List<Type> typeParams =

                                        enclosingType.allparams();

                                    if (typeParams.length() != typeArgs.length()) {

                                        // no "rare" types

                                        super.setEnclosingType(types.erasure(enclosingType));

                                    } else {

                                        super.setEnclosingType(types.subst(enclosingType,

                                                                           typeParams,

                                                                           typeArgs));

                                    }

                                } else {

                                    super.setEnclosingType(Type.noType);

                                }

                            }

                            return super.getEnclosingType();

                        }

                        @Override

                        public void setEnclosingType(Type outer) {

                            throw new UnsupportedOperationException();

                        }

                    };

                switch (signature[sigp++]) {

                case ';':

                    if (sigp < signature.length && signature[sigp] == '.') {

                        // support old-style GJC signatures

                        // The signature produced was

                        // Lfoo/Outer<Lfoo/X;>;.Lfoo/Outer$Inner<Lfoo/Y;>;

                        // rather than say

                        // Lfoo/Outer<Lfoo/X;>.Inner<Lfoo/Y;>;

                        // so we skip past ".Lfoo/Outer$"

                        sigp += (sbp - startSbp) + // "foo/Outer"

                            3;  // ".L" and "$"

                        signatureBuffer[sbp++] = (byte)'$';

                        break;

                    } else {

                        sbp = startSbp;

                        return outer;

                    }

                case '.':

                    signatureBuffer[sbp++] = (byte)'$';

                    break;

                default:

                    throw new AssertionError(signature[sigp-1]);

                }

                continue;

            case '.':

                //we have seen an enclosing non-generic class

                if (outer != Type.noType) {

                    t = enterClass(names.fromUtf(signatureBuffer,

                                                 startSbp,

                                                 sbp - startSbp));

                    outer = new ClassType(outer, List.nil(), t);

                }

                signatureBuffer[sbp++] = (byte)'$';

                continue;

            case '/':

                signatureBuffer[sbp++] = (byte)'.';

                continue;

            default:

                signatureBuffer[sbp++] = c;

                continue;

            }

        }

    }

    /** Convert (implicit) signature to list of types

     *  until `terminator' is encountered.

     */

    List<Type> sigToTypes(char terminator) {

        List<Type> head = List.of(null);

        List<Type> tail = head;

        while (signature[sigp] != terminator)

            tail = tail.setTail(List.of(sigToType()));

        sigp++;

        return head.tail;

    }

    /** Convert signature to type parameters, where signature is a byte

     *  array segment.

     */

    List<Type> sigToTypeParams(byte[] sig, int offset, int len) {

        signature = sig;

        sigp = offset;

        siglimit = offset + len;

        return sigToTypeParams();

    }

    /** Convert signature to type parameters, where signature is implicit.

     */

    List<Type> sigToTypeParams() {

        List<Type> tvars = List.nil();

        if (signature[sigp] == '<') {

            sigp++;

            int start = sigp;

            sigEnterPhase = true;

            while (signature[sigp] != '>')

                tvars = tvars.prepend(sigToTypeParam());

            sigEnterPhase = false;

            sigp = start;

            while (signature[sigp] != '>')

                sigToTypeParam();

            sigp++;

        }

        return tvars.reverse();

    }

    /** Convert (implicit) signature to type parameter.

     */

    Type sigToTypeParam() {

        int start = sigp;

        while (signature[sigp] != ':') sigp++;

        Name name = names.fromUtf(signature, start, sigp - start);

        TypeVar tvar;

        if (sigEnterPhase) {

            tvar = new TypeVar(name, currentOwner, syms.botType);

            typevars.enter(tvar.tsym);

        } else {

            tvar = (TypeVar)findTypeVar(name);

        }

        List<Type> bounds = List.nil();

        boolean allInterfaces = false;

        if (signature[sigp] == ':' && signature[sigp+1] == ':') {

            sigp++;

            allInterfaces = true;

        }

        while (signature[sigp] == ':') {

            sigp++;

            bounds = bounds.prepend(sigToType());

        }

        if (!sigEnterPhase) {

            types.setBounds(tvar, bounds.reverse(), allInterfaces);

        }

        return tvar;

    }

    /** Find type variable with given name in `typevars' scope.

     */

    Type findTypeVar(Name name) {

        Symbol s = typevars.findFirst(name);

        if (s != null) {

            return s.type;

        } else {

            if (readingClassAttr) {

                // While reading the class attribute, the supertypes

                // might refer to a type variable from an enclosing element

                // (method or class).

                // If the type variable is defined in the enclosing class,

                // we can actually find it in

                // currentOwner.owner.type.getTypeArguments()

                // However, until we have read the enclosing method attribute

                // we don't know for sure if this owner is correct.  It could

                // be a method and there is no way to tell before reading the

                // enclosing method attribute.

                TypeVar t = new TypeVar(name, currentOwner, syms.botType);

                missingTypeVariables = missingTypeVariables.prepend(t);

                // System.err.println("Missing type var " + name);

                return t;

            }

            throw badClassFile("undecl.type.var", name);

        }

    }

/************************************************************************

 * Reading Attributes

 ***********************************************************************/

    protected enum AttributeKind { CLASS, MEMBER }

    protected abstract class AttributeReader {

        protected AttributeReader(Name name, ClassFile.Version version, Set<AttributeKind> kinds) {

            this.name = name;

            this.version = version;

            this.kinds = kinds;

        }

        protected boolean accepts(AttributeKind kind) {

            if (kinds.contains(kind)) {

                if (majorVersion > version.major || (majorVersion == version.major && minorVersion >= version.minor))

                    return true;

                if (lintClassfile && !warnedAttrs.contains(name)) {

                    JavaFileObject prev = log.useSource(currentClassFile);