package org.aspectj.apache.bcel.generic;

/* ====================================================================
 * The Apache Software License, Version 1.1
 *
 * Copyright (c) 2001 The Apache Software Foundation.  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. The end-user documentation included with the redistribution,
 *    if any, must include the following acknowledgment:
 *       "This product includes software developed by the
 *        Apache Software Foundation (http://www.apache.org/)."
 *    Alternately, this acknowledgment may appear in the software itself,
 *    if and wherever such third-party acknowledgments normally appear.
 *
 * 4. The names "Apache" and "Apache Software Foundation" and
 *    "Apache BCEL" must not be used to endorse or promote products
 *    derived from this software without prior written permission. For
 *    written permission, please contact apache@apache.org.
 *
 * 5. Products derived from this software may not be called "Apache",
 *    "Apache BCEL", nor may "Apache" appear in their name, without
 *    prior written permission of the Apache Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 APACHE SOFTWARE FOUNDATION OR
 * ITS 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.
 * ====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of the Apache Software Foundation.  For more
 * information on the Apache Software Foundation, please see
 * <http://www.apache.org/>.
 */
import java.io.DataOutputStream;
import java.io.IOException;

import org.aspectj.apache.bcel.Constants;

/**
 * Abstract super class for instructions dealing with local variables.
 * 
 * @version $Id: InstructionLV.java,v 1.5 2009/10/05 17:35:36 aclement Exp $
 * @author <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>
 */
public class InstructionLV extends Instruction {
	protected int lvar = -1;

	public InstructionLV(short opcode, int lvar) {
		super(opcode);
		this.lvar = lvar;
	}

	public InstructionLV(short opcode) {
		super(opcode);
	}

	public void dump(DataOutputStream out) throws IOException {
		if (lvar == -1) {
			out.writeByte(opcode);
		} else {
			if (lvar < 4) {
				if (opcode == ALOAD) {
					out.writeByte(ALOAD_0 + lvar);
				} else if (opcode == ASTORE) {
					out.writeByte(ASTORE_0 + lvar);
				} else if (opcode == ILOAD) {
					out.writeByte(ILOAD_0 + lvar);
				} else if (opcode == ISTORE) {
					out.writeByte(ISTORE_0 + lvar);
				} else if (opcode == DLOAD) {
					out.writeByte(DLOAD_0 + lvar);
				} else if (opcode == DSTORE) {
					out.writeByte(DSTORE_0 + lvar);
				} else if (opcode == FLOAD) {
					out.writeByte(FLOAD_0 + lvar);
				} else if (opcode == FSTORE) {
					out.writeByte(FSTORE_0 + lvar);
				} else if (opcode == LLOAD) {
					out.writeByte(LLOAD_0 + lvar);
				} else if (opcode == LSTORE) {
					out.writeByte(LSTORE_0 + lvar);
				} else {
					if (wide()) {
						out.writeByte(Constants.WIDE);
					}
					out.writeByte(opcode);
					if (wide()) {
						out.writeShort(lvar);
					} else {
						out.writeByte(lvar);
					}
				}
			} else {
				if (wide()) {
					out.writeByte(Constants.WIDE);
				}
				out.writeByte(opcode);
				if (wide()) {
					out.writeShort(lvar);
				} else {
					out.writeByte(lvar);
				}
			}
		}
	}

	/**
	 * Long output format:
	 * 
	 * 'name of opcode' "[" 'opcode number' "]" "(" 'length of instruction' ")" "<" 'local variable index' ">"
	 */
	public String toString(boolean verbose) {
		if (opcode >= Constants.ILOAD_0 && opcode <= Constants.ALOAD_3 || opcode >= Constants.ISTORE_0
				&& opcode <= Constants.ASTORE_3) {
			return super.toString(verbose);
		} else {
			return super.toString(verbose) + (lvar != -1 && lvar < 4 ? "_" : " ") + lvar;
		}
	}

	public boolean isALOAD() {
		return opcode == ALOAD || opcode >= ALOAD_0 && opcode <= ALOAD_3;
	}

	public boolean isASTORE() {
		return opcode == ASTORE || opcode >= ASTORE_0 && opcode <= ASTORE_3;
	}

	public int getBaseOpcode() {
		if (opcode >= ILOAD && opcode <= ALOAD || opcode >= ISTORE && opcode <= ASTORE) {
			// not an optimized instruction
			return opcode;
		}
		if (opcode >= Constants.ILOAD_0 && opcode <= Constants.ALOAD_3) {
			int ret = opcode - ILOAD_0;
			ret = ret - ret % 4;
			ret = ret / 4;
			return ret + ILOAD;
		}
		int ret = opcode - ISTORE_0;
		ret = ret - ret % 4;
		ret = ret / 4;
		return ret + ISTORE;
	}

	/**
	 * @return local variable index referred by this instruction.
	 */
	// optimize!
	public final int getIndex() {
		if (lvar != -1) {
			return lvar;
		}
		if (opcode >= Constants.ILOAD_0 && opcode <= Constants.ALOAD_3) {
			return (opcode - Constants.ILOAD_0) % 4;
		} else if (opcode >= Constants.ISTORE_0 && opcode <= Constants.ASTORE_3) {
			return (opcode - Constants.ISTORE_0) % 4;
		}
		return -1;
	}

	public void setIndex(int i) {
		// Switching the index for a load/store without a current index specified (ie. an aload_1 or istore_2)
		// means we need to should adjust to a normal aload/istore opcode
		if (getIndex() != i) {
			if (opcode >= Constants.ILOAD_0 && opcode <= Constants.ALOAD_3) {
				opcode = (short) (ILOAD + (opcode - ILOAD_0) / 4);
			} else if (opcode >= Constants.ISTORE_0 && opcode <= Constants.ASTORE_3) {
				opcode = (short) (ISTORE + (opcode - ISTORE_0) / 4);
			}
			this.lvar = i;
		}
	}

	public boolean canSetIndex() {
		return true;
	}

	public InstructionLV setIndexAndCopyIfNecessary(int newIndex) {
		if (canSetIndex()) {
			setIndex(newIndex);
			return this;
		} else {
			if (getIndex() == newIndex) {
				return this;
			}
			InstructionLV newInstruction = null;
			int baseOpCode = getBaseOpcode();
			if (newIndex < 4) {
				if (isStoreInstruction()) {
					newInstruction = (InstructionLV) InstructionConstants.INSTRUCTIONS[(baseOpCode - Constants.ISTORE) * 4
							+ Constants.ISTORE_0 + newIndex];
				} else {
					newInstruction = (InstructionLV) InstructionConstants.INSTRUCTIONS[(baseOpCode - Constants.ILOAD) * 4
							+ Constants.ILOAD_0 + newIndex];
				}
			} else {
				newInstruction = new InstructionLV((short) baseOpCode, newIndex);
			}
			// if (getBaseOpcode()!=newInstruction.getBaseOpcode() || newInstruction.getIndex()!=newIndex) {
			// throw new
			// RuntimeException("New Instruction created does not appear to be valid: originalBaseOpcode="+getBaseOpcode()+
			// " newBaseOpcode="+newInstruction.getBaseOpcode());
			// }
			return newInstruction;
		}
	}

	public int getLength() {
		int size = Constants.iLen[opcode];
		if (lvar == -1) {
			return size;
		} else {
			if (lvar < 4) {
				if (opcode == ALOAD || opcode == ASTORE) {
					return 1;
				} else if (opcode == ILOAD || opcode == ISTORE) {
					return 1;
				} else if (opcode == DLOAD || opcode == DSTORE) {
					return 1;
				} else if (opcode == FLOAD || opcode == FSTORE) {
					return 1;
				} else if (opcode == LLOAD || opcode == LSTORE) {
					return 1;
				} else {
					if (wide()) {
						return size + 2;
					}
					return size;
				}
			} else {
				if (wide()) {
					return size + 2;
				}
				return size;
			}
		}
	}

	private final boolean wide() {
		return lvar > Constants.MAX_BYTE;
	}

	public boolean equals(Object other) {
		if (!(other instanceof InstructionLV)) {
			return false;
		}
		InstructionLV o = (InstructionLV) other;
		return o.opcode == opcode && o.lvar == lvar;
	}

	public int hashCode() {
		return opcode * 37 + lvar;
	}

}