compiler/src/org/apache/flex/abc/semantics/InstructionFactory.java

/*
 *
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 */

package org.apache.flex.abc.semantics;

import static org.apache.flex.abc.ABCConstants.*;

/**
 * The InstructionFactory creates implementation Instruction subclasses for
 * particular types of Instructions, and also handles caching and pooling of
 * shared Instructions.
 */
public abstract class InstructionFactory
{
    /*
     * Singleton instructions. Any Instruction without operands can be shared as
     * a singleton.
     */
    private static final Instruction s_add = new NoOperandsInstruction(OP_add);
    private static final Instruction s_astypelate = new NoOperandsInstruction(OP_astypelate);
    private static final Instruction s_bitand = new NoOperandsInstruction(OP_bitand);
    private static final Instruction s_bitnot = new NoOperandsInstruction(OP_bitnot);
    private static final Instruction s_bitor = new NoOperandsInstruction(OP_bitor);
    private static final Instruction s_bitxor = new NoOperandsInstruction(OP_bitxor);
    private static final Instruction s_checkfilter = new NoOperandsInstruction(OP_checkfilter);
    private static final Instruction s_coerce = new NoOperandsInstruction(OP_coerce);
    private static final Instruction s_coerce_a = new NoOperandsInstruction(OP_coerce_a);
    private static final Instruction s_coerce_s = new NoOperandsInstruction(OP_coerce_s);
    private static final Instruction s_convert_b = new NoOperandsInstruction(OP_convert_b);
    private static final Instruction s_convert_d = new NoOperandsInstruction(OP_convert_d);
    private static final Instruction s_convert_i = new NoOperandsInstruction(OP_convert_i);
    private static final Instruction s_convert_o = new NoOperandsInstruction(OP_convert_o);
    private static final Instruction s_convert_s = new NoOperandsInstruction(OP_convert_s);
    private static final Instruction s_convert_u = new NoOperandsInstruction(OP_convert_u);
    private static final Instruction s_decrement = new NoOperandsInstruction(OP_decrement);
    private static final Instruction s_decrement_i = new NoOperandsInstruction(OP_decrement_i);
    private static final Instruction s_divide = new NoOperandsInstruction(OP_divide);
    private static final Instruction s_dup = new NoOperandsInstruction(OP_dup);
    private static final Instruction s_dxnslate = new NoOperandsInstruction(OP_dxnslate);
    private static final Instruction s_equals = new NoOperandsInstruction(OP_equals);
    private static final Instruction s_esc_xattr = new NoOperandsInstruction(OP_esc_xattr);
    private static final Instruction s_esc_xelem = new NoOperandsInstruction(OP_esc_xelem);
    private static final Instruction s_getglobalscope = new NoOperandsInstruction(OP_getglobalscope);
    private static final Instruction s_getlocal0 = new NoOperandsInstruction(OP_getlocal0);
    private static final Instruction s_getlocal1 = new NoOperandsInstruction(OP_getlocal1);
    private static final Instruction s_getlocal2 = new NoOperandsInstruction(OP_getlocal2);
    private static final Instruction s_getlocal3 = new NoOperandsInstruction(OP_getlocal3);
    private static final Instruction s_greaterequals = new NoOperandsInstruction(OP_greaterequals);
    private static final Instruction s_greaterthan = new NoOperandsInstruction(OP_greaterthan);
    private static final Instruction s_hasnext = new NoOperandsInstruction(OP_hasnext);
    private static final Instruction s_in = new NoOperandsInstruction(OP_in);
    private static final Instruction s_increment = new NoOperandsInstruction(OP_increment);
    private static final Instruction s_increment_i = new NoOperandsInstruction(OP_increment_i);
    private static final Instruction s_instanceof = new NoOperandsInstruction(OP_instanceof);
    private static final Instruction s_istypelate = new NoOperandsInstruction(OP_istypelate);
    private static final Instruction s_label = new NoOperandsInstruction(OP_label);
    private static final Instruction s_lessequals = new NoOperandsInstruction(OP_lessequals);
    private static final Instruction s_lessthan = new NoOperandsInstruction(OP_lessthan);
    private static final Instruction s_lshift = new NoOperandsInstruction(OP_lshift);
    private static final Instruction s_modulo = new NoOperandsInstruction(OP_modulo);
    private static final Instruction s_multiply = new NoOperandsInstruction(OP_multiply);
    private static final Instruction s_multiply_i = new NoOperandsInstruction(OP_multiply_i);
    private static final Instruction s_negate = new NoOperandsInstruction(OP_negate);
    private static final Instruction s_negate_i = new NoOperandsInstruction(OP_negate_i);
    private static final Instruction s_newactivation = new NoOperandsInstruction(OP_newactivation);
    private static final Instruction s_nextname = new NoOperandsInstruction(OP_nextname);
    private static final Instruction s_nextvalue = new NoOperandsInstruction(OP_nextvalue);
    private static final Instruction s_nop = new NoOperandsInstruction(OP_nop);
    private static final Instruction s_not = new NoOperandsInstruction(OP_not);
    private static final Instruction s_pop = new NoOperandsInstruction(OP_pop);
    private static final Instruction s_popscope = new NoOperandsInstruction(OP_popscope);
    private static final Instruction s_pushfalse = new NoOperandsInstruction(OP_pushfalse);
    private static final Instruction s_pushnan = new NoOperandsInstruction(OP_pushnan);
    private static final Instruction s_pushnull = new NoOperandsInstruction(OP_pushnull);
    private static final Instruction s_pushscope = new NoOperandsInstruction(OP_pushscope);
    private static final Instruction s_pushtrue = new NoOperandsInstruction(OP_pushtrue);
    private static final Instruction s_pushundefined = new NoOperandsInstruction(OP_pushundefined);
    private static final Instruction s_pushwith = new NoOperandsInstruction(OP_pushwith);
    private static final Instruction s_returnvalue = new NoOperandsInstruction(OP_returnvalue);
    private static final Instruction s_returnvoid = new NoOperandsInstruction(OP_returnvoid);
    private static final Instruction s_rshift = new NoOperandsInstruction(OP_rshift);
    private static final Instruction s_setlocal0 = new NoOperandsInstruction(OP_setlocal0);
    private static final Instruction s_setlocal1 = new NoOperandsInstruction(OP_setlocal1);
    private static final Instruction s_setlocal2 = new NoOperandsInstruction(OP_setlocal2);
    private static final Instruction s_setlocal3 = new NoOperandsInstruction(OP_setlocal3);
    private static final Instruction s_strictequals = new NoOperandsInstruction(OP_strictequals);
    private static final Instruction s_subtract = new NoOperandsInstruction(OP_subtract);
    private static final Instruction s_subtract_i = new NoOperandsInstruction(OP_subtract_i);
    private static final Instruction s_swap = new NoOperandsInstruction(OP_swap);
    private static final Instruction s_throw = new NoOperandsInstruction(OP_throw);
    private static final Instruction s_typeof = new NoOperandsInstruction(OP_typeof);
    private static final Instruction s_urshift = new NoOperandsInstruction(OP_urshift);
    private static final Instruction s_unplus = new NoOperandsInstruction(OP_unplus);

    private static final Object[] NO_OPERANDS = new Object[0];

    /**
     * @return the singleton instance of an instruction with no operands, or a
     * "blank" instruction whose operands are to be filled in.
     */
    public static final Instruction getInstruction(int opcode)
    {
        switch (opcode)
        {
            case OP_add:
                return s_add;
            case OP_astypelate:
                return s_astypelate;
            case OP_bitand:
                return s_bitand;
            case OP_bitnot:
                return s_bitnot;
            case OP_bitor:
                return s_bitor;
            case OP_bitxor:
                return s_bitxor;
            case OP_checkfilter:
                return s_checkfilter;
            case OP_coerce:
                return s_coerce;
            case OP_coerce_a:
                return s_coerce_a;
            case OP_coerce_s:
                return s_coerce_s;
            case OP_convert_b:
                return s_convert_b;
            case OP_convert_d:
                return s_convert_d;
            case OP_convert_i:
                return s_convert_i;
            case OP_convert_o:
                return s_convert_o;
            case OP_convert_s:
                return s_convert_s;
            case OP_convert_u:
                return s_convert_u;
            case OP_decrement:
                return s_decrement;
            case OP_decrement_i:
                return s_decrement_i;
            case OP_divide:
                return s_divide;
            case OP_dup:
                return s_dup;
            case OP_dxnslate:
                return s_dxnslate;
            case OP_equals:
                return s_equals;
            case OP_esc_xattr:
                return s_esc_xattr;
            case OP_esc_xelem:
                return s_esc_xelem;
            case OP_getglobalscope:
                return s_getglobalscope;
            case OP_getlocal0:
                return s_getlocal0;
            case OP_getlocal1:
                return s_getlocal1;
            case OP_getlocal2:
                return s_getlocal2;
            case OP_getlocal3:
                return s_getlocal3;
            case OP_greaterequals:
                return s_greaterequals;
            case OP_greaterthan:
                return s_greaterthan;
            case OP_hasnext:
                return s_hasnext;
            case OP_in:
                return s_in;
            case OP_increment:
                return s_increment;
            case OP_increment_i:
                return s_increment_i;
            case OP_instanceof:
                return s_instanceof;
            case OP_istypelate:
                return s_istypelate;
            case OP_label:
                return s_label;
            case OP_lessequals:
                return s_lessequals;
            case OP_lessthan:
                return s_lessthan;
            case OP_lshift:
                return s_lshift;
            case OP_modulo:
                return s_modulo;
            case OP_multiply:
                return s_multiply;
            case OP_multiply_i:
                return s_multiply_i;
            case OP_negate:
                return s_negate;
            case OP_negate_i:
                return s_negate_i;
            case OP_newactivation:
                return s_newactivation;
            case OP_nextname:
                return s_nextname;
            case OP_nextvalue:
                return s_nextvalue;
            case OP_nop:
                return s_nop;
            case OP_not:
                return s_not;
            case OP_pop:
                return s_pop;
            case OP_popscope:
                return s_popscope;
            case OP_pushfalse:
                return s_pushfalse;
            case OP_pushnan:
                return s_pushnan;
            case OP_pushnull:
                return s_pushnull;
            case OP_pushscope:
                return s_pushscope;
            case OP_pushtrue:
                return s_pushtrue;
            case OP_pushundefined:
                return s_pushundefined;
            case OP_pushwith:
                return s_pushwith;
            case OP_returnvalue:
                return s_returnvalue;
            case OP_returnvoid:
                return s_returnvoid;
            case OP_rshift:
                return s_rshift;
            case OP_setlocal0:
                return s_setlocal0;
            case OP_setlocal1:
                return s_setlocal1;
            case OP_setlocal2:
                return s_setlocal2;
            case OP_setlocal3:
                return s_setlocal3;
            case OP_strictequals:
                return s_strictequals;
            case OP_subtract:
                return s_subtract;
            case OP_subtract_i:
                return s_subtract_i;
            case OP_swap:
                return s_swap;
            case OP_throw:
                return s_throw;
            case OP_typeof:
                return s_typeof;
            case OP_urshift:
                return s_urshift;
            case OP_unplus:
                return s_unplus;
            default:
                //  TODO: This can be tightened up by isolating the
                //  instructions that require a "blank" instruction
                //  (find/get/set/deleteproperty variants) and 
                //  asserting on others.
                return new ArbitraryOperandsInstruction(opcode, NO_OPERANDS);
        }
    }

    /**
     * @return an Instruction with an immediate operand.
     */
    public static final Instruction getInstruction(int opcode, int immediate)
    {
        return new ImmediateOperandInstruction(opcode, immediate);
    }

    /**
     * @return an immediate-operand instruction in cases where the immediate
     * operand is not yet known.
     */
    public static final Instruction getDeferredImmediateInstruction(int opcode)
    {
        return new ImmediateOperandInstruction(opcode);
    }

    /**
     * @return an Instruction with a single operand.
     */
    public static final Instruction getInstruction(int opcode, Object singleOperand)
    {
        return new OneOperandInstruction(opcode, singleOperand);
    }

    /**
     * @return a single-operand instruction, with the operand TBA.
     */
    public static final Instruction getTargetableInstruction(int opcode)
    {
        return new OneOperandInstruction(opcode);
    }

    /**
     * @return an Instruction with an arbitrary number of operands.
     */
    public static final Instruction getInstruction(int opcode, Object[] operands)
    {
        return new ArbitraryOperandsInstruction(opcode, operands);
    }

    /**
     * @return a hasNext2 instruction.
     */
    public static final Instruction getHasnext2Instruction()
    {
        return new ArbitraryOperandsInstruction(OP_hasnext2, NO_OPERANDS);
    }

    /**
     * Copy an instruction's operands as necessary and substitute a new opcode.
     * 
     * @param opcode - the opcode required.
     * @param original - the original instruction.
     * @return an instruction with the original instruction's operands, whatever
     * they may be, and the specified novel opcode.
     */
    public static final Instruction createModifiedInstruction(int opcode, Instruction original)
    {
        if (original instanceof ArbitraryOperandsInstruction)
            return new ArbitraryOperandsInstruction(opcode, (ArbitraryOperandsInstruction)original);

        else if (original instanceof OneOperandInstruction)
            return getInstruction(opcode, original.getOperand(0));

        else if (original instanceof ImmediateOperandInstruction)
            return getInstruction(opcode, original.getImmediate());

        else
             return getInstruction(opcode);
    }
}