/*

 * Copyright (c) 1999, 2014, 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.util.Arrays;

import java.util.EnumSet;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Map;

import java.util.Set;

import javax.tools.JavaFileManager;

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

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.file.BaseFileObject;

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 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.*;

/** 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. */

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

    public static final int INITIAL_BUFFER_SIZE = 0x0fff0;

    Annotate annotate;

    /** Switch: verbose output.

     */

    boolean verbose;

    /** Switch: check class file for correct minor version, unrecognized

     *  attributes.

     */

    boolean checkClassFile;

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

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

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

     */

    protected WriteableScope typevars;

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

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

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

        annotate = Annotate.instance(context);

        verbose        = options.isSet(VERBOSE);

        checkClassFile = options.isSet("-checkclassfile");

        Source source = Source.instance(context);

        allowSimplifiedVarargs = source.allowSimplifiedVarargs();

        saveParameterNames = options.isSet("save-parameter-names");

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

    }

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

 * Buffer Access

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

    /** Read a character.

     */

    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:

                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] = new Float(getFloat(index + 1));

            break;

        case CONSTANT_Long:

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

            break;

        case CONSTANT_Double:

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

            break;

        case CONSTANT_MethodHandle:

            skipBytes(4);

            break;

        case CONSTANT_MethodType:

            skipBytes(3);

            break;

        case CONSTANT_InvokeDynamic:

            skipBytes(5);

            break;

        default:

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

        }

        return poolObj[i];

    }

    /** Read signature and convert to type.

     */

    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)syms.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;

    }

    /** Read name.

     */

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