From: aclement Date: Thu, 28 Aug 2008 00:05:41 +0000 (+0000) Subject: equals/hashCode X-Git-Tag: V1_6_2~175 X-Git-Url: https://source.dussan.org/?a=commitdiff_plain;h=91d76d20f5c84a2cbb6d879f5fda8ac983aa6160;p=aspectj.git equals/hashCode --- diff --git a/bcel-builder/src/org/aspectj/apache/bcel/generic/InstructionSelect.java b/bcel-builder/src/org/aspectj/apache/bcel/generic/InstructionSelect.java index 8556aebf9..dcebe3a0f 100644 --- a/bcel-builder/src/org/aspectj/apache/bcel/generic/InstructionSelect.java +++ b/bcel-builder/src/org/aspectj/apache/bcel/generic/InstructionSelect.java @@ -53,221 +53,251 @@ package org.aspectj.apache.bcel.generic; * information on the Apache Software Foundation, please see * . */ -import java.io.*; +import java.io.DataOutputStream; +import java.io.IOException; + import org.aspectj.apache.bcel.util.ByteSequence; -/** +/** * Select - Abstract super class for LOOKUPSWITCH and TABLESWITCH instructions. - * - * @version $Id: InstructionSelect.java,v 1.2 2008/05/28 23:52:59 aclement Exp $ - * @author M. Dahm + * + * @version $Id: InstructionSelect.java,v 1.3 2008/08/28 00:05:41 aclement Exp $ + * @author M. Dahm * @see LOOKUPSWITCH * @see TABLESWITCH * @see InstructionList */ public abstract class InstructionSelect extends InstructionBranch { - protected int[] match; // matches, i.e., case 1: ... - protected int[] indices; // target offsets - protected InstructionHandle[] targets; // target objects in instruction list - protected int fixedLength; // fixed length defined by subclasses - protected int matchLength; // number of cases - protected int padding = 0; // number of pad bytes for alignment - - protected short length; - public int getLength() { return length; } - /** - * (Match, target) pairs for switch. - * `Match' and `targets' must have the same length of course. - * - * @param match array of matching values - * @param targets instruction targets - * @param target default instruction target - */ - InstructionSelect(short opcode, int[] match, InstructionHandle[] targets, - InstructionHandle target) { - super(opcode, target); - - this.targets = targets; - for(int i=0; i < targets.length; i++) - notifyTarget(null, targets[i], this); - - this.match = match; - - if((matchLength = match.length) != targets.length) - throw new ClassGenException("Match and target array have not the same length"); - - indices = new int[matchLength]; - } - - protected int getTargetOffset(InstructionHandle target) { - if(target == null) - throw new ClassGenException("Target of " + super.toString(true) + - " is invalid null handle"); - - int t = target.getPosition(); - - if(t < 0) - throw new ClassGenException("Invalid branch target position offset for " + - super.toString(true) + ":" + t + ":" + target); - - return t - positionOfThisInstruction; - } - /** - * Since this is a variable length instruction, it may shift the following - * instructions which then need to update their position. - * - * Called by InstructionList.setPositions when setting the position for every - * instruction. In the presence of variable length instructions `setPositions' - * performs multiple passes over the instruction list to calculate the - * correct (byte) positions and offsets by calling this function. - * - * @param offset additional offset caused by preceding (variable length) instructions - * @param max_offset the maximum offset that may be caused by these instructions - * @return additional offset caused by possible change of this instruction's length - */ - protected int updatePosition(int offset, int max_offset) { - positionOfThisInstruction += offset; // Additional offset caused by preceding SWITCHs, GOTOs, etc. - - short old_length = length; - - /* Alignment on 4-byte-boundary, + 1, because of tag byte. - */ - padding = (4 - ((positionOfThisInstruction + 1) % 4)) % 4; - length = (short)(fixedLength + padding); // Update length - - return length - old_length; - } - - /** - * Dump instruction as byte code to stream out. - * @param out Output stream - */ - public void dump(DataOutputStream out) throws IOException { - out.writeByte(opcode); - - for(int i=0; i < padding; i++) // Padding bytes - out.writeByte(0); - - targetIndex = getTargetOffset(); // Write default target offset - out.writeInt(targetIndex); - } - -// /** -// * Read needed data (e.g. index) from file. -// */ -// protected void initFromFile(ByteSequence bytes, boolean wide) throws IOException -// { -// padding = (4 - (bytes.getIndex() % 4)) % 4; // Compute number of pad bytes -// -// for(int i=0; i < padding; i++) { -// bytes.readByte(); -// } -// -// // Default branch target common for both cases (TABLESWITCH, LOOKUPSWITCH) -// targetIndex = bytes.readInt(); -// } - - public InstructionSelect(short opcode, ByteSequence bytes) throws IOException { - super(opcode); - padding = (4 - (bytes.getIndex() % 4)) % 4; // Compute number of pad bytes - - for(int i=0; i < padding; i++) { - bytes.readByte(); - } - - // Default branch target common for both cases (TABLESWITCH, LOOKUPSWITCH) - targetIndex = bytes.readInt(); - } - - /** - * @return mnemonic for instruction - */ - public String toString(boolean verbose) { - StringBuffer buf = new StringBuffer(super.toString(verbose)); - - if(verbose) { - for(int i=0; i < matchLength; i++) { - String s = "null"; - - if(targets[i] != null) - s = targets[i].getInstruction().toString(); - - buf.append("(" + match[i] + ", " + s + " = {" + indices[i] + "})"); - } - } - else - buf.append(" ..."); - - return buf.toString(); - } - - /** - * Set branch target for `i'th case - */ - public void setTarget(int i, InstructionHandle target) { - notifyTarget(targets[i], target, this); - targets[i] = target; - } - - /** - * @param old_ih old target - * @param new_ih new target - */ - public void updateTarget(InstructionHandle old_ih, InstructionHandle new_ih) { - boolean targeted = false; - - if(targetInstruction == old_ih) { - targeted = true; - setTarget(new_ih); - } - - for(int i=0; i < targets.length; i++) { - if(targets[i] == old_ih) { - targeted = true; - setTarget(i, new_ih); - } - } - - if(!targeted) - throw new ClassGenException("Not targeting " + old_ih); - } - - /** - * @return true, if ih is target of this instruction - */ - public boolean containsTarget(InstructionHandle ih) { - if(targetInstruction == ih) - return true; - - for(int i=0; i < targets.length; i++) - if(targets[i] == ih) - return true; - - return false; - } - - /** - * Inform targets that they're not targeted anymore. - */ - void dispose() { - super.dispose(); - - for(int i=0; i < targets.length; i++) - targets[i].removeTargeter(this); - } - - /** - * @return array of match indices - */ - public int[] getMatchs() { return match; } - - /** - * @return array of match target offsets - */ - public int[] getIndices() { return indices; } - - /** - * @return array of match targets - */ - public InstructionHandle[] getTargets() { return targets; } + protected int[] match; // matches, i.e., case 1: ... + protected int[] indices; // target offsets + protected InstructionHandle[] targets; // target objects in instruction list + protected int fixedLength; // fixed length defined by subclasses + protected int matchLength; // number of cases + protected int padding = 0; // number of pad bytes for alignment + + protected short length; + + /** + * (Match, target) pairs for switch. `Match' and `targets' must have the + * same length of course. + * + * @param match array of matching values + * @param targets instruction targets + * @param target default instruction target + */ + InstructionSelect(short opcode, int[] match, InstructionHandle[] targets, + InstructionHandle target) { + super(opcode, target); + + this.targets = targets; + for (int i = 0; i < targets.length; i++) { + notifyTarget(null, targets[i], this); + } + + this.match = match; + + if ((matchLength = match.length) != targets.length) { + throw new ClassGenException( + "Match and target array have not the same length"); + } + + indices = new int[matchLength]; + } + + protected int getTargetOffset(InstructionHandle target) { + if (target == null) { + throw new ClassGenException("Target of " + super.toString(true) + + " is invalid null handle"); + } + + int t = target.getPosition(); + + if (t < 0) { + throw new ClassGenException( + "Invalid branch target position offset for " + + super.toString(true) + ":" + t + ":" + target); + } + + return t - positionOfThisInstruction; + } + + /** + * Since this is a variable length instruction, it may shift the following + * instructions which then need to update their position. + * + * Called by InstructionList.setPositions when setting the position for + * every instruction. In the presence of variable length instructions + * `setPositions' performs multiple passes over the instruction list to + * calculate the correct (byte) positions and offsets by calling this + * function. + * + * @param offset additional offset caused by preceding (variable length) + * instructions + * @param max_offset the maximum offset that may be caused by these + * instructions + * @return additional offset caused by possible change of this instruction's + * length + */ + protected int updatePosition(int offset, int max_offset) { + positionOfThisInstruction += offset; // Additional offset caused by + // preceding SWITCHs, GOTOs, + // etc. + + short old_length = length; + + /* + * Alignment on 4-byte-boundary, + 1, because of tag byte. + */ + padding = (4 - (positionOfThisInstruction + 1) % 4) % 4; + length = (short) (fixedLength + padding); // Update length + + return length - old_length; + } + + /** + * Dump instruction as byte code to stream out. + * + * @param out Output stream + */ + public void dump(DataOutputStream out) throws IOException { + out.writeByte(opcode); + + for (int i = 0; i < padding; i++) { + out.writeByte(0); + } + + targetIndex = getTargetOffset(); // Write default target offset + out.writeInt(targetIndex); + } + + public InstructionSelect(short opcode, ByteSequence bytes) + throws IOException { + super(opcode); + padding = (4 - bytes.getIndex() % 4) % 4; // Compute number of pad bytes + + for (int i = 0; i < padding; i++) { + bytes.readByte(); + } + + // Default branch target common for both cases (TABLESWITCH, + // LOOKUPSWITCH) + targetIndex = bytes.readInt(); + } + + /** + * @return mnemonic for instruction + */ + public String toString(boolean verbose) { + StringBuffer buf = new StringBuffer(super.toString(verbose)); + + if (verbose) { + for (int i = 0; i < matchLength; i++) { + String s = "null"; + + if (targets[i] != null) { + s = targets[i].getInstruction().toString(); + } + + buf.append("(" + match[i] + ", " + s + " = {" + indices[i] + + "})"); + } + } else { + buf.append(" ..."); + } + + return buf.toString(); + } + + /** + * Set branch target for `i'th case + */ + public void setTarget(int i, InstructionHandle target) { + notifyTarget(targets[i], target, this); + targets[i] = target; + } + + /** + * @param old_ih old target + * @param new_ih new target + */ + public void updateTarget(InstructionHandle old_ih, InstructionHandle new_ih) { + boolean targeted = false; + + if (targetInstruction == old_ih) { + targeted = true; + setTarget(new_ih); + } + + for (int i = 0; i < targets.length; i++) { + if (targets[i] == old_ih) { + targeted = true; + setTarget(i, new_ih); + } + } + + if (!targeted) { + throw new ClassGenException("Not targeting " + old_ih); + } + } + + /** + * @return true, if ih is target of this instruction + */ + public boolean containsTarget(InstructionHandle ih) { + if (targetInstruction == ih) { + return true; + } + + for (int i = 0; i < targets.length; i++) { + if (targets[i] == ih) { + return true; + } + } + + return false; + } + + /** + * Inform targets that they're not targeted anymore. + */ + void dispose() { + super.dispose(); + + for (int i = 0; i < targets.length; i++) { + targets[i].removeTargeter(this); + } + } + + public boolean equals(Object other) { + return this == other; + } + + public int hashCode() { + return opcode * 37; + } + + /** + * @return array of match indices + */ + public int[] getMatchs() { + return match; + } + + /** + * @return array of match target offsets + */ + public int[] getIndices() { + return indices; + } + + /** + * @return array of match targets + */ + public InstructionHandle[] getTargets() { + return targets; + } + + public int getLength() { + return length; + } }