/*

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

import java.util.Map;

import java.util.Set;

import java.util.HashSet;

import javax.tools.JavaFileManager;

import javax.tools.FileObject;

import javax.tools.JavaFileObject;

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

import com.sun.tools.javac.code.Attribute.RetentionPolicy;

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

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

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

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

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

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

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

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

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

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

import static javax.tools.StandardLocation.CLASS_OUTPUT;

/** This class provides operations to map an internal symbol table graph

 *  rooted in a ClassSymbol into a classfile.

 *

 *  <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 ClassWriter extends ClassFile {

    protected static final Context.Key<ClassWriter> classWriterKey =

        new Context.Key<ClassWriter>();

    private final Symtab syms;

    private final Options options;

    /** Switch: verbose output.

     */

    private boolean verbose;

    /** Switch: scramble private names.

     */

    private boolean scramble;

    /** Switch: scramble private names.

     */

    private boolean scrambleAll;

    /** Switch: retrofit mode.

     */

    private boolean retrofit;

    /** Switch: emit source file attribute.

     */

    private boolean emitSourceFile;

    /** Switch: generate CharacterRangeTable attribute.

     */

    private boolean genCrt;

    /** Switch: describe the generated stackmap

     */

    boolean debugstackmap;

    /**

     * Target class version.

     */

    private Target target;

    /**

     * Source language version.

     */

    private Source source;

    /** Type utilities. */

    private Types types;

    /** The initial sizes of the data and constant pool buffers.

     *  sizes are increased when buffers get full.

     */

    static final int DATA_BUF_SIZE = 0x0fff0;

    static final int POOL_BUF_SIZE = 0x1fff0;

    /** An output buffer for member info.

     */

    ByteBuffer databuf = new ByteBuffer(DATA_BUF_SIZE);

    /** An output buffer for the constant pool.

     */

    ByteBuffer poolbuf = new ByteBuffer(POOL_BUF_SIZE);

    /** An output buffer for type signatures.

     */

    ByteBuffer sigbuf = new ByteBuffer();

    /** The constant pool.

     */

    Pool pool;

    /** The inner classes to be written, as a set.

     */

    Set<ClassSymbol> innerClasses;

    /** The inner classes to be written, as a queue where

     *  enclosing classes come first.

     */

    ListBuffer<ClassSymbol> innerClassesQueue;

    /** The bootstrap methods to be written in the corresponding class attribute

     *  (one for each invokedynamic)

     */

    Map<MethodSymbol, Pool.MethodHandle> bootstrapMethods;

    /** The log to use for verbose output.

     */

    private final Log log;

    /** The name table. */

    private final Names names;

    /** Access to files. */

    private final JavaFileManager fileManager;

    /** The tags and constants used in compressed stackmap. */

    static final int SAME_FRAME_SIZE = 64;

    static final int SAME_LOCALS_1_STACK_ITEM_EXTENDED = 247;

    static final int SAME_FRAME_EXTENDED = 251;

    static final int FULL_FRAME = 255;

    static final int MAX_LOCAL_LENGTH_DIFF = 4;

    /** Get the ClassWriter instance for this context. */

    public static ClassWriter instance(Context context) {

        ClassWriter instance = context.get(classWriterKey);

        if (instance == null)

            instance = new ClassWriter(context);

        return instance;

    }

    /** Construct a class writer, given an options table.

     */

    protected ClassWriter(Context context) {

        context.put(classWriterKey, this);

        log = Log.instance(context);

        names = Names.instance(context);

        syms = Symtab.instance(context);

        options = Options.instance(context);

        target = Target.instance(context);

        source = Source.instance(context);

        types = Types.instance(context);

        fileManager = context.get(JavaFileManager.class);

        verbose        = options.isSet(VERBOSE);

        scramble       = options.isSet("-scramble");

        scrambleAll    = options.isSet("-scrambleAll");

        retrofit       = options.isSet("-retrofit");

        genCrt         = options.isSet(XJCOV);

        debugstackmap  = options.isSet("debugstackmap");

        emitSourceFile = options.isUnset(G_CUSTOM) ||

                            options.isSet(G_CUSTOM, "source");

        String dumpModFlags = options.get("dumpmodifiers");

        dumpClassModifiers =

            (dumpModFlags != null && dumpModFlags.indexOf('c') != -1);

        dumpFieldModifiers =

            (dumpModFlags != null && dumpModFlags.indexOf('f') != -1);

        dumpInnerClassModifiers =

            (dumpModFlags != null && dumpModFlags.indexOf('i') != -1);

        dumpMethodModifiers =

            (dumpModFlags != null && dumpModFlags.indexOf('m') != -1);

    }

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

 * Diagnostics: dump generated class names and modifiers

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

    /** Value of option 'dumpmodifiers' is a string

     *  indicating which modifiers should be dumped for debugging:

     *    'c' -- classes

     *    'f' -- fields

     *    'i' -- innerclass attributes

     *    'm' -- methods

     *  For example, to dump everything:

     *    javac -XDdumpmodifiers=cifm MyProg.java

     */

    private final boolean dumpClassModifiers; // -XDdumpmodifiers=c

    private final boolean dumpFieldModifiers; // -XDdumpmodifiers=f

    private final boolean dumpInnerClassModifiers; // -XDdumpmodifiers=i

    private final boolean dumpMethodModifiers; // -XDdumpmodifiers=m

    /** Return flags as a string, separated by " ".

     */

    public static String flagNames(long flags) {

        StringBuilder sbuf = new StringBuilder();

        int i = 0;

        long f = flags & StandardFlags;

        while (f != 0) {

            if ((f & 1) != 0) {

                sbuf.append(" ");

                sbuf.append(flagName[i]);

            }

            f = f >> 1;

            i++;

        }

        return sbuf.toString();

    }

    //where

        private final static String[] flagName = {

            "PUBLIC", "PRIVATE", "PROTECTED", "STATIC", "FINAL",

            "SUPER", "VOLATILE", "TRANSIENT", "NATIVE", "INTERFACE",

            "ABSTRACT", "STRICTFP"};

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

 * Output routines

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

    /** Write a character into given byte buffer;

     *  byte buffer will not be grown.

     */

    void putChar(ByteBuffer buf, int op, int x) {

        buf.elems[op  ] = (byte)((x >>  8) & 0xFF);

        buf.elems[op+1] = (byte)((x      ) & 0xFF);

    }

    /** Write an integer into given byte buffer;

     *  byte buffer will not be grown.

     */

    void putInt(ByteBuffer buf, int adr, int x) {

        buf.elems[adr  ] = (byte)((x >> 24) & 0xFF);

        buf.elems[adr+1] = (byte)((x >> 16) & 0xFF);

        buf.elems[adr+2] = (byte)((x >>  8) & 0xFF);

        buf.elems[adr+3] = (byte)((x      ) & 0xFF);

    }

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

 * Signature Generation

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

    /** Assemble signature of given type in string buffer.

     */

    void assembleSig(Type type) {

        switch (type.getTag()) {

        case BYTE:

            sigbuf.appendByte('B');

            break;

        case SHORT:

            sigbuf.appendByte('S');

            break;

        case CHAR:

            sigbuf.appendByte('C');

            break;

        case INT:

            sigbuf.appendByte('I');

            break;

        case LONG:

            sigbuf.appendByte('J');

            break;

        case FLOAT:

            sigbuf.appendByte('F');

            break;

        case DOUBLE:

            sigbuf.appendByte('D');

            break;

        case BOOLEAN:

            sigbuf.appendByte('Z');

            break;

        case VOID:

            sigbuf.appendByte('V');

            break;

        case CLASS:

            sigbuf.appendByte('L');

            assembleClassSig(type);

            sigbuf.appendByte(';');

            break;

        case ARRAY:

            ArrayType at = (ArrayType)type;

            sigbuf.appendByte('[');

            assembleSig(at.elemtype);

            break;

        case METHOD:

            MethodType mt = (MethodType)type;

            sigbuf.appendByte('(');

            assembleSig(mt.argtypes);

            sigbuf.appendByte(')');

            assembleSig(mt.restype);

            if (hasTypeVar(mt.thrown)) {

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

                    sigbuf.appendByte('^');

                    assembleSig(l.head);

                }

            }

            break;

        case WILDCARD: {

            WildcardType ta = (WildcardType) type;

            switch (ta.kind) {

            case SUPER:

                sigbuf.appendByte('-');

                assembleSig(ta.type);

                break;

            case EXTENDS:

                sigbuf.appendByte('+');

                assembleSig(ta.type);

                break;

            case UNBOUND:

                sigbuf.appendByte('*');

                break;

            default:

                throw new AssertionError(ta.kind);

            }

            break;

        }

        case TYPEVAR:

            sigbuf.appendByte('T');

            sigbuf.appendName(type.tsym.name);

            sigbuf.appendByte(';');

            break;

        case FORALL:

            ForAll ft = (ForAll)type;

            assembleParamsSig(ft.tvars);

            assembleSig(ft.qtype);

            break;

        case UNINITIALIZED_THIS:

        case UNINITIALIZED_OBJECT:

            // we don't yet have a spec for uninitialized types in the

            // local variable table

            assembleSig(types.erasure(((UninitializedType)type).qtype));

            break;

        default:

            throw new AssertionError("typeSig " + type.getTag());

        }

    }

    boolean hasTypeVar(List<Type> l) {

        while (l.nonEmpty()) {

            if (l.head.hasTag(TYPEVAR)) return true;

            l = l.tail;

        }

        return false;

    }

    void assembleClassSig(Type type) {

        ClassType ct = (ClassType)type;

        ClassSymbol c = (ClassSymbol)ct.tsym;

        enterInner(c);

        Type outer = ct.getEnclosingType();

        if (outer.allparams().nonEmpty()) {

            boolean rawOuter =

                c.owner.kind == MTH || // either a local class

                c.name == names.empty; // or anonymous

            assembleClassSig(rawOuter

                             ? types.erasure(outer)

                             : outer);

            sigbuf.appendByte('.');

            Assert.check(c.flatname.startsWith(c.owner.enclClass().flatname));

            sigbuf.appendName(rawOuter

                              ? c.flatname.subName(c.owner.enclClass().flatname.getByteLength()+1,c.flatname.getByteLength())

                              : c.name);

        } else {

            sigbuf.appendBytes(externalize(c.flatname));

        }

        if (ct.getTypeArguments().nonEmpty()) {

            sigbuf.appendByte('<');

            assembleSig(ct.getTypeArguments());

            sigbuf.appendByte('>');

        }

    }

    void assembleSig(List<Type> types) {

        for (List<Type> ts = types; ts.nonEmpty(); ts = ts.tail)

            assembleSig(ts.head);

    }

    void assembleParamsSig(List<Type> typarams) {

        sigbuf.appendByte('<');

        for (List<Type> ts = typarams; ts.nonEmpty(); ts = ts.tail) {

            TypeVar tvar = (TypeVar)ts.head;

            sigbuf.appendName(tvar.tsym.name);

            List<Type> bounds = types.getBounds(tvar);

            if ((bounds.head.tsym.flags() & INTERFACE) != 0) {

                sigbuf.appendByte(':');

            }

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

                sigbuf.appendByte(':');

                assembleSig(l.head);

            }

        }

        sigbuf.appendByte('>');

    }

    /** Return signature of given type

     */

    Name typeSig(Type type) {

        Assert.check(sigbuf.length == 0);

        //- System.out.println(" ? " + type);

        assembleSig(type);

        Name n = sigbuf.toName(names);

        sigbuf.reset();

        //- System.out.println("   " + n);

        return n;

    }

    /** Given a type t, return the extended class name of its erasure in

     *  external representation.

     */

    public Name xClassName(Type t) {

        if (t.hasTag(CLASS)) {

            return names.fromUtf(externalize(t.tsym.flatName()));

        } else if (t.hasTag(ARRAY)) {

            return typeSig(types.erasure(t));

        } else {

            throw new AssertionError("xClassName");

        }

    }

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

 * Writing the Constant Pool

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

    /** Thrown when the constant pool is over full.

     */

    public static class PoolOverflow extends Exception {

        private static final long serialVersionUID = 0;

        public PoolOverflow() {}

    }

    public static class StringOverflow extends Exception {

        private static final long serialVersionUID = 0;

        public final String value;

        public StringOverflow(String s) {

            value = s;

        }

    }

    /** Write constant pool to pool buffer.

     *  Note: during writing, constant pool

     *  might grow since some parts of constants still need to be entered.

     */

    void writePool(Pool pool) throws PoolOverflow, StringOverflow {

        int poolCountIdx = poolbuf.length;

        poolbuf.appendChar(0);

        int i = 1;

        while (i < pool.pp) {

            Object value = pool.pool[i];

            Assert.checkNonNull(value);

            if (value instanceof Pool.Method)

                value = ((Pool.Method)value).m;

            else if (value instanceof Pool.Variable)

                value = ((Pool.Variable)value).v;

            if (value instanceof MethodSymbol) {

                MethodSymbol m = (MethodSymbol)value;

                if (!m.isDynamic()) {

                    poolbuf.appendByte((m.owner.flags() & INTERFACE) != 0

                              ? CONSTANT_InterfaceMethodref

                              : CONSTANT_Methodref);

                    poolbuf.appendChar(pool.put(m.owner));

                    poolbuf.appendChar(pool.put(nameType(m)));

                } else {

                    //invokedynamic

                    DynamicMethodSymbol dynSym = (DynamicMethodSymbol)m;

                    Pool.MethodHandle handle = new Pool.MethodHandle(dynSym.bsmKind, dynSym.bsm);

                    bootstrapMethods.put(dynSym, handle);

                    //init cp entries

                    pool.put(names.BootstrapMethods);

                    pool.put(handle);

                    for (Object staticArg : dynSym.staticArgs) {

                        pool.put(staticArg);

                    }

                    poolbuf.appendByte(CONSTANT_InvokeDynamic);

                    poolbuf.appendChar(bootstrapMethods.size() - 1);

                    poolbuf.appendChar(pool.put(nameType(dynSym)));

                }

            } else if (value instanceof VarSymbol) {

                VarSymbol v = (VarSymbol)value;

                poolbuf.appendByte(CONSTANT_Fieldref);

                poolbuf.appendChar(pool.put(v.owner));

                poolbuf.appendChar(pool.put(nameType(v)));

            } else if (value instanceof Name) {

                poolbuf.appendByte(CONSTANT_Utf8);

                byte[] bs = ((Name)value).toUtf();

                poolbuf.appendChar(bs.length);

                poolbuf.appendBytes(bs, 0, bs.length);

                if (bs.length > Pool.MAX_STRING_LENGTH)

                    throw new StringOverflow(value.toString());

            } else if (value instanceof ClassSymbol) {