/*

 * 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 com.sun.tools.javac.code.*;

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

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

import com.sun.tools.javac.jvm.Code.*;

import com.sun.tools.javac.tree.JCTree;

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

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

/** A helper class for code generation. Items are objects

 *  that stand for addressable entities in the bytecode. Each item

 *  supports a fixed protocol for loading the item on the stack, storing

 *  into it, converting it into a jump condition, and several others.

 *  There are many individual forms of items, such as local, static,

 *  indexed, or instance variables, values on the top of stack, the

 *  special values this or super, etc. Individual items are represented as

 *  inner classes in class Items.

 *

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

    /** The current constant pool.

     */

    Pool pool;

    /** The current code buffer.

     */

    Code code;

    /** The current symbol table.

     */

    Symtab syms;

    /** Type utilities. */

    Types types;

    /** Items that exist only once (flyweight pattern).

     */

    private final Item voidItem;

    private final Item thisItem;

    private final Item superItem;

    private final Item[] stackItem = new Item[TypeCodeCount];

    public Items(Pool pool, Code code, Symtab syms, Types types) {

        this.code = code;

        this.pool = pool;

        this.types = types;

        voidItem = new Item(VOIDcode) {

                public String toString() { return "void"; }

            };

        thisItem = new SelfItem(false);

        superItem = new SelfItem(true);

        for (int i = 0; i < VOIDcode; i++) stackItem[i] = new StackItem(i);

        stackItem[VOIDcode] = voidItem;

        this.syms = syms;

    }

    /** Make a void item

     */

    Item makeVoidItem() {

        return voidItem;

    }

    /** Make an item representing `this'.

     */

    Item makeThisItem() {

        return thisItem;

    }

    /** Make an item representing `super'.

     */

    Item makeSuperItem() {

        return superItem;

    }

    /** Make an item representing a value on stack.

     *  @param type    The value's type.

     */

    Item makeStackItem(Type type) {

        return stackItem[Code.typecode(type)];

    }

    /** Make an item representing a dynamically invoked method.

     *  @param member   The represented symbol.

     */

    Item makeDynamicItem(Symbol member) {

        return new DynamicItem(member);

    }

    /** Make an item representing an indexed expression.

     *  @param type    The expression's type.

     */

    Item makeIndexedItem(Type type) {

        return new IndexedItem(type);

    }

    /** Make an item representing a local variable.

     *  @param v    The represented variable.

     */

    LocalItem makeLocalItem(VarSymbol v) {

        return new LocalItem(v.erasure(types), v.adr);

    }

    /** Make an item representing a local anonymous variable.

     *  @param type  The represented variable's type.

     *  @param reg   The represented variable's register.

     */

    private LocalItem makeLocalItem(Type type, int reg) {

        return new LocalItem(type, reg);

    }

    /** Make an item representing a static variable or method.

     *  @param member   The represented symbol.

     */

    Item makeStaticItem(Symbol member) {

        return new StaticItem(member);

    }

    /** Make an item representing an instance variable or method.

     *  @param member       The represented symbol.

     *  @param nonvirtual   Is the reference not virtual? (true for constructors

     *                      and private members).

     */

    Item makeMemberItem(Symbol member, boolean nonvirtual) {

        return new MemberItem(member, nonvirtual);

    }

    /** Make an item representing a literal.

     *  @param type     The literal's type.

     *  @param value    The literal's value.

     */

    Item makeImmediateItem(Type type, Object value) {

        return new ImmediateItem(type, value);

    }

    /** Make an item representing an assignment expression.

     *  @param lhs      The item representing the assignment's left hand side.

     */

    Item makeAssignItem(Item lhs) {

        return new AssignItem(lhs);

    }

    /** Make an item representing a conditional or unconditional jump.

     *  @param opcode      The jump's opcode.

     *  @param trueJumps   A chain encomassing all jumps that can be taken

     *                     if the condition evaluates to true.

     *  @param falseJumps  A chain encomassing all jumps that can be taken

     *                     if the condition evaluates to false.

     */

    CondItem makeCondItem(int opcode, Chain trueJumps, Chain falseJumps) {

        return new CondItem(opcode, trueJumps, falseJumps);

    }

    /** Make an item representing a conditional or unconditional jump.

     *  @param opcode      The jump's opcode.

     */

    CondItem makeCondItem(int opcode) {

        return makeCondItem(opcode, null, null);

    }

    /** The base class of all items, which implements default behavior.

     */

    abstract class Item {

        /** The type code of values represented by this item.

         */

        int typecode;

        Item(int typecode) {

            this.typecode = typecode;

        }

        /** Generate code to load this item onto stack.

         */

        Item load() {

            throw new AssertionError();

        }

        /** Generate code to store top of stack into this item.

         */

        void store() {

            throw new AssertionError("store unsupported: " + this);

        }

        /** Generate code to invoke method represented by this item.

         */

        Item invoke() {

            throw new AssertionError(this);

        }

        /** Generate code to use this item twice.

         */

        void duplicate() {}

        /** Generate code to avoid having to use this item.

         */

        void drop() {}

        /** Generate code to stash a copy of top of stack - of typecode toscode -

         *  under this item.

         */

        void stash(int toscode) {

            stackItem[toscode].duplicate();

        }

        /** Generate code to turn item into a testable condition.

         */

        CondItem mkCond() {

            load();

            return makeCondItem(ifne);

        }

        /** Generate code to coerce item to given type code.

         *  @param targetcode    The type code to coerce to.

         */

        Item coerce(int targetcode) {

            if (typecode == targetcode)

                return this;

            else {

                load();

                int typecode1 = Code.truncate(typecode);

                int targetcode1 = Code.truncate(targetcode);

                if (typecode1 != targetcode1) {

                    int offset = targetcode1 > typecode1 ? targetcode1 - 1

                        : targetcode1;

                    code.emitop0(i2l + typecode1 * 3 + offset);

                }

                if (targetcode != targetcode1) {

                    code.emitop0(int2byte + targetcode - BYTEcode);

                }

                return stackItem[targetcode];

            }

        }

        /** Generate code to coerce item to given type.

         *  @param targettype    The type to coerce to.

         */

        Item coerce(Type targettype) {

            return coerce(Code.typecode(targettype));

        }

        /** Return the width of this item on stack as a number of words.

         */

        int width() {

            return 0;

        }

        public abstract String toString();

    }

    /** An item representing a value on stack.

     */

    class StackItem extends Item {

        StackItem(int typecode) {

            super(typecode);

        }

        Item load() {

            return this;

        }

        void duplicate() {

            code.emitop0(width() == 2 ? dup2 : dup);

        }

        void drop() {

            code.emitop0(width() == 2 ? pop2 : pop);

        }

        void stash(int toscode) {

            code.emitop0(

                (width() == 2 ? dup_x2 : dup_x1) + 3 * (Code.width(toscode) - 1));

        }

        int width() {

            return Code.width(typecode);

        }

        public String toString() {

            return "stack(" + typecodeNames[typecode] + ")";

        }

    }

    /** An item representing an indexed expression.

     */

    class IndexedItem extends Item {

        IndexedItem(Type type) {

            super(Code.typecode(type));

        }

        Item load() {

            code.emitop0(iaload + typecode);

            return stackItem[typecode];

        }

        void store() {

            code.emitop0(iastore + typecode);

        }

        void duplicate() {

            code.emitop0(dup2);

        }

        void drop() {

            code.emitop0(pop2);

        }

        void stash(int toscode) {

            code.emitop0(dup_x2 + 3 * (Code.width(toscode) - 1));

        }

        int width() {

            return 2;

        }

        public String toString() {

            return "indexed(" + ByteCodes.typecodeNames[typecode] + ")";

        }

    }

    /** An item representing `this' or `super'.

     */

    class SelfItem extends Item {

        /** Flag which determines whether this item represents `this' or `super'.

         */

        boolean isSuper;

        SelfItem(boolean isSuper) {

            super(OBJECTcode);

            this.isSuper = isSuper;

        }

        Item load() {

            code.emitop0(aload_0);

            return stackItem[typecode];

        }

        public String toString() {

            return isSuper ? "super" : "this";

        }

    }

    /** An item representing a local variable.

     */

    class LocalItem extends Item {

        /** The variable's register.

         */

        int reg;

        /** The variable's type.

         */

        Type type;

        LocalItem(Type type, int reg) {

            super(Code.typecode(type));

            Assert.check(reg >= 0);

            this.type = type;

            this.reg = reg;

        }

        Item load() {

            if (reg <= 3)

                code.emitop0(iload_0 + Code.truncate(typecode) * 4 + reg);

            else

                code.emitop1w(iload + Code.truncate(typecode), reg);

            return stackItem[typecode];

        }

        void store() {

            if (reg <= 3)

                code.emitop0(istore_0 + Code.truncate(typecode) * 4 + reg);

            else

                code.emitop1w(istore + Code.truncate(typecode), reg);

            code.setDefined(reg);

        }

        void incr(int x) {

            if (typecode == INTcode && x >= -32768 && x <= 32767) {

                code.emitop1w(iinc, reg, x);

            } else {

                load();

                if (x >= 0) {

                    makeImmediateItem(syms.intType, x).load();

                    code.emitop0(iadd);

                } else {

                    makeImmediateItem(syms.intType, -x).load();

                    code.emitop0(isub);

                }

                makeStackItem(syms.intType).coerce(typecode);

                store();

            }

        }

        public String toString() {

            return "localItem(type=" + type + "; reg=" + reg + ")";

        }

    }

    /** An item representing a static variable or method.

     */

    class StaticItem extends Item {

        /** The represented symbol.

         */

        Symbol member;

        StaticItem(Symbol member) {

            super(Code.typecode(member.erasure(types)));

            this.member = member;

        }

        Item load() {

            code.emitop2(getstatic, pool.put(member));

            return stackItem[typecode];

        }

        void store() {

            code.emitop2(putstatic, pool.put(member));

        }

        Item invoke() {

            MethodType mtype = (MethodType)member.erasure(types);

            int rescode = Code.typecode(mtype.restype);

            code.emitInvokestatic(pool.put(member), mtype);

            return stackItem[rescode];

        }

        public String toString() {

            return "static(" + member + ")";

        }

    }

    /** An item representing a dynamic call site.

     */

    class DynamicItem extends StaticItem {

        DynamicItem(Symbol member) {

            super(member);

        }

        Item load() {

            assert false;

            return null;

        }

        void store() {

            assert false;

        }

        Item invoke() {

            // assert target.hasNativeInvokeDynamic();

            MethodType mtype = (MethodType)member.erasure(types);

            int rescode = Code.typecode(mtype.restype);

            code.emitInvokedynamic(pool.put(member), mtype);

            return stackItem[rescode];

        }

        public String toString() {

            return "dynamic(" + member + ")";

        }

    }

    /** An item representing an instance variable or method.

     */

    class MemberItem extends Item {

        /** The represented symbol.

         */

        Symbol member;

        /** Flag that determines whether or not access is virtual.

         */

        boolean nonvirtual;

        MemberItem(Symbol member, boolean nonvirtual) {

            super(Code.typecode(member.erasure(types)));

            this.member = member;

            this.nonvirtual = nonvirtual;

        }

        Item load() {

            code.emitop2(getfield, pool.put(member));

            return stackItem[typecode];

        }

        void store() {

            code.emitop2(putfield, pool.put(member));

        }

        Item invoke() {

            MethodType mtype = (MethodType)member.externalType(types);