compiler/src/org/apache/flex/abc/semantics/Instruction.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 java.lang.reflect.Field;
import java.util.Map;
import java.util.HashMap;

import org.apache.flex.abc.ABCConstants;

/**
 * A representation of an ABC instruction.
 * Note that an instance of Instruction may be shared or reused.
 */
public abstract class Instruction
{
    /*
     * Opcode mappings extracted from ABCConstants
     */
    private static Map<String, Integer> opcodeNameToOpcode;
    private static Map<Integer, String> opcodeToOpcodeName;

    //  Populate the opcode maps.
    static
    {
        opcodeNameToOpcode = new HashMap<String, Integer>();
        opcodeToOpcodeName = new HashMap<Integer, String>();
        loadOpcodes();
    }

    /**
     * Decode an opcode name into a numeric constant.
     * 
     * @param opcodeName - the name of the opcode.
     * @return the opcode's value, or -1 if it's not an opcode.
     */
    public static int decodeOpcodeName(String opcodeName)
    {
        String opcodeKey = opcodeName.toLowerCase();

        if (opcodeNameToOpcode.size() == 0)
            loadOpcodes();

        if (opcodeNameToOpcode.containsKey(opcodeKey))
            return opcodeNameToOpcode.get(opcodeKey);
        else
            return -1;
    }

    /**
     * Get the symbolic name of an opcode.
     * 
     * @return the opcode's symbolic name, or a hex representation if none
     * exists.
     */
    public static String decodeOp(int opcode)
    {
        if (opcodeToOpcodeName.containsKey(opcode))
            return opcodeToOpcodeName.get(opcode);
        else
            return "OP_" + Integer.toHexString(opcode);
    }

    /**
     * Look at fields of ABCConstants and get the mappings of OP_foo names to
     * their values.
     */
    private static void loadOpcodes()
    {
        //  Traverse the names of the OP_foo constants
        //  in ABCConstants and load their values.
        for (Field f : ABCConstants.class.getFields())
        {
            String field_name = f.getName();

            if (field_name.startsWith("OP_"))
            {
                String opcode = field_name.substring(3);
                try
                {
                    int field_value = f.getInt(null);
                    opcodeNameToOpcode.put(opcode, field_value);
                    opcodeToOpcodeName.put(field_value, opcode);
                }
                catch (Exception noFieldValue)
                {
                    //  Ignore, continue...
                }

            }
        }
    }

    /**
     * Constructor.
     */
    protected Instruction(int opcode)
    {
        this.opcode = opcode;
    }

    /**
     * @see ABCConstants
     */
    protected int opcode;

    /**
     * @return this instruction's opcode.
     * @see ABCConstants for opcodes.
     */
    public int getOpcode()
    {
        return this.opcode;
    }

    /**
     * determine if instruction has immediate operands.
     * 
     * @return true if the instruction has an immediate operand.
     */
    public boolean isImmediate()
    {
        return false;
    }

    /**
     * @return this Instruction's immediate operand.
     */
    public int getImmediate()
    {
        unsupported("%s has no immediate operand.");
        return -1;
    }

    /**
     * Get the target of a branch instruction.
     * 
     * @return the target label, or null if not present.
     */
    public Label getTarget()
    {
        return null;
    }

    /**
     * Set the target of a branch instruction.
     * 
     * @param target - the AET Label this instruction targets.
     */
    public void setTarget(Label target)
    {
        unsupported("Cannot set target on %s");
    }

    /**
     * Get one of the instruction's non-immediate operands.
     * 
     * @param index - the index of the desired operand.
     * @return the operand at the given index.
     * @throws IllegalStateException if the instruction has no operands.
     */
    public Object getOperand(int index)
    {
        unsupported("%s has no operands");
        return null;
    }

    /**
     * @return the number of operands this instruction has.
     */
    public int getOperandCount()
    {
        return 0;
    }

    /**
     * @return true if this instruction has operands (it may have zero operands,
     * but it supports them).
     */
    public boolean hasOperands()
    {
        return false;
    }

    /**
     * Set this Instruction's operands.
     * 
     * @pre hasOperands() must be true.
     */
    public void setOperands(Object[] operands)
    {
        unsupported("%s has no operands");
    }

    /**
     * Is this a branch instruction?
     * 
     * @return true if the instruction is a branch.
     */
    public boolean isBranch()
    {
        return ABCConstants.OP_lookupswitch == getOpcode() || getTarget() != null;
    }

    /**
     * Is this one of the return instructions?
     * 
     * @return true if this instruction is one of the return instructions
     */
    public boolean isReturn()
    {
        int opcode = getOpcode();
        return ABCConstants.OP_returnvalue == opcode || ABCConstants.OP_returnvoid == opcode;
    }

    /**
     *  Is this a transfer of control?
     *  @return true if isBranch() or isReturn() is true, or the opcode is OP_throw.
     */
    public boolean isTransferOfControl()
    {
        return isBranch() || isReturn() || ABCConstants.OP_throw == opcode;
    }

    /**
     * Set the immediate field of a local register access instruction.
     * 
     * @pre only valid for get/set/inc/declocal, hasnext, and kill.
     */
    public void setImmediate(final int immediate)
    {
        unsupported("%s has no immediate operand.");
    }

    /**
     * Set the temporary register operands of a hasnext2 instruction.
     */
    public void setTempRegisters(Object[] tempregs)
    {
        unsupported("cannot set temp registers of %s");
    }

    /**
     * @return true if this instruction is an executable (non-debug)
     * instruction.
     */
    public boolean isExecutable()
    {
        return this.opcode != ABCConstants.OP_debugline && this.opcode != ABCConstants.OP_debugfile;
    }

    /**
     * Test whether this instructions opcode is targetable
     * 
     * @return true if the instructions opcode is targetable
     */
    public boolean isTargetableInstruction()
    {
        switch (opcode)
        {
            case ABCConstants.OP_ifnlt:
            case ABCConstants.OP_ifnle:
            case ABCConstants.OP_ifngt:
            case ABCConstants.OP_ifnge:
            case ABCConstants.OP_iftrue:
            case ABCConstants.OP_iffalse:
            case ABCConstants.OP_ifeq:
            case ABCConstants.OP_ifne:
            case ABCConstants.OP_iflt:
            case ABCConstants.OP_ifle:
            case ABCConstants.OP_ifgt:
            case ABCConstants.OP_ifge:
            case ABCConstants.OP_ifstricteq:
            case ABCConstants.OP_ifstrictne:
            case ABCConstants.OP_jump:
            case ABCConstants.OP_lookupswitch:
                return true;
        }

        return false;
    }

    /**
     * @return a string representation of the opcode.
     */
    @Override
    public String toString()
    {
        return decodeOp(opcode);
    }

    protected void unsupported(String diagnostic)
    {
        throw new UnsupportedOperationException(String.format(diagnostic, toString()));
    }
}