/*

 * Copyright (c) 1999, 2013, 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.lang.model.SourceVersion;

import javax.tools.JavaFileObject;

import javax.tools.JavaFileManager;

import javax.tools.JavaFileManager.Location;

import javax.tools.StandardJavaFileManager;

import static javax.tools.StandardLocation.*;

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

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

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

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

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.JCDiagnostic.DiagnosticPosition;

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

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

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

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>

 */

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

    protected static final Context.Key<ClassReader> classReaderKey =

        new Context.Key<ClassReader>();

    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: read GJ signature information.

     */

    boolean allowGenerics;

    /** Switch: read varargs attribute.

     */

    boolean allowVarargs;

    /** Switch: allow annotations.

     */

    boolean allowAnnotations;

    /** Switch: allow simplified varargs.

     */

    boolean allowSimplifiedVarargs;

   /** Lint option: warn about classfile issues

     */

    boolean lintClassfile;

    /** Switch: allow default methods

     */

    boolean allowDefaultMethods;

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

     */

    public boolean saveParameterNames;

    /**

     * Switch: cache completion failures unless -XDdev is used

     */

    private boolean cacheCompletionFailure;

    /**

     * Switch: prefer source files instead of newer when both source

     * and class are available

     **/

    public boolean preferSource;

    /**

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

    /** Force a completion failure on this name

     */

    final Name completionFailureName;

    /** Access to files

     */

    private final JavaFileManager fileManager;

    /** Factory for diagnostics

     */

    JCDiagnostic.Factory diagFactory;

    /** Can be reassigned from outside:

     *  the completer to be used for ".java" files. If this remains unassigned

     *  ".java" files will not be loaded.

     */

    public SourceCompleter sourceCompleter = null;

    /** A hashtable containing the encountered top-level and member classes,

     *  indexed by flat names. The table does not contain local classes.

     */

    private Map<Name,ClassSymbol> classes;

    /** A hashtable containing the encountered packages.

     */

    private Map<Name, PackageSymbol> packages;

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

     */

    protected Scope 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<Name>();

    /** Get the ClassReader instance for this invocation. */

    public static ClassReader instance(Context context) {

        ClassReader instance = context.get(classReaderKey);

        if (instance == null)

            instance = new ClassReader(context, true);

        return instance;

    }

    /** Initialize classes and packages, treating this as the definitive classreader. */

    public void init(Symtab syms) {

        init(syms, true);

    }

    /** Initialize classes and packages, optionally treating this as

     *  the definitive classreader.

     */

    private void init(Symtab syms, boolean definitive) {

        if (classes != null) return;

        if (definitive) {

            Assert.check(packages == null || packages == syms.packages);

            packages = syms.packages;

            Assert.check(classes == null || classes == syms.classes);

            classes = syms.classes;

        } else {

            packages = new HashMap<Name, PackageSymbol>();

            classes = new HashMap<Name, ClassSymbol>();

        }

        packages.put(names.empty, syms.rootPackage);

    }

    /** Construct a new class reader, optionally treated as the

     *  definitive classreader for this invocation.

     */

    protected ClassReader(Context context, boolean definitive) {

        if (definitive) 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);

        init(syms, definitive);

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

        allowGenerics    = source.allowGenerics();

        allowVarargs     = source.allowVarargs();

        allowAnnotations = source.allowAnnotations();

        allowSimplifiedVarargs = source.allowSimplifiedVarargs();

        allowDefaultMethods = source.allowDefaultMethods();

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

        cacheCompletionFailure = options.isUnset("dev");

        preferSource = "source".equals(options.get("-Xprefer"));

        profile = Profile.instance(context);

        completionFailureName =

            options.isSet("failcomplete")

            ? names.fromString(options.get("failcomplete"))

            : null;

        typevars = new Scope(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 class BadClassFile extends CompletionFailure {

        private static final long serialVersionUID = 0;

        public BadClassFile(TypeSymbol sym, JavaFileObject file, JCDiagnostic diag) {

            super(sym, createBadClassFileDiagnostic(file, diag));

        }

    }

    // where

    private JCDiagnostic createBadClassFileDiagnostic(JavaFileObject file, JCDiagnostic diag) {

        String key = (file.getKind() == JavaFileObject.Kind.SOURCE

                    ? "bad.source.file.header" : "bad.class.file.header");

        return diagFactory.fragment(key, file, diag);

    }

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

        return new BadClassFile (

            currentOwner.enclClass(),

            currentClassFile,

            diagFactory.fragment(key, args));

    }

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

 * 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: