/*

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

 */

/*

 * This file is available under and governed by the GNU General Public

 * License version 2 only, as published by the Free Software Foundation.

 * However, the following notice accompanied the original version of this

 * file:

 *

 * ASM: a very small and fast Java bytecode manipulation framework

 * Copyright (c) 2000-2011 INRIA, France Telecom

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. Neither the name of the copyright holders nor the names of its

 *    contributors may be used to endorse or promote products derived from

 *    this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

package jdk.internal.org.objectweb.asm.commons;

import jdk.internal.org.objectweb.asm.Handle;

import jdk.internal.org.objectweb.asm.Label;

import jdk.internal.org.objectweb.asm.MethodVisitor;

import jdk.internal.org.objectweb.asm.Opcodes;

import jdk.internal.org.objectweb.asm.Type;

/**

 * A {@link MethodVisitor} providing a more detailed API to generate and

 * transform instructions.

 *

 * @author Eric Bruneton

 */

public class InstructionAdapter extends MethodVisitor {

    /**

     * Creates a new {@link InstructionAdapter}. <i>Subclasses must not use this

     * constructor</i>. Instead, they must use the

     * {@link #InstructionAdapter(int, MethodVisitor)} version.

     *

     * @param mv

     *            the method visitor to which this adapter delegates calls.

     * @throws IllegalStateException

     *             If a subclass calls this constructor.

     */

    public InstructionAdapter(final MethodVisitor mv) {

        this(Opcodes.ASM5, mv);

        if (getClass() != InstructionAdapter.class) {

            throw new IllegalStateException();

        }

    }

    /**

     * Creates a new {@link InstructionAdapter}.

     *

     * @param api

     *            the ASM API version implemented by this visitor. Must be one

     *            of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}.

     * @param mv

     *            the method visitor to which this adapter delegates calls.

     */

    protected InstructionAdapter(final int api, final MethodVisitor mv) {

        super(api, mv);

    }

    @Override

    public void visitInsn(final int opcode) {

        switch (opcode) {

        case Opcodes.NOP:

            nop();

            break;

        case Opcodes.ACONST_NULL:

            aconst(null);

            break;

        case Opcodes.ICONST_M1:

        case Opcodes.ICONST_0:

        case Opcodes.ICONST_1:

        case Opcodes.ICONST_2:

        case Opcodes.ICONST_3:

        case Opcodes.ICONST_4:

        case Opcodes.ICONST_5:

            iconst(opcode - Opcodes.ICONST_0);

            break;

        case Opcodes.LCONST_0:

        case Opcodes.LCONST_1:

            lconst(opcode - Opcodes.LCONST_0);

            break;

        case Opcodes.FCONST_0:

        case Opcodes.FCONST_1:

        case Opcodes.FCONST_2:

            fconst(opcode - Opcodes.FCONST_0);

            break;

        case Opcodes.DCONST_0:

        case Opcodes.DCONST_1:

            dconst(opcode - Opcodes.DCONST_0);

            break;

        case Opcodes.IALOAD:

            aload(Type.INT_TYPE);

            break;

        case Opcodes.LALOAD:

            aload(Type.LONG_TYPE);

            break;

        case Opcodes.FALOAD:

            aload(Type.FLOAT_TYPE);

            break;

        case Opcodes.DALOAD:

            aload(Type.DOUBLE_TYPE);

            break;

        case Opcodes.AALOAD:

            aload(OBJECT_TYPE);

            break;

        case Opcodes.BALOAD:

            aload(Type.BYTE_TYPE);

            break;

        case Opcodes.CALOAD:

            aload(Type.CHAR_TYPE);

            break;

        case Opcodes.SALOAD:

            aload(Type.SHORT_TYPE);

            break;

        case Opcodes.IASTORE:

            astore(Type.INT_TYPE);

            break;

        case Opcodes.LASTORE:

            astore(Type.LONG_TYPE);

            break;

        case Opcodes.FASTORE:

            astore(Type.FLOAT_TYPE);

            break;

        case Opcodes.DASTORE:

            astore(Type.DOUBLE_TYPE);

            break;

        case Opcodes.AASTORE:

            astore(OBJECT_TYPE);

            break;

        case Opcodes.BASTORE:

            astore(Type.BYTE_TYPE);

            break;

        case Opcodes.CASTORE:

            astore(Type.CHAR_TYPE);

            break;

        case Opcodes.SASTORE:

            astore(Type.SHORT_TYPE);

            break;

        case Opcodes.POP:

            pop();

            break;

        case Opcodes.POP2:

            pop2();

            break;

        case Opcodes.DUP:

            dup();

            break;

        case Opcodes.DUP_X1:

            dupX1();

            break;

        case Opcodes.DUP_X2:

            dupX2();

            break;

        case Opcodes.DUP2:

            dup2();

            break;

        case Opcodes.DUP2_X1:

            dup2X1();

            break;

        case Opcodes.DUP2_X2:

            dup2X2();

            break;

        case Opcodes.SWAP:

            swap();

            break;

        case Opcodes.IADD:

            add(Type.INT_TYPE);

            break;

        case Opcodes.LADD:

            add(Type.LONG_TYPE);

            break;

        case Opcodes.FADD:

            add(Type.FLOAT_TYPE);

            break;

        case Opcodes.DADD:

            add(Type.DOUBLE_TYPE);

            break;

        case Opcodes.ISUB:

            sub(Type.INT_TYPE);

            break;

        case Opcodes.LSUB:

            sub(Type.LONG_TYPE);

            break;

        case Opcodes.FSUB:

            sub(Type.FLOAT_TYPE);

            break;

        case Opcodes.DSUB:

            sub(Type.DOUBLE_TYPE);

            break;

        case Opcodes.IMUL:

            mul(Type.INT_TYPE);

            break;

        case Opcodes.LMUL:

            mul(Type.LONG_TYPE);

            break;

        case Opcodes.FMUL:

            mul(Type.FLOAT_TYPE);

            break;

        case Opcodes.DMUL:

            mul(Type.DOUBLE_TYPE);

            break;

        case Opcodes.IDIV:

            div(Type.INT_TYPE);

            break;

        case Opcodes.LDIV:

            div(Type.LONG_TYPE);

            break;

        case Opcodes.FDIV:

            div(Type.FLOAT_TYPE);

            break;

        case Opcodes.DDIV:

            div(Type.DOUBLE_TYPE);

            break;

        case Opcodes.IREM:

            rem(Type.INT_TYPE);

            break;

        case Opcodes.LREM:

            rem(Type.LONG_TYPE);

            break;

        case Opcodes.FREM:

            rem(Type.FLOAT_TYPE);

            break;

        case Opcodes.DREM:

            rem(Type.DOUBLE_TYPE);

            break;

        case Opcodes.INEG:

            neg(Type.INT_TYPE);

            break;

        case Opcodes.LNEG:

            neg(Type.LONG_TYPE);

            break;

        case Opcodes.FNEG:

            neg(Type.FLOAT_TYPE);

            break;

        case Opcodes.DNEG:

            neg(Type.DOUBLE_TYPE);

            break;

        case Opcodes.ISHL:

            shl(Type.INT_TYPE);

            break;

        case Opcodes.LSHL:

            shl(Type.LONG_TYPE);

            break;

        case Opcodes.ISHR:

            shr(Type.INT_TYPE);

            break;

        case Opcodes.LSHR:

            shr(Type.LONG_TYPE);

            break;

        case Opcodes.IUSHR:

            ushr(Type.INT_TYPE);

            break;

        case Opcodes.LUSHR:

            ushr(Type.LONG_TYPE);

            break;

        case Opcodes.IAND:

            and(Type.INT_TYPE);

            break;

        case Opcodes.LAND:

            and(Type.LONG_TYPE);

            break;

        case Opcodes.IOR:

            or(Type.INT_TYPE);

            break;

        case Opcodes.LOR:

            or(Type.LONG_TYPE);

            break;

        case Opcodes.IXOR:

            xor(Type.INT_TYPE);

            break;

        case Opcodes.LXOR:

            xor(Type.LONG_TYPE);

            break;

        case Opcodes.I2L:

            cast(Type.INT_TYPE, Type.LONG_TYPE);

            break;

        case Opcodes.I2F:

            cast(Type.INT_TYPE, Type.FLOAT_TYPE);

            break;

        case Opcodes.I2D:

            cast(Type.INT_TYPE, Type.DOUBLE_TYPE);

            break;

        case Opcodes.L2I:

            cast(Type.LONG_TYPE, Type.INT_TYPE);

            break;

        case Opcodes.L2F:

            cast(Type.LONG_TYPE, Type.FLOAT_TYPE);

            break;

        case Opcodes.L2D:

            cast(Type.LONG_TYPE, Type.DOUBLE_TYPE);

            break;

        case Opcodes.F2I:

            cast(Type.FLOAT_TYPE, Type.INT_TYPE);

            break;

        case Opcodes.F2L:

            cast(Type.FLOAT_TYPE, Type.LONG_TYPE);

            break;

        case Opcodes.F2D:

            cast(Type.FLOAT_TYPE, Type.DOUBLE_TYPE);

            break;

        case Opcodes.D2I:

            cast(Type.DOUBLE_TYPE, Type.INT_TYPE);

            break;

        case Opcodes.D2L:

            cast(Type.DOUBLE_TYPE, Type.LONG_TYPE);

            break;

        case Opcodes.D2F:

            cast(Type.DOUBLE_TYPE, Type.FLOAT_TYPE);

            break;

        case Opcodes.I2B:

            cast(Type.INT_TYPE, Type.BYTE_TYPE);

            break;

        case Opcodes.I2C:

            cast(Type.INT_TYPE, Type.CHAR_TYPE);

            break;

        case Opcodes.I2S:

            cast(Type.INT_TYPE, Type.SHORT_TYPE);

            break;

        case Opcodes.LCMP:

            lcmp();

            break;

        case Opcodes.FCMPL:

            cmpl(Type.FLOAT_TYPE);

            break;

        case Opcodes.FCMPG:

            cmpg(Type.FLOAT_TYPE);

            break;

        case Opcodes.DCMPL:

            cmpl(Type.DOUBLE_TYPE);

            break;

        case Opcodes.DCMPG:

            cmpg(Type.DOUBLE_TYPE);

            break;

        case Opcodes.IRETURN:

            areturn(Type.INT_TYPE);

            break;

        case Opcodes.LRETURN:

            areturn(Type.LONG_TYPE);

            break;

        case Opcodes.FRETURN:

            areturn(Type.FLOAT_TYPE);

            break;

        case Opcodes.DRETURN:

            areturn(Type.DOUBLE_TYPE);

            break;

        case Opcodes.ARETURN:

            areturn(OBJECT_TYPE);

            break;

        case Opcodes.RETURN:

            areturn(Type.VOID_TYPE);

            break;

        case Opcodes.ARRAYLENGTH:

            arraylength();

            break;

        case Opcodes.ATHROW:

            athrow();

            break;

        case Opcodes.MONITORENTER:

            monitorenter();

            break;

        case Opcodes.MONITOREXIT:

            monitorexit();

            break;

        default:

            throw new IllegalArgumentException();

        }

    }

    @Override

    public void visitIntInsn(final int opcode, final int operand) {

        switch (opcode) {

        case Opcodes.BIPUSH:

            iconst(operand);

            break;

        case Opcodes.SIPUSH:

            iconst(operand);

            break;

        case Opcodes.NEWARRAY:

            switch (operand) {

            case Opcodes.T_BOOLEAN:

                newarray(Type.BOOLEAN_TYPE);

                break;

            case Opcodes.T_CHAR:

                newarray(Type.CHAR_TYPE);

                break;

            case Opcodes.T_BYTE:

                newarray(Type.BYTE_TYPE);

                break;

            case Opcodes.T_SHORT:

                newarray(Type.SHORT_TYPE);

                break;

            case Opcodes.T_INT:

                newarray(Type.INT_TYPE);

                break;

            case Opcodes.T_FLOAT:

                newarray(Type.FLOAT_TYPE);

                break;

            case Opcodes.T_LONG:

                newarray(Type.LONG_TYPE);

                break;

            case Opcodes.T_DOUBLE:

                newarray(Type.DOUBLE_TYPE);

                break;

            default:

                throw new IllegalArgumentException();

            }

            break;

        default:

            throw new IllegalArgumentException();

        }

    }

    @Override

    public void visitVarInsn(final int opcode, final int var) {

        switch (opcode) {

        case Opcodes.ILOAD:

            load(var, Type.INT_TYPE);

            break;

        case Opcodes.LLOAD:

            load(var, Type.LONG_TYPE);

            break;

        case Opcodes.FLOAD:

            load(var, Type.FLOAT_TYPE);

            break;

        case Opcodes.DLOAD:

            load(var, Type.DOUBLE_TYPE);

            break;

        case Opcodes.ALOAD:

            load(var, OBJECT_TYPE);

            break;

        case Opcodes.ISTORE:

            store(var, Type.INT_TYPE);

            break;

        case Opcodes.LSTORE:

            store(var, Type.LONG_TYPE);

            break;

        case Opcodes.FSTORE:

            store(var, Type.FLOAT_TYPE);

            break;

        case Opcodes.DSTORE:

            store(var, Type.DOUBLE_TYPE);

            break;

        case Opcodes.ASTORE:

            store(var, OBJECT_TYPE);

            break;

        case Opcodes.RET:

            ret(var);

            break;

        default:

            throw new IllegalArgumentException();

        }

    }