();
+
+ /**
+ * Look for ConstantMethodref in ConstantPool.
+ *
+ * @param class_name
+ * Where to find method
+ * @param method_name
+ * Guess what
+ * @param signature
+ * return and argument types
+ * @return index on success, -1 otherwise
+ */
+ public int lookupMethodref(String class_name, String method_name,
+ String signature) {
+ Index index = cp_table.get(class_name + METHODREF_DELIM + method_name
+ + METHODREF_DELIM + signature);
+ return (index != null) ? index.index : -1;
+ }
+
+ public int lookupMethodref(MethodGen method) {
+ return lookupMethodref(method.getClassName(), method.getName(),
+ method.getSignature());
+ }
+
+ /**
+ * Add a new Methodref constant to the ConstantPool, if it is not already in
+ * there.
+ *
+ * @param class_name
+ * class name string to add
+ * @param method_name
+ * method name string to add
+ * @param signature
+ * method signature string to add
+ * @return index of entry
+ */
+ public int addMethodref(String class_name, String method_name,
+ String signature) {
+ int ret, class_index, name_and_type_index;
+ if ((ret = lookupMethodref(class_name, method_name, signature)) != -1) {
+ return ret; // Already in CP
+ }
+ adjustSize();
+ name_and_type_index = addNameAndType(method_name, signature);
+ class_index = addClass(class_name);
+ ret = index;
+ constants[index++] = new ConstantMethodref(class_index,
+ name_and_type_index);
+ String key = class_name + METHODREF_DELIM + method_name
+ + METHODREF_DELIM + signature;
+ if (!cp_table.containsKey(key)) {
+ cp_table.put(key, new Index(ret));
+ }
+ return ret;
+ }
+
+ public int addMethodref(MethodGen method) {
+ return addMethodref(method.getClassName(), method.getName(),
+ method.getSignature());
+ }
+
+ /**
+ * Look for ConstantInterfaceMethodref in ConstantPool.
+ *
+ * @param class_name
+ * Where to find method
+ * @param method_name
+ * Guess what
+ * @param signature
+ * return and argument types
+ * @return index on success, -1 otherwise
+ */
+ public int lookupInterfaceMethodref(String class_name, String method_name,
+ String signature) {
+ Index index = cp_table.get(class_name + IMETHODREF_DELIM + method_name
+ + IMETHODREF_DELIM + signature);
+ return (index != null) ? index.index : -1;
+ }
+
+ public int lookupInterfaceMethodref(MethodGen method) {
+ return lookupInterfaceMethodref(method.getClassName(),
+ method.getName(), method.getSignature());
+ }
+
+ /**
+ * Add a new InterfaceMethodref constant to the ConstantPool, if it is not
+ * already in there.
+ *
+ * @param class_name
+ * class name string to add
+ * @param method_name
+ * method name string to add
+ * @param signature
+ * signature string to add
+ * @return index of entry
+ */
+ public int addInterfaceMethodref(String class_name, String method_name,
+ String signature) {
+ int ret, class_index, name_and_type_index;
+ if ((ret = lookupInterfaceMethodref(class_name, method_name, signature)) != -1) {
+ return ret; // Already in CP
+ }
+ adjustSize();
+ class_index = addClass(class_name);
+ name_and_type_index = addNameAndType(method_name, signature);
+ ret = index;
+ constants[index++] = new ConstantInterfaceMethodref(class_index,
+ name_and_type_index);
+ String key = class_name + IMETHODREF_DELIM + method_name
+ + IMETHODREF_DELIM + signature;
+ if (!cp_table.containsKey(key)) {
+ cp_table.put(key, new Index(ret));
+ }
+ return ret;
+ }
+
+ public int addInterfaceMethodref(MethodGen method) {
+ return addInterfaceMethodref(method.getClassName(), method.getName(),
+ method.getSignature());
+ }
+
+ /**
+ * Look for ConstantFieldref in ConstantPool.
+ *
+ * @param class_name
+ * Where to find method
+ * @param field_name
+ * Guess what
+ * @param signature
+ * return and argument types
+ * @return index on success, -1 otherwise
+ */
+ public int lookupFieldref(String class_name, String field_name,
+ String signature) {
+ Index index = cp_table.get(class_name + FIELDREF_DELIM + field_name
+ + FIELDREF_DELIM + signature);
+ return (index != null) ? index.index : -1;
+ }
+
+ /**
+ * Add a new Fieldref constant to the ConstantPool, if it is not already in
+ * there.
+ *
+ * @param class_name
+ * class name string to add
+ * @param field_name
+ * field name string to add
+ * @param signature
+ * signature string to add
+ * @return index of entry
+ */
+ public int addFieldref(String class_name, String field_name,
+ String signature) {
+ int ret;
+ int class_index, name_and_type_index;
+ if ((ret = lookupFieldref(class_name, field_name, signature)) != -1) {
+ return ret; // Already in CP
+ }
+ adjustSize();
+ class_index = addClass(class_name);
+ name_and_type_index = addNameAndType(field_name, signature);
+ ret = index;
+ constants[index++] = new ConstantFieldref(class_index,
+ name_and_type_index);
+ String key = class_name + FIELDREF_DELIM + field_name + FIELDREF_DELIM
+ + signature;
+ if (!cp_table.containsKey(key)) {
+ cp_table.put(key, new Index(ret));
+ }
+ return ret;
+ }
+
+ /**
+ * @param i
+ * index in constant pool
+ * @return constant pool entry at index i
+ */
+ public Constant getConstant(int i) {
+ return constants[i];
+ }
+
+ /**
+ * Use with care!
+ *
+ * @param i
+ * index in constant pool
+ * @param c
+ * new constant pool entry at index i
+ */
+ public void setConstant(int i, Constant c) {
+ constants[i] = c;
+ }
+
+ /**
+ * @return intermediate constant pool
+ */
+ public ConstantPool getConstantPool() {
+ return new ConstantPool(constants);
+ }
+
+ /**
+ * @return current size of constant pool
+ */
+ public int getSize() {
+ return index;
+ }
+
+ /**
+ * @return constant pool with proper length
+ */
+ public ConstantPool getFinalConstantPool() {
+ Constant[] cs = new Constant[index];
+ System.arraycopy(constants, 0, cs, 0, index);
+ return new ConstantPool(cs);
+ }
+
+ /**
+ * @return String representation.
+ */
+ @Override
+ public String toString() {
+ StringBuffer buf = new StringBuffer();
+ for (int i = 1; i < index; i++) {
+ buf.append(i).append(")").append(constants[i]).append("\n");
+ }
+ return buf.toString();
+ }
+
+ /**
+ * Import constant from another ConstantPool and return new index.
+ */
+ public int addConstant(Constant c, ConstantPoolGen cp) {
+ Constant[] constants = cp.getConstantPool().getConstantPool();
+ switch (c.getTag()) {
+ case Constants.CONSTANT_String: {
+ ConstantString s = (ConstantString) c;
+ ConstantUtf8 u8 = (ConstantUtf8) constants[s.getStringIndex()];
+ return addString(u8.getBytes());
+ }
+ case Constants.CONSTANT_Class: {
+ ConstantClass s = (ConstantClass) c;
+ ConstantUtf8 u8 = (ConstantUtf8) constants[s.getNameIndex()];
+ return addClass(u8.getBytes());
+ }
+ case Constants.CONSTANT_NameAndType: {
+ ConstantNameAndType n = (ConstantNameAndType) c;
+ ConstantUtf8 u8 = (ConstantUtf8) constants[n.getNameIndex()];
+ ConstantUtf8 u8_2 = (ConstantUtf8) constants[n.getSignatureIndex()];
+ return addNameAndType(u8.getBytes(), u8_2.getBytes());
+ }
+ case Constants.CONSTANT_Utf8:
+ return addUtf8(((ConstantUtf8) c).getBytes());
+ case Constants.CONSTANT_Double:
+ return addDouble(((ConstantDouble) c).getBytes());
+ case Constants.CONSTANT_Float:
+ return addFloat(((ConstantFloat) c).getBytes());
+ case Constants.CONSTANT_Long:
+ return addLong(((ConstantLong) c).getBytes());
+ case Constants.CONSTANT_Integer:
+ return addInteger(((ConstantInteger) c).getBytes());
+ case Constants.CONSTANT_InterfaceMethodref:
+ case Constants.CONSTANT_Methodref:
+ case Constants.CONSTANT_Fieldref: {
+ ConstantCP m = (ConstantCP) c;
+ ConstantClass clazz = (ConstantClass) constants[m.getClassIndex()];
+ ConstantNameAndType n = (ConstantNameAndType) constants[m
+ .getNameAndTypeIndex()];
+ ConstantUtf8 u8 = (ConstantUtf8) constants[clazz.getNameIndex()];
+ String class_name = u8.getBytes().replace('/', '.');
+ u8 = (ConstantUtf8) constants[n.getNameIndex()];
+ String name = u8.getBytes();
+ u8 = (ConstantUtf8) constants[n.getSignatureIndex()];
+ String signature = u8.getBytes();
+ switch (c.getTag()) {
+ case Constants.CONSTANT_InterfaceMethodref:
+ return addInterfaceMethodref(class_name, name, signature);
+ case Constants.CONSTANT_Methodref:
+ return addMethodref(class_name, name, signature);
+ case Constants.CONSTANT_Fieldref:
+ return addFieldref(class_name, name, signature);
+ default: // Never reached
+ throw new RuntimeException("Unknown constant type " + c);
+ }
+ }
+ default: // Never reached
+ throw new RuntimeException("Unknown constant type " + c);
+ }
+ }
}
diff --git a/src/org/apache/bcel/generic/ConstantPushInstruction.java b/src/org/apache/bcel/generic/ConstantPushInstruction.java
index 2c69228..7fcfea8 100644
--- a/src/org/apache/bcel/generic/ConstantPushInstruction.java
+++ b/src/org/apache/bcel/generic/ConstantPushInstruction.java
@@ -17,16 +17,18 @@
package org.apache.bcel.generic;
/**
- * Denotes a push instruction that produces a literal on the stack
- * such as SIPUSH, BIPUSH, ICONST, etc.
- *
- * @version $Id: ConstantPushInstruction.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
-
+ * Denotes a push instruction that produces a literal on the stack such as
+ * SIPUSH, BIPUSH, ICONST, etc.
+ *
+ * @version $Id: ConstantPushInstruction.java 386056 2006-03-15 11:31:56Z tcurdt
+ * $
+ * @author M. Dahm
+ *
* @see ICONST
* @see SIPUSH
*/
-public interface ConstantPushInstruction extends PushInstruction, TypedInstruction {
+public interface ConstantPushInstruction extends PushInstruction,
+ TypedInstruction {
- public Number getValue();
+ public Number getValue();
}
diff --git a/src/org/apache/bcel/generic/ConversionInstruction.java b/src/org/apache/bcel/generic/ConversionInstruction.java
index accb79c..1cc400a 100644
--- a/src/org/apache/bcel/generic/ConversionInstruction.java
+++ b/src/org/apache/bcel/generic/ConversionInstruction.java
@@ -20,57 +20,63 @@ import org.apache.bcel.Constants;
/**
* Super class for the x2y family of instructions.
- *
+ *
* @version $Id: ConversionInstruction.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
-public abstract class ConversionInstruction extends Instruction implements TypedInstruction,
- StackProducer, StackConsumer {
+public abstract class ConversionInstruction extends Instruction implements
+ TypedInstruction, StackProducer, StackConsumer {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- ConversionInstruction() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ ConversionInstruction() {
+ }
- /**
- * @param opcode opcode of instruction
- */
- protected ConversionInstruction(short opcode) {
- super(opcode, (short) 1);
- }
+ /**
+ * @param opcode
+ * opcode of instruction
+ */
+ protected ConversionInstruction(short opcode) {
+ super(opcode, (short) 1);
+ }
-
- /** @return type associated with the instruction
- */
- public Type getType( ConstantPoolGen cp ) {
- switch (opcode) {
- case Constants.D2I:
- case Constants.F2I:
- case Constants.L2I:
- return Type.INT;
- case Constants.D2F:
- case Constants.I2F:
- case Constants.L2F:
- return Type.FLOAT;
- case Constants.D2L:
- case Constants.F2L:
- case Constants.I2L:
- return Type.LONG;
- case Constants.F2D:
- case Constants.I2D:
- case Constants.L2D:
- return Type.DOUBLE;
- case Constants.I2B:
- return Type.BYTE;
- case Constants.I2C:
- return Type.CHAR;
- case Constants.I2S:
- return Type.SHORT;
- default: // Never reached
- throw new ClassGenException("Unknown type " + opcode);
- }
- }
+ /**
+ * @return type associated with the instruction
+ */
+ @Override
+ public Type getType(ConstantPoolGen cp) {
+ switch (opcode) {
+ case Constants.D2I:
+ case Constants.F2I:
+ case Constants.L2I:
+ return Type.INT;
+ case Constants.D2F:
+ case Constants.I2F:
+ case Constants.L2F:
+ return Type.FLOAT;
+ case Constants.D2L:
+ case Constants.F2L:
+ case Constants.I2L:
+ return Type.LONG;
+ case Constants.F2D:
+ case Constants.I2D:
+ case Constants.L2D:
+ return Type.DOUBLE;
+ case Constants.I2B:
+ return Type.BYTE;
+ case Constants.I2C:
+ return Type.CHAR;
+ case Constants.I2S:
+ return Type.SHORT;
+ default: // Never reached
+ throw new ClassGenException("Unknown type " + opcode);
+ }
+ }
}
diff --git a/src/org/apache/bcel/generic/D2F.java b/src/org/apache/bcel/generic/D2F.java
index 1990492..8f733cb 100644
--- a/src/org/apache/bcel/generic/D2F.java
+++ b/src/org/apache/bcel/generic/D2F.java
@@ -16,35 +16,45 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* D2F - Convert double to float
- * Stack: ..., value.word1, value.word2 -> ..., result
- *
+ *
+ *
+ * Stack: ..., value.word1, value.word2 -> ..., result
+ *
+ *
* @version $Id: D2F.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class D2F extends ConversionInstruction {
- /** Convert double to float
- */
- public D2F() {
- super(org.apache.bcel.Constants.D2F);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Convert double to float
+ */
+ public D2F() {
+ super(org.apache.bcel.Constants.D2F);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitConversionInstruction(this);
- v.visitD2F(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitConversionInstruction(this);
+ v.visitD2F(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/D2I.java b/src/org/apache/bcel/generic/D2I.java
index cca2f9f..d18b4c4 100644
--- a/src/org/apache/bcel/generic/D2I.java
+++ b/src/org/apache/bcel/generic/D2I.java
@@ -16,35 +16,45 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* D2I - Convert double to int
- * Stack: ..., value.word1, value.word2 -> ..., result
- *
+ *
+ *
+ * Stack: ..., value.word1, value.word2 -> ..., result
+ *
+ *
* @version $Id: D2I.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class D2I extends ConversionInstruction {
- /** Convert double to int
- */
- public D2I() {
- super(org.apache.bcel.Constants.D2I);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Convert double to int
+ */
+ public D2I() {
+ super(org.apache.bcel.Constants.D2I);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitConversionInstruction(this);
- v.visitD2I(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitConversionInstruction(this);
+ v.visitD2I(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/D2L.java b/src/org/apache/bcel/generic/D2L.java
index 0f63663..39b653b 100644
--- a/src/org/apache/bcel/generic/D2L.java
+++ b/src/org/apache/bcel/generic/D2L.java
@@ -16,35 +16,45 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* D2L - Convert double to long
- * Stack: ..., value.word1, value.word2 -> ..., result.word1, result.word2
- *
+ *
+ *
+ * Stack: ..., value.word1, value.word2 -> ..., result.word1, result.word2
+ *
+ *
* @version $Id: D2L.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class D2L extends ConversionInstruction {
- /** Convert double to long
- */
- public D2L() {
- super(org.apache.bcel.Constants.D2L);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Convert double to long
+ */
+ public D2L() {
+ super(org.apache.bcel.Constants.D2L);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitConversionInstruction(this);
- v.visitD2L(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitConversionInstruction(this);
+ v.visitD2L(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/DADD.java b/src/org/apache/bcel/generic/DADD.java
index 7918b47..28b0625 100644
--- a/src/org/apache/bcel/generic/DADD.java
+++ b/src/org/apache/bcel/generic/DADD.java
@@ -16,36 +16,47 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* DADD - Add doubles
- * Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 ->
- * ..., result.word1, result1.word2
- *
+ *
+ *
+ * Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 ->
+ *
+ *
+ * ..., result.word1, result1.word2
+ *
* @version $Id: DADD.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class DADD extends ArithmeticInstruction {
- /** Add doubles
- */
- public DADD() {
- super(org.apache.bcel.Constants.DADD);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Add doubles
+ */
+ public DADD() {
+ super(org.apache.bcel.Constants.DADD);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitArithmeticInstruction(this);
- v.visitDADD(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitArithmeticInstruction(this);
+ v.visitDADD(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/DALOAD.java b/src/org/apache/bcel/generic/DALOAD.java
index de2def0..1f91fd7 100644
--- a/src/org/apache/bcel/generic/DALOAD.java
+++ b/src/org/apache/bcel/generic/DALOAD.java
@@ -16,35 +16,45 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* DALOAD - Load double from array
- * Stack: ..., arrayref, index -> ..., result.word1, result.word2
- *
+ *
+ *
+ * Stack: ..., arrayref, index -> ..., result.word1, result.word2
+ *
+ *
* @version $Id: DALOAD.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class DALOAD extends ArrayInstruction implements StackProducer {
- /** Load double from array
- */
- public DALOAD() {
- super(org.apache.bcel.Constants.DALOAD);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Load double from array
+ */
+ public DALOAD() {
+ super(org.apache.bcel.Constants.DALOAD);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackProducer(this);
- v.visitExceptionThrower(this);
- v.visitTypedInstruction(this);
- v.visitArrayInstruction(this);
- v.visitDALOAD(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackProducer(this);
+ v.visitExceptionThrower(this);
+ v.visitTypedInstruction(this);
+ v.visitArrayInstruction(this);
+ v.visitDALOAD(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/DASTORE.java b/src/org/apache/bcel/generic/DASTORE.java
index 5de71bc..18b4166 100644
--- a/src/org/apache/bcel/generic/DASTORE.java
+++ b/src/org/apache/bcel/generic/DASTORE.java
@@ -16,35 +16,45 @@
*/
package org.apache.bcel.generic;
-/**
- * DASTORE - Store into double array
- * Stack: ..., arrayref, index, value.word1, value.word2 -> ...
- *
+/**
+ * DASTORE - Store into double array
+ *
+ *
+ * Stack: ..., arrayref, index, value.word1, value.word2 -> ...
+ *
+ *
* @version $Id: DASTORE.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class DASTORE extends ArrayInstruction implements StackConsumer {
- /** Store double into array
- */
- public DASTORE() {
- super(org.apache.bcel.Constants.DASTORE);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Store double into array
+ */
+ public DASTORE() {
+ super(org.apache.bcel.Constants.DASTORE);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackConsumer(this);
- v.visitExceptionThrower(this);
- v.visitTypedInstruction(this);
- v.visitArrayInstruction(this);
- v.visitDASTORE(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackConsumer(this);
+ v.visitExceptionThrower(this);
+ v.visitTypedInstruction(this);
+ v.visitArrayInstruction(this);
+ v.visitDASTORE(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/DCMPG.java b/src/org/apache/bcel/generic/DCMPG.java
index 7190b82..ab68ced 100644
--- a/src/org/apache/bcel/generic/DCMPG.java
+++ b/src/org/apache/bcel/generic/DCMPG.java
@@ -16,40 +16,52 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* DCMPG - Compare doubles: value1 > value2
- * Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 ->
- * ..., result
- *
+ *
+ *
+ * Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 ->
+ *
+ *
+ * ..., result
+ *
* @version $Id: DCMPG.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
-public class DCMPG extends Instruction implements TypedInstruction, StackProducer, StackConsumer {
+public class DCMPG extends Instruction implements TypedInstruction,
+ StackProducer, StackConsumer {
- public DCMPG() {
- super(org.apache.bcel.Constants.DCMPG, (short) 1);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ public DCMPG() {
+ super(org.apache.bcel.Constants.DCMPG, (short) 1);
+ }
- /** @return Type.DOUBLE
- */
- public Type getType( ConstantPoolGen cp ) {
- return Type.DOUBLE;
- }
+ /**
+ * @return Type.DOUBLE
+ */
+ @Override
+ public Type getType(ConstantPoolGen cp) {
+ return Type.DOUBLE;
+ }
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitDCMPG(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitDCMPG(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/DCMPL.java b/src/org/apache/bcel/generic/DCMPL.java
index 9dcfc4f..f3d98fd 100644
--- a/src/org/apache/bcel/generic/DCMPL.java
+++ b/src/org/apache/bcel/generic/DCMPL.java
@@ -16,40 +16,52 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* DCMPL - Compare doubles: value1 < value2
- * Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 ->
- * ..., result
- *
+ *
+ *
+ * Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 ->
+ *
+ *
+ * ..., result
+ *
* @version $Id: DCMPL.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
-public class DCMPL extends Instruction implements TypedInstruction, StackProducer, StackConsumer {
+public class DCMPL extends Instruction implements TypedInstruction,
+ StackProducer, StackConsumer {
- public DCMPL() {
- super(org.apache.bcel.Constants.DCMPL, (short) 1);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ public DCMPL() {
+ super(org.apache.bcel.Constants.DCMPL, (short) 1);
+ }
- /** @return Type.DOUBLE
- */
- public Type getType( ConstantPoolGen cp ) {
- return Type.DOUBLE;
- }
+ /**
+ * @return Type.DOUBLE
+ */
+ @Override
+ public Type getType(ConstantPoolGen cp) {
+ return Type.DOUBLE;
+ }
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitDCMPL(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitDCMPL(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/DCONST.java b/src/org/apache/bcel/generic/DCONST.java
index 5af8686..6fa8ad8 100644
--- a/src/org/apache/bcel/generic/DCONST.java
+++ b/src/org/apache/bcel/generic/DCONST.java
@@ -16,65 +16,73 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* DCONST - Push 0.0 or 1.0, other values cause an exception
- *
- * Stack: ... -> ...,
- *
+ *
+ *
+ * Stack: ... -> ...,
+ *
+ *
* @version $Id: DCONST.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
-public class DCONST extends Instruction implements ConstantPushInstruction, TypedInstruction {
+public class DCONST extends Instruction implements ConstantPushInstruction,
+ TypedInstruction {
- private double value;
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ private double value;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ DCONST() {
+ }
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- DCONST() {
- }
+ public DCONST(double f) {
+ super(org.apache.bcel.Constants.DCONST_0, (short) 1);
+ if (f == 0.0) {
+ opcode = org.apache.bcel.Constants.DCONST_0;
+ } else if (f == 1.0) {
+ opcode = org.apache.bcel.Constants.DCONST_1;
+ } else {
+ throw new ClassGenException(
+ "DCONST can be used only for 0.0 and 1.0: " + f);
+ }
+ value = f;
+ }
+ @Override
+ public Number getValue() {
+ return new Double(value);
+ }
- public DCONST(double f) {
- super(org.apache.bcel.Constants.DCONST_0, (short) 1);
- if (f == 0.0) {
- opcode = org.apache.bcel.Constants.DCONST_0;
- } else if (f == 1.0) {
- opcode = org.apache.bcel.Constants.DCONST_1;
- } else {
- throw new ClassGenException("DCONST can be used only for 0.0 and 1.0: " + f);
- }
- value = f;
- }
+ /**
+ * @return Type.DOUBLE
+ */
+ @Override
+ public Type getType(ConstantPoolGen cp) {
+ return Type.DOUBLE;
+ }
-
- public Number getValue() {
- return new Double(value);
- }
-
-
- /** @return Type.DOUBLE
- */
- public Type getType( ConstantPoolGen cp ) {
- return Type.DOUBLE;
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitPushInstruction(this);
- v.visitStackProducer(this);
- v.visitTypedInstruction(this);
- v.visitConstantPushInstruction(this);
- v.visitDCONST(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitPushInstruction(this);
+ v.visitStackProducer(this);
+ v.visitTypedInstruction(this);
+ v.visitConstantPushInstruction(this);
+ v.visitDCONST(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/DDIV.java b/src/org/apache/bcel/generic/DDIV.java
index 44c2308..8df2367 100644
--- a/src/org/apache/bcel/generic/DDIV.java
+++ b/src/org/apache/bcel/generic/DDIV.java
@@ -16,36 +16,47 @@
*/
package org.apache.bcel.generic;
-/**
- * DDIV - Divide doubles
- * Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 ->
- * ..., result.word1, result.word2
- *
+/**
+ * DDIV - Divide doubles
+ *
+ *
+ * Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 ->
+ *
+ *
+ * ..., result.word1, result.word2
+ *
* @version $Id: DDIV.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class DDIV extends ArithmeticInstruction {
- /** Divide doubles
- */
- public DDIV() {
- super(org.apache.bcel.Constants.DDIV);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Divide doubles
+ */
+ public DDIV() {
+ super(org.apache.bcel.Constants.DDIV);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitArithmeticInstruction(this);
- v.visitDDIV(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitArithmeticInstruction(this);
+ v.visitDDIV(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/DLOAD.java b/src/org/apache/bcel/generic/DLOAD.java
index 360d23b..c7a6cbb 100644
--- a/src/org/apache/bcel/generic/DLOAD.java
+++ b/src/org/apache/bcel/generic/DLOAD.java
@@ -16,42 +16,55 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* DLOAD - Load double from local variable
- * Stack ... -> ..., result.word1, result.word2
- *
+ *
+ *
+ * Stack ... -> ..., result.word1, result.word2
+ *
+ *
* @version $Id: DLOAD.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class DLOAD extends LoadInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- DLOAD() {
- super(org.apache.bcel.Constants.DLOAD, org.apache.bcel.Constants.DLOAD_0);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ DLOAD() {
+ super(org.apache.bcel.Constants.DLOAD,
+ org.apache.bcel.Constants.DLOAD_0);
+ }
- /** Load double from local variable
- * @param n index of local variable
- */
- public DLOAD(int n) {
- super(org.apache.bcel.Constants.DLOAD, org.apache.bcel.Constants.DLOAD_0, n);
- }
+ /**
+ * Load double from local variable
+ *
+ * @param n
+ * index of local variable
+ */
+ public DLOAD(int n) {
+ super(org.apache.bcel.Constants.DLOAD,
+ org.apache.bcel.Constants.DLOAD_0, n);
+ }
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- super.accept(v);
- v.visitDLOAD(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ super.accept(v);
+ v.visitDLOAD(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/DMUL.java b/src/org/apache/bcel/generic/DMUL.java
index 79e64ae..130f5df 100644
--- a/src/org/apache/bcel/generic/DMUL.java
+++ b/src/org/apache/bcel/generic/DMUL.java
@@ -16,36 +16,47 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* DMUL - Multiply doubles
- * Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 ->
- * ..., result.word1, result.word2
- *
+ *
+ *
+ * Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 ->
+ *
+ *
+ * ..., result.word1, result.word2
+ *
* @version $Id: DMUL.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class DMUL extends ArithmeticInstruction {
- /** Multiply doubles
- */
- public DMUL() {
- super(org.apache.bcel.Constants.DMUL);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Multiply doubles
+ */
+ public DMUL() {
+ super(org.apache.bcel.Constants.DMUL);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitArithmeticInstruction(this);
- v.visitDMUL(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitArithmeticInstruction(this);
+ v.visitDMUL(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/DNEG.java b/src/org/apache/bcel/generic/DNEG.java
index c7e2d21..8046d70 100644
--- a/src/org/apache/bcel/generic/DNEG.java
+++ b/src/org/apache/bcel/generic/DNEG.java
@@ -16,33 +16,42 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* DNEG - Negate double
- * Stack: ..., value.word1, value.word2 -> ..., result.word1, result.word2
- *
+ *
+ *
+ * Stack: ..., value.word1, value.word2 -> ..., result.word1, result.word2
+ *
+ *
* @version $Id: DNEG.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class DNEG extends ArithmeticInstruction {
- public DNEG() {
- super(org.apache.bcel.Constants.DNEG);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ public DNEG() {
+ super(org.apache.bcel.Constants.DNEG);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitArithmeticInstruction(this);
- v.visitDNEG(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitArithmeticInstruction(this);
+ v.visitDNEG(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/DREM.java b/src/org/apache/bcel/generic/DREM.java
index 01dfc15..84599f0 100644
--- a/src/org/apache/bcel/generic/DREM.java
+++ b/src/org/apache/bcel/generic/DREM.java
@@ -16,36 +16,47 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* DREM - Remainder of doubles
- * Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 ->
- * ..., result.word1, result.word2
- *
+ *
+ *
+ * Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 ->
+ *
+ *
+ * ..., result.word1, result.word2
+ *
* @version $Id: DREM.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class DREM extends ArithmeticInstruction {
- /** Remainder of doubles
- */
- public DREM() {
- super(org.apache.bcel.Constants.DREM);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Remainder of doubles
+ */
+ public DREM() {
+ super(org.apache.bcel.Constants.DREM);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitArithmeticInstruction(this);
- v.visitDREM(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitArithmeticInstruction(this);
+ v.visitDREM(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/DRETURN.java b/src/org/apache/bcel/generic/DRETURN.java
index a1ccc8b..1bf6d16 100644
--- a/src/org/apache/bcel/generic/DRETURN.java
+++ b/src/org/apache/bcel/generic/DRETURN.java
@@ -16,35 +16,45 @@
*/
package org.apache.bcel.generic;
-/**
- * DRETURN - Return double from method
- * Stack: ..., value.word1, value.word2 -> <empty>
- *
+/**
+ * DRETURN - Return double from method
+ *
+ *
+ * Stack: ..., value.word1, value.word2 -> <empty>
+ *
+ *
* @version $Id: DRETURN.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class DRETURN extends ReturnInstruction {
- /** Return double from method
- */
- public DRETURN() {
- super(org.apache.bcel.Constants.DRETURN);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Return double from method
+ */
+ public DRETURN() {
+ super(org.apache.bcel.Constants.DRETURN);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitExceptionThrower(this);
- v.visitTypedInstruction(this);
- v.visitStackConsumer(this);
- v.visitReturnInstruction(this);
- v.visitDRETURN(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitExceptionThrower(this);
+ v.visitTypedInstruction(this);
+ v.visitStackConsumer(this);
+ v.visitReturnInstruction(this);
+ v.visitDRETURN(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/DSTORE.java b/src/org/apache/bcel/generic/DSTORE.java
index 9efeb3f..1040e06 100644
--- a/src/org/apache/bcel/generic/DSTORE.java
+++ b/src/org/apache/bcel/generic/DSTORE.java
@@ -16,42 +16,55 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* DSTORE - Store double into local variable
- * Stack: ..., value.word1, value.word2 -> ...
- *
+ *
+ *
+ * Stack: ..., value.word1, value.word2 -> ...
+ *
+ *
* @version $Id: DSTORE.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class DSTORE extends StoreInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- DSTORE() {
- super(org.apache.bcel.Constants.DSTORE, org.apache.bcel.Constants.DSTORE_0);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ DSTORE() {
+ super(org.apache.bcel.Constants.DSTORE,
+ org.apache.bcel.Constants.DSTORE_0);
+ }
- /** Store double into local variable
- * @param n index of local variable
- */
- public DSTORE(int n) {
- super(org.apache.bcel.Constants.DSTORE, org.apache.bcel.Constants.DSTORE_0, n);
- }
+ /**
+ * Store double into local variable
+ *
+ * @param n
+ * index of local variable
+ */
+ public DSTORE(int n) {
+ super(org.apache.bcel.Constants.DSTORE,
+ org.apache.bcel.Constants.DSTORE_0, n);
+ }
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- super.accept(v);
- v.visitDSTORE(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ super.accept(v);
+ v.visitDSTORE(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/DSUB.java b/src/org/apache/bcel/generic/DSUB.java
index 6169cfe..63a6f7b 100644
--- a/src/org/apache/bcel/generic/DSUB.java
+++ b/src/org/apache/bcel/generic/DSUB.java
@@ -16,36 +16,47 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* DSUB - Substract doubles
- * Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 ->
- * ..., result.word1, result.word2
- *
+ *
+ *
+ * Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 ->
+ *
+ *
+ * ..., result.word1, result.word2
+ *
* @version $Id: DSUB.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class DSUB extends ArithmeticInstruction {
- /** Substract doubles
- */
- public DSUB() {
- super(org.apache.bcel.Constants.DSUB);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Substract doubles
+ */
+ public DSUB() {
+ super(org.apache.bcel.Constants.DSUB);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitArithmeticInstruction(this);
- v.visitDSUB(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitArithmeticInstruction(this);
+ v.visitDSUB(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/DUP.java b/src/org/apache/bcel/generic/DUP.java
index 5900ddf..7726a0a 100644
--- a/src/org/apache/bcel/generic/DUP.java
+++ b/src/org/apache/bcel/generic/DUP.java
@@ -16,32 +16,41 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* DUP - Duplicate top operand stack word
- * Stack: ..., word -> ..., word, word
- *
+ *
+ *
+ * Stack: ..., word -> ..., word, word
+ *
+ *
* @version $Id: DUP.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class DUP extends StackInstruction implements PushInstruction {
- public DUP() {
- super(org.apache.bcel.Constants.DUP);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ public DUP() {
+ super(org.apache.bcel.Constants.DUP);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackProducer(this);
- v.visitPushInstruction(this);
- v.visitStackInstruction(this);
- v.visitDUP(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackProducer(this);
+ v.visitPushInstruction(this);
+ v.visitStackInstruction(this);
+ v.visitDUP(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/DUP2.java b/src/org/apache/bcel/generic/DUP2.java
index 688a33b..e33c39f 100644
--- a/src/org/apache/bcel/generic/DUP2.java
+++ b/src/org/apache/bcel/generic/DUP2.java
@@ -16,32 +16,41 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* DUP2 - Duplicate two top operand stack words
- * Stack: ..., word2, word1 -> ..., word2, word1, word2, word1
- *
+ *
+ *
+ * Stack: ..., word2, word1 -> ..., word2, word1, word2, word1
+ *
+ *
* @version $Id: DUP2.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class DUP2 extends StackInstruction implements PushInstruction {
- public DUP2() {
- super(org.apache.bcel.Constants.DUP2);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ public DUP2() {
+ super(org.apache.bcel.Constants.DUP2);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackProducer(this);
- v.visitPushInstruction(this);
- v.visitStackInstruction(this);
- v.visitDUP2(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackProducer(this);
+ v.visitPushInstruction(this);
+ v.visitStackInstruction(this);
+ v.visitDUP2(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/DUP2_X1.java b/src/org/apache/bcel/generic/DUP2_X1.java
index b522b1a..b35b991 100644
--- a/src/org/apache/bcel/generic/DUP2_X1.java
+++ b/src/org/apache/bcel/generic/DUP2_X1.java
@@ -16,30 +16,39 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* DUP2_X1 - Duplicate two top operand stack words and put three down
- * Stack: ..., word3, word2, word1 -> ..., word2, word1, word3, word2, word1
- *
+ *
+ *
+ * Stack: ..., word3, word2, word1 -> ..., word2, word1, word3, word2, word1
+ *
+ *
* @version $Id: DUP2_X1.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class DUP2_X1 extends StackInstruction {
- public DUP2_X1() {
- super(org.apache.bcel.Constants.DUP2_X1);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ public DUP2_X1() {
+ super(org.apache.bcel.Constants.DUP2_X1);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackInstruction(this);
- v.visitDUP2_X1(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackInstruction(this);
+ v.visitDUP2_X1(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/DUP2_X2.java b/src/org/apache/bcel/generic/DUP2_X2.java
index 8cf009e..f4bd487 100644
--- a/src/org/apache/bcel/generic/DUP2_X2.java
+++ b/src/org/apache/bcel/generic/DUP2_X2.java
@@ -16,30 +16,39 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* DUP2_X2 - Duplicate two top operand stack words and put four down
- * Stack: ..., word4, word3, word2, word1 -> ..., word2, word1, word4, word3, word2, word1
- *
+ *
+ *
+ * Stack: ..., word4, word3, word2, word1 -> ..., word2, word1, word4, word3, word2, word1
+ *
+ *
* @version $Id: DUP2_X2.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class DUP2_X2 extends StackInstruction {
- public DUP2_X2() {
- super(org.apache.bcel.Constants.DUP2_X2);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ public DUP2_X2() {
+ super(org.apache.bcel.Constants.DUP2_X2);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackInstruction(this);
- v.visitDUP2_X2(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackInstruction(this);
+ v.visitDUP2_X2(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/DUP_X1.java b/src/org/apache/bcel/generic/DUP_X1.java
index a672e29..22a20da 100644
--- a/src/org/apache/bcel/generic/DUP_X1.java
+++ b/src/org/apache/bcel/generic/DUP_X1.java
@@ -16,30 +16,39 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* DUP_X1 - Duplicate top operand stack word and put two down
- * Stack: ..., word2, word1 -> ..., word1, word2, word1
- *
+ *
+ *
+ * Stack: ..., word2, word1 -> ..., word1, word2, word1
+ *
+ *
* @version $Id: DUP_X1.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class DUP_X1 extends StackInstruction {
- public DUP_X1() {
- super(org.apache.bcel.Constants.DUP_X1);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ public DUP_X1() {
+ super(org.apache.bcel.Constants.DUP_X1);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackInstruction(this);
- v.visitDUP_X1(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackInstruction(this);
+ v.visitDUP_X1(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/DUP_X2.java b/src/org/apache/bcel/generic/DUP_X2.java
index 475c4c8..0b94197 100644
--- a/src/org/apache/bcel/generic/DUP_X2.java
+++ b/src/org/apache/bcel/generic/DUP_X2.java
@@ -16,30 +16,39 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* DUP_X2 - Duplicate top operand stack word and put three down
- * Stack: ..., word3, word2, word1 -> ..., word1, word3, word2, word1
- *
+ *
+ *
+ * Stack: ..., word3, word2, word1 -> ..., word1, word3, word2, word1
+ *
+ *
* @version $Id: DUP_X2.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class DUP_X2 extends StackInstruction {
- public DUP_X2() {
- super(org.apache.bcel.Constants.DUP_X2);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ public DUP_X2() {
+ super(org.apache.bcel.Constants.DUP_X2);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackInstruction(this);
- v.visitDUP_X2(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackInstruction(this);
+ v.visitDUP_X2(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/EmptyVisitor.java b/src/org/apache/bcel/generic/EmptyVisitor.java
index b28fecd..b56c77b 100644
--- a/src/org/apache/bcel/generic/EmptyVisitor.java
+++ b/src/org/apache/bcel/generic/EmptyVisitor.java
@@ -18,728 +18,729 @@ package org.apache.bcel.generic;
/**
* Supplies empty method bodies to be overridden by subclasses.
- *
+ *
* @version $Id: EmptyVisitor.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public abstract class EmptyVisitor implements Visitor {
- public void visitStackInstruction( StackInstruction obj ) {
- }
+ @Override
+ public void visitStackInstruction(StackInstruction obj) {
+ }
+ @Override
+ public void visitLocalVariableInstruction(LocalVariableInstruction obj) {
+ }
- public void visitLocalVariableInstruction( LocalVariableInstruction obj ) {
- }
+ @Override
+ public void visitBranchInstruction(BranchInstruction obj) {
+ }
+ @Override
+ public void visitLoadClass(LoadClass obj) {
+ }
- public void visitBranchInstruction( BranchInstruction obj ) {
- }
+ @Override
+ public void visitFieldInstruction(FieldInstruction obj) {
+ }
+ @Override
+ public void visitIfInstruction(IfInstruction obj) {
+ }
- public void visitLoadClass( LoadClass obj ) {
- }
+ @Override
+ public void visitConversionInstruction(ConversionInstruction obj) {
+ }
+ @Override
+ public void visitPopInstruction(PopInstruction obj) {
+ }
- public void visitFieldInstruction( FieldInstruction obj ) {
- }
+ @Override
+ public void visitJsrInstruction(JsrInstruction obj) {
+ }
+ @Override
+ public void visitGotoInstruction(GotoInstruction obj) {
+ }
- public void visitIfInstruction( IfInstruction obj ) {
- }
+ @Override
+ public void visitStoreInstruction(StoreInstruction obj) {
+ }
+ @Override
+ public void visitTypedInstruction(TypedInstruction obj) {
+ }
- public void visitConversionInstruction( ConversionInstruction obj ) {
- }
+ @Override
+ public void visitSelect(Select obj) {
+ }
+ @Override
+ public void visitUnconditionalBranch(UnconditionalBranch obj) {
+ }
- public void visitPopInstruction( PopInstruction obj ) {
- }
+ @Override
+ public void visitPushInstruction(PushInstruction obj) {
+ }
+ @Override
+ public void visitArithmeticInstruction(ArithmeticInstruction obj) {
+ }
- public void visitJsrInstruction( JsrInstruction obj ) {
- }
+ @Override
+ public void visitCPInstruction(CPInstruction obj) {
+ }
+ @Override
+ public void visitInvokeInstruction(InvokeInstruction obj) {
+ }
- public void visitGotoInstruction( GotoInstruction obj ) {
- }
+ @Override
+ public void visitArrayInstruction(ArrayInstruction obj) {
+ }
+ @Override
+ public void visitAllocationInstruction(AllocationInstruction obj) {
+ }
- public void visitStoreInstruction( StoreInstruction obj ) {
- }
+ @Override
+ public void visitReturnInstruction(ReturnInstruction obj) {
+ }
+ @Override
+ public void visitFieldOrMethod(FieldOrMethod obj) {
+ }
- public void visitTypedInstruction( TypedInstruction obj ) {
- }
+ @Override
+ public void visitConstantPushInstruction(ConstantPushInstruction obj) {
+ }
+ @Override
+ public void visitExceptionThrower(ExceptionThrower obj) {
+ }
- public void visitSelect( Select obj ) {
- }
+ @Override
+ public void visitLoadInstruction(LoadInstruction obj) {
+ }
+ @Override
+ public void visitVariableLengthInstruction(VariableLengthInstruction obj) {
+ }
- public void visitUnconditionalBranch( UnconditionalBranch obj ) {
- }
+ @Override
+ public void visitStackProducer(StackProducer obj) {
+ }
+ @Override
+ public void visitStackConsumer(StackConsumer obj) {
+ }
- public void visitPushInstruction( PushInstruction obj ) {
- }
+ @Override
+ public void visitACONST_NULL(ACONST_NULL obj) {
+ }
+ @Override
+ public void visitGETSTATIC(GETSTATIC obj) {
+ }
- public void visitArithmeticInstruction( ArithmeticInstruction obj ) {
- }
+ @Override
+ public void visitIF_ICMPLT(IF_ICMPLT obj) {
+ }
+ @Override
+ public void visitMONITOREXIT(MONITOREXIT obj) {
+ }
- public void visitCPInstruction( CPInstruction obj ) {
- }
+ @Override
+ public void visitIFLT(IFLT obj) {
+ }
+ @Override
+ public void visitLSTORE(LSTORE obj) {
+ }
- public void visitInvokeInstruction( InvokeInstruction obj ) {
- }
+ @Override
+ public void visitPOP2(POP2 obj) {
+ }
+ @Override
+ public void visitBASTORE(BASTORE obj) {
+ }
- public void visitArrayInstruction( ArrayInstruction obj ) {
- }
+ @Override
+ public void visitISTORE(ISTORE obj) {
+ }
+ @Override
+ public void visitCHECKCAST(CHECKCAST obj) {
+ }
- public void visitAllocationInstruction( AllocationInstruction obj ) {
- }
+ @Override
+ public void visitFCMPG(FCMPG obj) {
+ }
+ @Override
+ public void visitI2F(I2F obj) {
+ }
- public void visitReturnInstruction( ReturnInstruction obj ) {
- }
+ @Override
+ public void visitATHROW(ATHROW obj) {
+ }
+ @Override
+ public void visitDCMPL(DCMPL obj) {
+ }
- public void visitFieldOrMethod( FieldOrMethod obj ) {
- }
+ @Override
+ public void visitARRAYLENGTH(ARRAYLENGTH obj) {
+ }
+ @Override
+ public void visitDUP(DUP obj) {
+ }
- public void visitConstantPushInstruction( ConstantPushInstruction obj ) {
- }
+ @Override
+ public void visitINVOKESTATIC(INVOKESTATIC obj) {
+ }
+ @Override
+ public void visitLCONST(LCONST obj) {
+ }
- public void visitExceptionThrower( ExceptionThrower obj ) {
- }
+ @Override
+ public void visitDREM(DREM obj) {
+ }
+ @Override
+ public void visitIFGE(IFGE obj) {
+ }
- public void visitLoadInstruction( LoadInstruction obj ) {
- }
+ @Override
+ public void visitCALOAD(CALOAD obj) {
+ }
+ @Override
+ public void visitLASTORE(LASTORE obj) {
+ }
- public void visitVariableLengthInstruction( VariableLengthInstruction obj ) {
- }
+ @Override
+ public void visitI2D(I2D obj) {
+ }
+ @Override
+ public void visitDADD(DADD obj) {
+ }
- public void visitStackProducer( StackProducer obj ) {
- }
+ @Override
+ public void visitINVOKESPECIAL(INVOKESPECIAL obj) {
+ }
+ @Override
+ public void visitIAND(IAND obj) {
+ }
- public void visitStackConsumer( StackConsumer obj ) {
- }
+ @Override
+ public void visitPUTFIELD(PUTFIELD obj) {
+ }
+ @Override
+ public void visitILOAD(ILOAD obj) {
+ }
- public void visitACONST_NULL( ACONST_NULL obj ) {
- }
+ @Override
+ public void visitDLOAD(DLOAD obj) {
+ }
+ @Override
+ public void visitDCONST(DCONST obj) {
+ }
- public void visitGETSTATIC( GETSTATIC obj ) {
- }
+ @Override
+ public void visitNEW(NEW obj) {
+ }
+ @Override
+ public void visitIFNULL(IFNULL obj) {
+ }
- public void visitIF_ICMPLT( IF_ICMPLT obj ) {
- }
+ @Override
+ public void visitLSUB(LSUB obj) {
+ }
+ @Override
+ public void visitL2I(L2I obj) {
+ }
- public void visitMONITOREXIT( MONITOREXIT obj ) {
- }
+ @Override
+ public void visitISHR(ISHR obj) {
+ }
+ @Override
+ public void visitTABLESWITCH(TABLESWITCH obj) {
+ }
- public void visitIFLT( IFLT obj ) {
- }
+ @Override
+ public void visitIINC(IINC obj) {
+ }
+ @Override
+ public void visitDRETURN(DRETURN obj) {
+ }
- public void visitLSTORE( LSTORE obj ) {
- }
+ @Override
+ public void visitFSTORE(FSTORE obj) {
+ }
+ @Override
+ public void visitDASTORE(DASTORE obj) {
+ }
- public void visitPOP2( POP2 obj ) {
- }
+ @Override
+ public void visitIALOAD(IALOAD obj) {
+ }
+ @Override
+ public void visitDDIV(DDIV obj) {
+ }
- public void visitBASTORE( BASTORE obj ) {
- }
+ @Override
+ public void visitIF_ICMPGE(IF_ICMPGE obj) {
+ }
+ @Override
+ public void visitLAND(LAND obj) {
+ }
- public void visitISTORE( ISTORE obj ) {
- }
+ @Override
+ public void visitIDIV(IDIV obj) {
+ }
+ @Override
+ public void visitLOR(LOR obj) {
+ }
- public void visitCHECKCAST( CHECKCAST obj ) {
- }
+ @Override
+ public void visitCASTORE(CASTORE obj) {
+ }
+ @Override
+ public void visitFREM(FREM obj) {
+ }
- public void visitFCMPG( FCMPG obj ) {
- }
+ @Override
+ public void visitLDC(LDC obj) {
+ }
+ @Override
+ public void visitBIPUSH(BIPUSH obj) {
+ }
- public void visitI2F( I2F obj ) {
- }
+ @Override
+ public void visitDSTORE(DSTORE obj) {
+ }
+ @Override
+ public void visitF2L(F2L obj) {
+ }
- public void visitATHROW( ATHROW obj ) {
- }
+ @Override
+ public void visitFMUL(FMUL obj) {
+ }
+ @Override
+ public void visitLLOAD(LLOAD obj) {
+ }
- public void visitDCMPL( DCMPL obj ) {
- }
+ @Override
+ public void visitJSR(JSR obj) {
+ }
+ @Override
+ public void visitFSUB(FSUB obj) {
+ }
- public void visitARRAYLENGTH( ARRAYLENGTH obj ) {
- }
+ @Override
+ public void visitSASTORE(SASTORE obj) {
+ }
+ @Override
+ public void visitALOAD(ALOAD obj) {
+ }
- public void visitDUP( DUP obj ) {
- }
+ @Override
+ public void visitDUP2_X2(DUP2_X2 obj) {
+ }
+ @Override
+ public void visitRETURN(RETURN obj) {
+ }
- public void visitINVOKESTATIC( INVOKESTATIC obj ) {
- }
+ @Override
+ public void visitDALOAD(DALOAD obj) {
+ }
+ @Override
+ public void visitSIPUSH(SIPUSH obj) {
+ }
- public void visitLCONST( LCONST obj ) {
- }
+ @Override
+ public void visitDSUB(DSUB obj) {
+ }
+ @Override
+ public void visitL2F(L2F obj) {
+ }
- public void visitDREM( DREM obj ) {
- }
+ @Override
+ public void visitIF_ICMPGT(IF_ICMPGT obj) {
+ }
+ @Override
+ public void visitF2D(F2D obj) {
+ }
- public void visitIFGE( IFGE obj ) {
- }
+ @Override
+ public void visitI2L(I2L obj) {
+ }
+ @Override
+ public void visitIF_ACMPNE(IF_ACMPNE obj) {
+ }
- public void visitCALOAD( CALOAD obj ) {
- }
+ @Override
+ public void visitPOP(POP obj) {
+ }
+ @Override
+ public void visitI2S(I2S obj) {
+ }
- public void visitLASTORE( LASTORE obj ) {
- }
+ @Override
+ public void visitIFEQ(IFEQ obj) {
+ }
+ @Override
+ public void visitSWAP(SWAP obj) {
+ }
- public void visitI2D( I2D obj ) {
- }
+ @Override
+ public void visitIOR(IOR obj) {
+ }
+ @Override
+ public void visitIREM(IREM obj) {
+ }
- public void visitDADD( DADD obj ) {
- }
+ @Override
+ public void visitIASTORE(IASTORE obj) {
+ }
+ @Override
+ public void visitNEWARRAY(NEWARRAY obj) {
+ }
- public void visitINVOKESPECIAL( INVOKESPECIAL obj ) {
- }
+ @Override
+ public void visitINVOKEINTERFACE(INVOKEINTERFACE obj) {
+ }
+ @Override
+ public void visitINEG(INEG obj) {
+ }
- public void visitIAND( IAND obj ) {
- }
+ @Override
+ public void visitLCMP(LCMP obj) {
+ }
+ @Override
+ public void visitJSR_W(JSR_W obj) {
+ }
- public void visitPUTFIELD( PUTFIELD obj ) {
- }
+ @Override
+ public void visitMULTIANEWARRAY(MULTIANEWARRAY obj) {
+ }
+ @Override
+ public void visitDUP_X2(DUP_X2 obj) {
+ }
- public void visitILOAD( ILOAD obj ) {
- }
+ @Override
+ public void visitSALOAD(SALOAD obj) {
+ }
+ @Override
+ public void visitIFNONNULL(IFNONNULL obj) {
+ }
- public void visitDLOAD( DLOAD obj ) {
- }
+ @Override
+ public void visitDMUL(DMUL obj) {
+ }
+ @Override
+ public void visitIFNE(IFNE obj) {
+ }
- public void visitDCONST( DCONST obj ) {
- }
+ @Override
+ public void visitIF_ICMPLE(IF_ICMPLE obj) {
+ }
+ @Override
+ public void visitLDC2_W(LDC2_W obj) {
+ }
- public void visitNEW( NEW obj ) {
- }
+ @Override
+ public void visitGETFIELD(GETFIELD obj) {
+ }
+ @Override
+ public void visitLADD(LADD obj) {
+ }
- public void visitIFNULL( IFNULL obj ) {
- }
+ @Override
+ public void visitNOP(NOP obj) {
+ }
+ @Override
+ public void visitFALOAD(FALOAD obj) {
+ }
- public void visitLSUB( LSUB obj ) {
- }
+ @Override
+ public void visitINSTANCEOF(INSTANCEOF obj) {
+ }
+ @Override
+ public void visitIFLE(IFLE obj) {
+ }
- public void visitL2I( L2I obj ) {
- }
+ @Override
+ public void visitLXOR(LXOR obj) {
+ }
+ @Override
+ public void visitLRETURN(LRETURN obj) {
+ }
- public void visitISHR( ISHR obj ) {
- }
+ @Override
+ public void visitFCONST(FCONST obj) {
+ }
+ @Override
+ public void visitIUSHR(IUSHR obj) {
+ }
- public void visitTABLESWITCH( TABLESWITCH obj ) {
- }
+ @Override
+ public void visitBALOAD(BALOAD obj) {
+ }
+ @Override
+ public void visitDUP2(DUP2 obj) {
+ }
- public void visitIINC( IINC obj ) {
- }
+ @Override
+ public void visitIF_ACMPEQ(IF_ACMPEQ obj) {
+ }
+ @Override
+ public void visitIMPDEP1(IMPDEP1 obj) {
+ }
- public void visitDRETURN( DRETURN obj ) {
- }
+ @Override
+ public void visitMONITORENTER(MONITORENTER obj) {
+ }
+ @Override
+ public void visitLSHL(LSHL obj) {
+ }
- public void visitFSTORE( FSTORE obj ) {
- }
+ @Override
+ public void visitDCMPG(DCMPG obj) {
+ }
+ @Override
+ public void visitD2L(D2L obj) {
+ }
- public void visitDASTORE( DASTORE obj ) {
- }
+ @Override
+ public void visitIMPDEP2(IMPDEP2 obj) {
+ }
+ @Override
+ public void visitL2D(L2D obj) {
+ }
- public void visitIALOAD( IALOAD obj ) {
- }
+ @Override
+ public void visitRET(RET obj) {
+ }
+ @Override
+ public void visitIFGT(IFGT obj) {
+ }
- public void visitDDIV( DDIV obj ) {
- }
+ @Override
+ public void visitIXOR(IXOR obj) {
+ }
+ @Override
+ public void visitINVOKEVIRTUAL(INVOKEVIRTUAL obj) {
+ }
- public void visitIF_ICMPGE( IF_ICMPGE obj ) {
- }
+ @Override
+ public void visitFASTORE(FASTORE obj) {
+ }
+ @Override
+ public void visitIRETURN(IRETURN obj) {
+ }
- public void visitLAND( LAND obj ) {
- }
+ @Override
+ public void visitIF_ICMPNE(IF_ICMPNE obj) {
+ }
+ @Override
+ public void visitFLOAD(FLOAD obj) {
+ }
- public void visitIDIV( IDIV obj ) {
- }
+ @Override
+ public void visitLDIV(LDIV obj) {
+ }
+ @Override
+ public void visitPUTSTATIC(PUTSTATIC obj) {
+ }
- public void visitLOR( LOR obj ) {
- }
+ @Override
+ public void visitAALOAD(AALOAD obj) {
+ }
+ @Override
+ public void visitD2I(D2I obj) {
+ }
- public void visitCASTORE( CASTORE obj ) {
- }
+ @Override
+ public void visitIF_ICMPEQ(IF_ICMPEQ obj) {
+ }
+ @Override
+ public void visitAASTORE(AASTORE obj) {
+ }
- public void visitFREM( FREM obj ) {
- }
+ @Override
+ public void visitARETURN(ARETURN obj) {
+ }
+ @Override
+ public void visitDUP2_X1(DUP2_X1 obj) {
+ }
- public void visitLDC( LDC obj ) {
- }
+ @Override
+ public void visitFNEG(FNEG obj) {
+ }
+ @Override
+ public void visitGOTO_W(GOTO_W obj) {
+ }
- public void visitBIPUSH( BIPUSH obj ) {
- }
+ @Override
+ public void visitD2F(D2F obj) {
+ }
+ @Override
+ public void visitGOTO(GOTO obj) {
+ }
- public void visitDSTORE( DSTORE obj ) {
- }
+ @Override
+ public void visitISUB(ISUB obj) {
+ }
+ @Override
+ public void visitF2I(F2I obj) {
+ }
- public void visitF2L( F2L obj ) {
- }
+ @Override
+ public void visitDNEG(DNEG obj) {
+ }
+ @Override
+ public void visitICONST(ICONST obj) {
+ }
- public void visitFMUL( FMUL obj ) {
- }
+ @Override
+ public void visitFDIV(FDIV obj) {
+ }
+ @Override
+ public void visitI2B(I2B obj) {
+ }
- public void visitLLOAD( LLOAD obj ) {
- }
+ @Override
+ public void visitLNEG(LNEG obj) {
+ }
+ @Override
+ public void visitLREM(LREM obj) {
+ }
- public void visitJSR( JSR obj ) {
- }
+ @Override
+ public void visitIMUL(IMUL obj) {
+ }
+ @Override
+ public void visitIADD(IADD obj) {
+ }
- public void visitFSUB( FSUB obj ) {
- }
+ @Override
+ public void visitLSHR(LSHR obj) {
+ }
+ @Override
+ public void visitLOOKUPSWITCH(LOOKUPSWITCH obj) {
+ }
- public void visitSASTORE( SASTORE obj ) {
- }
+ @Override
+ public void visitDUP_X1(DUP_X1 obj) {
+ }
+ @Override
+ public void visitFCMPL(FCMPL obj) {
+ }
- public void visitALOAD( ALOAD obj ) {
- }
+ @Override
+ public void visitI2C(I2C obj) {
+ }
+ @Override
+ public void visitLMUL(LMUL obj) {
+ }
- public void visitDUP2_X2( DUP2_X2 obj ) {
- }
+ @Override
+ public void visitLUSHR(LUSHR obj) {
+ }
+ @Override
+ public void visitISHL(ISHL obj) {
+ }
- public void visitRETURN( RETURN obj ) {
- }
+ @Override
+ public void visitLALOAD(LALOAD obj) {
+ }
+ @Override
+ public void visitASTORE(ASTORE obj) {
+ }
- public void visitDALOAD( DALOAD obj ) {
- }
+ @Override
+ public void visitANEWARRAY(ANEWARRAY obj) {
+ }
+ @Override
+ public void visitFRETURN(FRETURN obj) {
+ }
- public void visitSIPUSH( SIPUSH obj ) {
- }
+ @Override
+ public void visitFADD(FADD obj) {
+ }
-
- public void visitDSUB( DSUB obj ) {
- }
-
-
- public void visitL2F( L2F obj ) {
- }
-
-
- public void visitIF_ICMPGT( IF_ICMPGT obj ) {
- }
-
-
- public void visitF2D( F2D obj ) {
- }
-
-
- public void visitI2L( I2L obj ) {
- }
-
-
- public void visitIF_ACMPNE( IF_ACMPNE obj ) {
- }
-
-
- public void visitPOP( POP obj ) {
- }
-
-
- public void visitI2S( I2S obj ) {
- }
-
-
- public void visitIFEQ( IFEQ obj ) {
- }
-
-
- public void visitSWAP( SWAP obj ) {
- }
-
-
- public void visitIOR( IOR obj ) {
- }
-
-
- public void visitIREM( IREM obj ) {
- }
-
-
- public void visitIASTORE( IASTORE obj ) {
- }
-
-
- public void visitNEWARRAY( NEWARRAY obj ) {
- }
-
-
- public void visitINVOKEINTERFACE( INVOKEINTERFACE obj ) {
- }
-
-
- public void visitINEG( INEG obj ) {
- }
-
-
- public void visitLCMP( LCMP obj ) {
- }
-
-
- public void visitJSR_W( JSR_W obj ) {
- }
-
-
- public void visitMULTIANEWARRAY( MULTIANEWARRAY obj ) {
- }
-
-
- public void visitDUP_X2( DUP_X2 obj ) {
- }
-
-
- public void visitSALOAD( SALOAD obj ) {
- }
-
-
- public void visitIFNONNULL( IFNONNULL obj ) {
- }
-
-
- public void visitDMUL( DMUL obj ) {
- }
-
-
- public void visitIFNE( IFNE obj ) {
- }
-
-
- public void visitIF_ICMPLE( IF_ICMPLE obj ) {
- }
-
-
- public void visitLDC2_W( LDC2_W obj ) {
- }
-
-
- public void visitGETFIELD( GETFIELD obj ) {
- }
-
-
- public void visitLADD( LADD obj ) {
- }
-
-
- public void visitNOP( NOP obj ) {
- }
-
-
- public void visitFALOAD( FALOAD obj ) {
- }
-
-
- public void visitINSTANCEOF( INSTANCEOF obj ) {
- }
-
-
- public void visitIFLE( IFLE obj ) {
- }
-
-
- public void visitLXOR( LXOR obj ) {
- }
-
-
- public void visitLRETURN( LRETURN obj ) {
- }
-
-
- public void visitFCONST( FCONST obj ) {
- }
-
-
- public void visitIUSHR( IUSHR obj ) {
- }
-
-
- public void visitBALOAD( BALOAD obj ) {
- }
-
-
- public void visitDUP2( DUP2 obj ) {
- }
-
-
- public void visitIF_ACMPEQ( IF_ACMPEQ obj ) {
- }
-
-
- public void visitIMPDEP1( IMPDEP1 obj ) {
- }
-
-
- public void visitMONITORENTER( MONITORENTER obj ) {
- }
-
-
- public void visitLSHL( LSHL obj ) {
- }
-
-
- public void visitDCMPG( DCMPG obj ) {
- }
-
-
- public void visitD2L( D2L obj ) {
- }
-
-
- public void visitIMPDEP2( IMPDEP2 obj ) {
- }
-
-
- public void visitL2D( L2D obj ) {
- }
-
-
- public void visitRET( RET obj ) {
- }
-
-
- public void visitIFGT( IFGT obj ) {
- }
-
-
- public void visitIXOR( IXOR obj ) {
- }
-
-
- public void visitINVOKEVIRTUAL( INVOKEVIRTUAL obj ) {
- }
-
-
- public void visitFASTORE( FASTORE obj ) {
- }
-
-
- public void visitIRETURN( IRETURN obj ) {
- }
-
-
- public void visitIF_ICMPNE( IF_ICMPNE obj ) {
- }
-
-
- public void visitFLOAD( FLOAD obj ) {
- }
-
-
- public void visitLDIV( LDIV obj ) {
- }
-
-
- public void visitPUTSTATIC( PUTSTATIC obj ) {
- }
-
-
- public void visitAALOAD( AALOAD obj ) {
- }
-
-
- public void visitD2I( D2I obj ) {
- }
-
-
- public void visitIF_ICMPEQ( IF_ICMPEQ obj ) {
- }
-
-
- public void visitAASTORE( AASTORE obj ) {
- }
-
-
- public void visitARETURN( ARETURN obj ) {
- }
-
-
- public void visitDUP2_X1( DUP2_X1 obj ) {
- }
-
-
- public void visitFNEG( FNEG obj ) {
- }
-
-
- public void visitGOTO_W( GOTO_W obj ) {
- }
-
-
- public void visitD2F( D2F obj ) {
- }
-
-
- public void visitGOTO( GOTO obj ) {
- }
-
-
- public void visitISUB( ISUB obj ) {
- }
-
-
- public void visitF2I( F2I obj ) {
- }
-
-
- public void visitDNEG( DNEG obj ) {
- }
-
-
- public void visitICONST( ICONST obj ) {
- }
-
-
- public void visitFDIV( FDIV obj ) {
- }
-
-
- public void visitI2B( I2B obj ) {
- }
-
-
- public void visitLNEG( LNEG obj ) {
- }
-
-
- public void visitLREM( LREM obj ) {
- }
-
-
- public void visitIMUL( IMUL obj ) {
- }
-
-
- public void visitIADD( IADD obj ) {
- }
-
-
- public void visitLSHR( LSHR obj ) {
- }
-
-
- public void visitLOOKUPSWITCH( LOOKUPSWITCH obj ) {
- }
-
-
- public void visitDUP_X1( DUP_X1 obj ) {
- }
-
-
- public void visitFCMPL( FCMPL obj ) {
- }
-
-
- public void visitI2C( I2C obj ) {
- }
-
-
- public void visitLMUL( LMUL obj ) {
- }
-
-
- public void visitLUSHR( LUSHR obj ) {
- }
-
-
- public void visitISHL( ISHL obj ) {
- }
-
-
- public void visitLALOAD( LALOAD obj ) {
- }
-
-
- public void visitASTORE( ASTORE obj ) {
- }
-
-
- public void visitANEWARRAY( ANEWARRAY obj ) {
- }
-
-
- public void visitFRETURN( FRETURN obj ) {
- }
-
-
- public void visitFADD( FADD obj ) {
- }
-
-
- public void visitBREAKPOINT( BREAKPOINT obj ) {
- }
+ @Override
+ public void visitBREAKPOINT(BREAKPOINT obj) {
+ }
}
diff --git a/src/org/apache/bcel/generic/ExceptionThrower.java b/src/org/apache/bcel/generic/ExceptionThrower.java
index 570f47c..706e2c8 100644
--- a/src/org/apache/bcel/generic/ExceptionThrower.java
+++ b/src/org/apache/bcel/generic/ExceptionThrower.java
@@ -17,26 +17,24 @@
package org.apache.bcel.generic;
/**
- * Denote an instruction that may throw a run-time or a linking
- * exception (or both) during execution. This is not quite the truth
- * as such; because all instructions may throw an
- * java.lang.VirtualMachineError. These exceptions are omitted.
+ * Denote an instruction that may throw a run-time or a linking exception (or
+ * both) during execution. This is not quite the truth as such; because all
+ * instructions may throw an java.lang.VirtualMachineError. These exceptions are
+ * omitted.
*
- * The Lava Language Specification specifies exactly which
- * RUN-TIME and which LINKING exceptions each
- * instruction may throw which is reflected by the implementers. Due
- * to the structure of the JVM specification, it may be possible that
- * an Instruction implementing this interface returns a Class[] of
+ * The Lava Language Specification specifies exactly which RUN-TIME and
+ * which LINKING exceptions each instruction may throw which is reflected
+ * by the implementers. Due to the structure of the JVM specification, it may be
+ * possible that an Instruction implementing this interface returns a Class[] of
* size 0.
- *
- * Please note that we speak of an "exception" here when we mean any
- * "Throwable" object; so this term is equally used for "Exception"
- * and "Error" objects.
- *
+ *
+ * Please note that we speak of an "exception" here when we mean any "Throwable"
+ * object; so this term is equally used for "Exception" and "Error" objects.
+ *
* @version $Id: ExceptionThrower.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author Enver Haase
+ * @author Enver Haase
*/
public interface ExceptionThrower {
- public java.lang.Class[] getExceptions();
+ public java.lang.Class[] getExceptions();
}
diff --git a/src/org/apache/bcel/generic/F2D.java b/src/org/apache/bcel/generic/F2D.java
index b3f9ac1..a924f43 100644
--- a/src/org/apache/bcel/generic/F2D.java
+++ b/src/org/apache/bcel/generic/F2D.java
@@ -16,35 +16,45 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* F2D - Convert float to double
- * Stack: ..., value -> ..., result.word1, result.word2
- *
+ *
+ *
+ * Stack: ..., value -> ..., result.word1, result.word2
+ *
+ *
* @version $Id: F2D.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class F2D extends ConversionInstruction {
- /** Convert float to double
- */
- public F2D() {
- super(org.apache.bcel.Constants.F2D);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Convert float to double
+ */
+ public F2D() {
+ super(org.apache.bcel.Constants.F2D);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitConversionInstruction(this);
- v.visitF2D(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitConversionInstruction(this);
+ v.visitF2D(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/F2I.java b/src/org/apache/bcel/generic/F2I.java
index 155d019..31126f0 100644
--- a/src/org/apache/bcel/generic/F2I.java
+++ b/src/org/apache/bcel/generic/F2I.java
@@ -16,35 +16,45 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* F2I - Convert float to int
- * Stack: ..., value -> ..., result
- *
+ *
+ *
+ * Stack: ..., value -> ..., result
+ *
+ *
* @version $Id: F2I.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class F2I extends ConversionInstruction {
- /** Convert float to int
- */
- public F2I() {
- super(org.apache.bcel.Constants.F2I);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Convert float to int
+ */
+ public F2I() {
+ super(org.apache.bcel.Constants.F2I);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitConversionInstruction(this);
- v.visitF2I(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitConversionInstruction(this);
+ v.visitF2I(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/F2L.java b/src/org/apache/bcel/generic/F2L.java
index 83ede65..a0bd284 100644
--- a/src/org/apache/bcel/generic/F2L.java
+++ b/src/org/apache/bcel/generic/F2L.java
@@ -16,35 +16,45 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* F2L - Convert float to long
- * Stack: ..., value -> ..., result.word1, result.word2
- *
+ *
+ *
+ * Stack: ..., value -> ..., result.word1, result.word2
+ *
+ *
* @version $Id: F2L.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class F2L extends ConversionInstruction {
- /** Convert float to long
- */
- public F2L() {
- super(org.apache.bcel.Constants.F2L);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Convert float to long
+ */
+ public F2L() {
+ super(org.apache.bcel.Constants.F2L);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitConversionInstruction(this);
- v.visitF2L(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitConversionInstruction(this);
+ v.visitF2L(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/FADD.java b/src/org/apache/bcel/generic/FADD.java
index 88dcb1e..e08e360 100644
--- a/src/org/apache/bcel/generic/FADD.java
+++ b/src/org/apache/bcel/generic/FADD.java
@@ -16,35 +16,45 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* FADD - Add floats
- * Stack: ..., value1, value2 -> result
- *
+ *
+ *
+ * Stack: ..., value1, value2 -> result
+ *
+ *
* @version $Id: FADD.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class FADD extends ArithmeticInstruction {
- /** Add floats
- */
- public FADD() {
- super(org.apache.bcel.Constants.FADD);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Add floats
+ */
+ public FADD() {
+ super(org.apache.bcel.Constants.FADD);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitArithmeticInstruction(this);
- v.visitFADD(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitArithmeticInstruction(this);
+ v.visitFADD(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/FALOAD.java b/src/org/apache/bcel/generic/FALOAD.java
index 06fb7a3..c718f6a 100644
--- a/src/org/apache/bcel/generic/FALOAD.java
+++ b/src/org/apache/bcel/generic/FALOAD.java
@@ -16,35 +16,45 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* FALOAD - Load float from array
- * Stack: ..., arrayref, index -> ..., value
- *
+ *
+ *
+ * Stack: ..., arrayref, index -> ..., value
+ *
+ *
* @version $Id: FALOAD.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class FALOAD extends ArrayInstruction implements StackProducer {
- /** Load float from array
- */
- public FALOAD() {
- super(org.apache.bcel.Constants.FALOAD);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Load float from array
+ */
+ public FALOAD() {
+ super(org.apache.bcel.Constants.FALOAD);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackProducer(this);
- v.visitExceptionThrower(this);
- v.visitTypedInstruction(this);
- v.visitArrayInstruction(this);
- v.visitFALOAD(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackProducer(this);
+ v.visitExceptionThrower(this);
+ v.visitTypedInstruction(this);
+ v.visitArrayInstruction(this);
+ v.visitFALOAD(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/FASTORE.java b/src/org/apache/bcel/generic/FASTORE.java
index 1545b49..4e8e13e 100644
--- a/src/org/apache/bcel/generic/FASTORE.java
+++ b/src/org/apache/bcel/generic/FASTORE.java
@@ -16,35 +16,45 @@
*/
package org.apache.bcel.generic;
-/**
- * FASTORE - Store into float array
- * Stack: ..., arrayref, index, value -> ...
- *
+/**
+ * FASTORE - Store into float array
+ *
+ *
+ * Stack: ..., arrayref, index, value -> ...
+ *
+ *
* @version $Id: FASTORE.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class FASTORE extends ArrayInstruction implements StackConsumer {
- /** Store float into array
- */
- public FASTORE() {
- super(org.apache.bcel.Constants.FASTORE);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Store float into array
+ */
+ public FASTORE() {
+ super(org.apache.bcel.Constants.FASTORE);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackConsumer(this);
- v.visitExceptionThrower(this);
- v.visitTypedInstruction(this);
- v.visitArrayInstruction(this);
- v.visitFASTORE(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackConsumer(this);
+ v.visitExceptionThrower(this);
+ v.visitTypedInstruction(this);
+ v.visitArrayInstruction(this);
+ v.visitFASTORE(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/FCMPG.java b/src/org/apache/bcel/generic/FCMPG.java
index 9ff626e..da9504c 100644
--- a/src/org/apache/bcel/generic/FCMPG.java
+++ b/src/org/apache/bcel/generic/FCMPG.java
@@ -16,39 +16,50 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* FCMPG - Compare floats: value1 > value2
- * Stack: ..., value1, value2 -> ..., result
- *
+ *
+ *
+ * Stack: ..., value1, value2 -> ..., result
+ *
+ *
* @version $Id: FCMPG.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
-public class FCMPG extends Instruction implements TypedInstruction, StackProducer, StackConsumer {
+public class FCMPG extends Instruction implements TypedInstruction,
+ StackProducer, StackConsumer {
- public FCMPG() {
- super(org.apache.bcel.Constants.FCMPG, (short) 1);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ public FCMPG() {
+ super(org.apache.bcel.Constants.FCMPG, (short) 1);
+ }
- /** @return Type.FLOAT
- */
- public Type getType( ConstantPoolGen cp ) {
- return Type.FLOAT;
- }
+ /**
+ * @return Type.FLOAT
+ */
+ @Override
+ public Type getType(ConstantPoolGen cp) {
+ return Type.FLOAT;
+ }
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitFCMPG(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitFCMPG(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/FCMPL.java b/src/org/apache/bcel/generic/FCMPL.java
index 7bc4bf2..5ca6078 100644
--- a/src/org/apache/bcel/generic/FCMPL.java
+++ b/src/org/apache/bcel/generic/FCMPL.java
@@ -16,39 +16,50 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* FCMPL - Compare floats: value1 < value2
- * Stack: ..., value1, value2 -> ..., result
- *
+ *
+ *
+ * Stack: ..., value1, value2 -> ..., result
+ *
+ *
* @version $Id: FCMPL.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
-public class FCMPL extends Instruction implements TypedInstruction, StackProducer, StackConsumer {
+public class FCMPL extends Instruction implements TypedInstruction,
+ StackProducer, StackConsumer {
- public FCMPL() {
- super(org.apache.bcel.Constants.FCMPL, (short) 1);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ public FCMPL() {
+ super(org.apache.bcel.Constants.FCMPL, (short) 1);
+ }
- /** @return Type.FLOAT
- */
- public Type getType( ConstantPoolGen cp ) {
- return Type.FLOAT;
- }
+ /**
+ * @return Type.FLOAT
+ */
+ @Override
+ public Type getType(ConstantPoolGen cp) {
+ return Type.FLOAT;
+ }
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitFCMPL(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitFCMPL(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/FCONST.java b/src/org/apache/bcel/generic/FCONST.java
index 30bb0dc..3f0c2dd 100644
--- a/src/org/apache/bcel/generic/FCONST.java
+++ b/src/org/apache/bcel/generic/FCONST.java
@@ -16,67 +16,75 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* FCONST - Push 0.0, 1.0 or 2.0, other values cause an exception
- *
- * Stack: ... -> ...,
- *
+ *
+ *
+ * Stack: ... -> ...,
+ *
+ *
* @version $Id: FCONST.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
-public class FCONST extends Instruction implements ConstantPushInstruction, TypedInstruction {
+public class FCONST extends Instruction implements ConstantPushInstruction,
+ TypedInstruction {
- private float value;
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ private float value;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ FCONST() {
+ }
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- FCONST() {
- }
+ public FCONST(float f) {
+ super(org.apache.bcel.Constants.FCONST_0, (short) 1);
+ if (f == 0.0) {
+ opcode = org.apache.bcel.Constants.FCONST_0;
+ } else if (f == 1.0) {
+ opcode = org.apache.bcel.Constants.FCONST_1;
+ } else if (f == 2.0) {
+ opcode = org.apache.bcel.Constants.FCONST_2;
+ } else {
+ throw new ClassGenException(
+ "FCONST can be used only for 0.0, 1.0 and 2.0: " + f);
+ }
+ value = f;
+ }
+ @Override
+ public Number getValue() {
+ return new Float(value);
+ }
- public FCONST(float f) {
- super(org.apache.bcel.Constants.FCONST_0, (short) 1);
- if (f == 0.0) {
- opcode = org.apache.bcel.Constants.FCONST_0;
- } else if (f == 1.0) {
- opcode = org.apache.bcel.Constants.FCONST_1;
- } else if (f == 2.0) {
- opcode = org.apache.bcel.Constants.FCONST_2;
- } else {
- throw new ClassGenException("FCONST can be used only for 0.0, 1.0 and 2.0: " + f);
- }
- value = f;
- }
+ /**
+ * @return Type.FLOAT
+ */
+ @Override
+ public Type getType(ConstantPoolGen cp) {
+ return Type.FLOAT;
+ }
-
- public Number getValue() {
- return new Float(value);
- }
-
-
- /** @return Type.FLOAT
- */
- public Type getType( ConstantPoolGen cp ) {
- return Type.FLOAT;
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitPushInstruction(this);
- v.visitStackProducer(this);
- v.visitTypedInstruction(this);
- v.visitConstantPushInstruction(this);
- v.visitFCONST(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitPushInstruction(this);
+ v.visitStackProducer(this);
+ v.visitTypedInstruction(this);
+ v.visitConstantPushInstruction(this);
+ v.visitFCONST(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/FDIV.java b/src/org/apache/bcel/generic/FDIV.java
index 72a2019..5d8a840 100644
--- a/src/org/apache/bcel/generic/FDIV.java
+++ b/src/org/apache/bcel/generic/FDIV.java
@@ -18,33 +18,43 @@ package org.apache.bcel.generic;
/**
* FDIV - Divide floats
- * Stack: ..., value1, value2 -> result
- *
+ *
+ *
+ * Stack: ..., value1, value2 -> result
+ *
+ *
* @version $Id: FDIV.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class FDIV extends ArithmeticInstruction {
- /** Divide floats
- */
- public FDIV() {
- super(org.apache.bcel.Constants.FDIV);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Divide floats
+ */
+ public FDIV() {
+ super(org.apache.bcel.Constants.FDIV);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitArithmeticInstruction(this);
- v.visitFDIV(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitArithmeticInstruction(this);
+ v.visitFDIV(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/FLOAD.java b/src/org/apache/bcel/generic/FLOAD.java
index beda2cb..5781361 100644
--- a/src/org/apache/bcel/generic/FLOAD.java
+++ b/src/org/apache/bcel/generic/FLOAD.java
@@ -16,42 +16,55 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* FLOAD - Load float from local variable
- * Stack ... -> ..., result
- *
+ *
+ *
+ * Stack ... -> ..., result
+ *
+ *
* @version $Id: FLOAD.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class FLOAD extends LoadInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- FLOAD() {
- super(org.apache.bcel.Constants.FLOAD, org.apache.bcel.Constants.FLOAD_0);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ FLOAD() {
+ super(org.apache.bcel.Constants.FLOAD,
+ org.apache.bcel.Constants.FLOAD_0);
+ }
- /** Load float from local variable
- * @param n index of local variable
- */
- public FLOAD(int n) {
- super(org.apache.bcel.Constants.FLOAD, org.apache.bcel.Constants.FLOAD_0, n);
- }
+ /**
+ * Load float from local variable
+ *
+ * @param n
+ * index of local variable
+ */
+ public FLOAD(int n) {
+ super(org.apache.bcel.Constants.FLOAD,
+ org.apache.bcel.Constants.FLOAD_0, n);
+ }
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- super.accept(v);
- v.visitFLOAD(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ super.accept(v);
+ v.visitFLOAD(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/FMUL.java b/src/org/apache/bcel/generic/FMUL.java
index 2375ffe..90c21b0 100644
--- a/src/org/apache/bcel/generic/FMUL.java
+++ b/src/org/apache/bcel/generic/FMUL.java
@@ -18,33 +18,43 @@ package org.apache.bcel.generic;
/**
* FMUL - Multiply floats
- * Stack: ..., value1, value2 -> result
- *
+ *
+ *
+ * Stack: ..., value1, value2 -> result
+ *
+ *
* @version $Id: FMUL.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class FMUL extends ArithmeticInstruction {
- /** Multiply floats
- */
- public FMUL() {
- super(org.apache.bcel.Constants.FMUL);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Multiply floats
+ */
+ public FMUL() {
+ super(org.apache.bcel.Constants.FMUL);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitArithmeticInstruction(this);
- v.visitFMUL(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitArithmeticInstruction(this);
+ v.visitFMUL(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/FNEG.java b/src/org/apache/bcel/generic/FNEG.java
index a1c03ec..fe31946 100644
--- a/src/org/apache/bcel/generic/FNEG.java
+++ b/src/org/apache/bcel/generic/FNEG.java
@@ -16,33 +16,42 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* FNEG - Negate float
- * Stack: ..., value -> ..., result
- *
+ *
+ *
+ * Stack: ..., value -> ..., result
+ *
+ *
* @version $Id: FNEG.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class FNEG extends ArithmeticInstruction {
- public FNEG() {
- super(org.apache.bcel.Constants.FNEG);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ public FNEG() {
+ super(org.apache.bcel.Constants.FNEG);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitArithmeticInstruction(this);
- v.visitFNEG(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitArithmeticInstruction(this);
+ v.visitFNEG(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/FREM.java b/src/org/apache/bcel/generic/FREM.java
index 6227a63..4ded950 100644
--- a/src/org/apache/bcel/generic/FREM.java
+++ b/src/org/apache/bcel/generic/FREM.java
@@ -18,33 +18,43 @@ package org.apache.bcel.generic;
/**
* FREM - Remainder of floats
- * Stack: ..., value1, value2 -> result
- *
+ *
+ *
+ * Stack: ..., value1, value2 -> result
+ *
+ *
* @version $Id: FREM.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class FREM extends ArithmeticInstruction {
- /** Remainder of floats
- */
- public FREM() {
- super(org.apache.bcel.Constants.FREM);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Remainder of floats
+ */
+ public FREM() {
+ super(org.apache.bcel.Constants.FREM);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitArithmeticInstruction(this);
- v.visitFREM(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitArithmeticInstruction(this);
+ v.visitFREM(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/FRETURN.java b/src/org/apache/bcel/generic/FRETURN.java
index 4676840..0946b65 100644
--- a/src/org/apache/bcel/generic/FRETURN.java
+++ b/src/org/apache/bcel/generic/FRETURN.java
@@ -16,35 +16,45 @@
*/
package org.apache.bcel.generic;
-/**
- * FRETURN - Return float from method
- * Stack: ..., value -> <empty>
- *
+/**
+ * FRETURN - Return float from method
+ *
+ *
+ * Stack: ..., value -> <empty>
+ *
+ *
* @version $Id: FRETURN.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class FRETURN extends ReturnInstruction {
- /** Return float from method
- */
- public FRETURN() {
- super(org.apache.bcel.Constants.FRETURN);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Return float from method
+ */
+ public FRETURN() {
+ super(org.apache.bcel.Constants.FRETURN);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitExceptionThrower(this);
- v.visitTypedInstruction(this);
- v.visitStackConsumer(this);
- v.visitReturnInstruction(this);
- v.visitFRETURN(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitExceptionThrower(this);
+ v.visitTypedInstruction(this);
+ v.visitStackConsumer(this);
+ v.visitReturnInstruction(this);
+ v.visitFRETURN(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/FSTORE.java b/src/org/apache/bcel/generic/FSTORE.java
index ec4b950..fe0b2b7 100644
--- a/src/org/apache/bcel/generic/FSTORE.java
+++ b/src/org/apache/bcel/generic/FSTORE.java
@@ -16,42 +16,55 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* FSTORE - Store float into local variable
- * Stack: ..., value -> ...
- *
+ *
+ *
+ * Stack: ..., value -> ...
+ *
+ *
* @version $Id: FSTORE.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class FSTORE extends StoreInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- FSTORE() {
- super(org.apache.bcel.Constants.FSTORE, org.apache.bcel.Constants.FSTORE_0);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ FSTORE() {
+ super(org.apache.bcel.Constants.FSTORE,
+ org.apache.bcel.Constants.FSTORE_0);
+ }
- /** Store float into local variable
- * @param n index of local variable
- */
- public FSTORE(int n) {
- super(org.apache.bcel.Constants.FSTORE, org.apache.bcel.Constants.FSTORE_0, n);
- }
+ /**
+ * Store float into local variable
+ *
+ * @param n
+ * index of local variable
+ */
+ public FSTORE(int n) {
+ super(org.apache.bcel.Constants.FSTORE,
+ org.apache.bcel.Constants.FSTORE_0, n);
+ }
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- super.accept(v);
- v.visitFSTORE(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ super.accept(v);
+ v.visitFSTORE(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/FSUB.java b/src/org/apache/bcel/generic/FSUB.java
index 90a8dbb..7aab799 100644
--- a/src/org/apache/bcel/generic/FSUB.java
+++ b/src/org/apache/bcel/generic/FSUB.java
@@ -18,33 +18,43 @@ package org.apache.bcel.generic;
/**
* FSUB - Substract floats
- * Stack: ..., value1, value2 -> result
- *
+ *
+ *
+ * Stack: ..., value1, value2 -> result
+ *
+ *
* @version $Id: FSUB.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class FSUB extends ArithmeticInstruction {
- /** Substract floats
- */
- public FSUB() {
- super(org.apache.bcel.Constants.FSUB);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Substract floats
+ */
+ public FSUB() {
+ super(org.apache.bcel.Constants.FSUB);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitArithmeticInstruction(this);
- v.visitFSUB(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitArithmeticInstruction(this);
+ v.visitFSUB(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/FieldGen.java b/src/org/apache/bcel/generic/FieldGen.java
index d9af25f..71658e2 100644
--- a/src/org/apache/bcel/generic/FieldGen.java
+++ b/src/org/apache/bcel/generic/FieldGen.java
@@ -29,329 +29,328 @@ import org.apache.bcel.classfile.Field;
import org.apache.bcel.classfile.Utility;
import org.apache.bcel.util.BCELComparator;
-/**
- * Template class for building up a field. The only extraordinary thing
- * one can do is to add a constant value attribute to a field (which must of
- * course be compatible with to the declared type).
- *
+/**
+ * Template class for building up a field. The only extraordinary thing one can
+ * do is to add a constant value attribute to a field (which must of course be
+ * compatible with to the declared type).
+ *
* @version $Id: FieldGen.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
* @see Field
*/
public class FieldGen extends FieldGenOrMethodGen {
- private Object value = null;
- private static BCELComparator _cmp = new BCELComparator() {
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ private Object value = null;
+ private static BCELComparator _cmp = new BCELComparator() {
- public boolean equals( Object o1, Object o2 ) {
- FieldGen THIS = (FieldGen) o1;
- FieldGen THAT = (FieldGen) o2;
- return THIS.getName().equals(THAT.getName())
- && THIS.getSignature().equals(THAT.getSignature());
- }
+ @Override
+ public boolean equals(Object o1, Object o2) {
+ FieldGen THIS = (FieldGen) o1;
+ FieldGen THAT = (FieldGen) o2;
+ return THIS.getName().equals(THAT.getName())
+ && THIS.getSignature().equals(THAT.getSignature());
+ }
+ @Override
+ public int hashCode(Object o) {
+ FieldGen THIS = (FieldGen) o;
+ return THIS.getSignature().hashCode() ^ THIS.getName().hashCode();
+ }
+ };
- public int hashCode( Object o ) {
- FieldGen THIS = (FieldGen) o;
- return THIS.getSignature().hashCode() ^ THIS.getName().hashCode();
- }
- };
+ /**
+ * Declare a field. If it is static (isStatic() == true) and has a basic
+ * type like int or String it may have an initial value associated with it
+ * as defined by setInitValue().
+ *
+ * @param access_flags
+ * access qualifiers
+ * @param type
+ * field type
+ * @param name
+ * field name
+ * @param cp
+ * constant pool
+ */
+ public FieldGen(int access_flags, Type type, String name, ConstantPoolGen cp) {
+ setAccessFlags(access_flags);
+ setType(type);
+ setName(name);
+ setConstantPool(cp);
+ }
+ /**
+ * Instantiate from existing field.
+ *
+ * @param field
+ * Field object
+ * @param cp
+ * constant pool (must contain the same entries as the field's
+ * constant pool)
+ */
+ public FieldGen(Field field, ConstantPoolGen cp) {
+ this(field.getAccessFlags(), Type.getType(field.getSignature()), field
+ .getName(), cp);
+ Attribute[] attrs = field.getAttributes();
+ for (int i = 0; i < attrs.length; i++) {
+ if (attrs[i] instanceof ConstantValue) {
+ setValue(((ConstantValue) attrs[i]).getConstantValueIndex());
+ } else {
+ addAttribute(attrs[i]);
+ }
+ }
+ }
- /**
- * Declare a field. If it is static (isStatic() == true) and has a
- * basic type like int or String it may have an initial value
- * associated with it as defined by setInitValue().
- *
- * @param access_flags access qualifiers
- * @param type field type
- * @param name field name
- * @param cp constant pool
- */
- public FieldGen(int access_flags, Type type, String name, ConstantPoolGen cp) {
- setAccessFlags(access_flags);
- setType(type);
- setName(name);
- setConstantPool(cp);
- }
+ private void setValue(int index) {
+ ConstantPool cp = this.cp.getConstantPool();
+ Constant c = cp.getConstant(index);
+ value = ((ConstantObject) c).getConstantValue(cp);
+ }
+ /**
+ * Set (optional) initial value of field, otherwise it will be set to
+ * null/0/false by the JVM automatically.
+ */
+ public void setInitValue(String str) {
+ checkType(new ObjectType("java.lang.String"));
+ if (str != null) {
+ value = str;
+ }
+ }
- /**
- * Instantiate from existing field.
- *
- * @param field Field object
- * @param cp constant pool (must contain the same entries as the field's constant pool)
- */
- public FieldGen(Field field, ConstantPoolGen cp) {
- this(field.getAccessFlags(), Type.getType(field.getSignature()), field.getName(), cp);
- Attribute[] attrs = field.getAttributes();
- for (int i = 0; i < attrs.length; i++) {
- if (attrs[i] instanceof ConstantValue) {
- setValue(((ConstantValue) attrs[i]).getConstantValueIndex());
- } else {
- addAttribute(attrs[i]);
- }
- }
- }
+ public void setInitValue(long l) {
+ checkType(Type.LONG);
+ if (l != 0L) {
+ value = new Long(l);
+ }
+ }
+ public void setInitValue(int i) {
+ checkType(Type.INT);
+ if (i != 0) {
+ value = new Integer(i);
+ }
+ }
- private void setValue( int index ) {
- ConstantPool cp = this.cp.getConstantPool();
- Constant c = cp.getConstant(index);
- value = ((ConstantObject) c).getConstantValue(cp);
- }
+ public void setInitValue(short s) {
+ checkType(Type.SHORT);
+ if (s != 0) {
+ value = new Integer(s);
+ }
+ }
+ public void setInitValue(char c) {
+ checkType(Type.CHAR);
+ if (c != 0) {
+ value = new Integer(c);
+ }
+ }
- /**
- * Set (optional) initial value of field, otherwise it will be set to null/0/false
- * by the JVM automatically.
- */
- public void setInitValue( String str ) {
- checkType(new ObjectType("java.lang.String"));
- if (str != null) {
- value = str;
- }
- }
+ public void setInitValue(byte b) {
+ checkType(Type.BYTE);
+ if (b != 0) {
+ value = new Integer(b);
+ }
+ }
+ public void setInitValue(boolean b) {
+ checkType(Type.BOOLEAN);
+ if (b) {
+ value = new Integer(1);
+ }
+ }
- public void setInitValue( long l ) {
- checkType(Type.LONG);
- if (l != 0L) {
- value = new Long(l);
- }
- }
+ public void setInitValue(float f) {
+ checkType(Type.FLOAT);
+ if (f != 0.0) {
+ value = new Float(f);
+ }
+ }
+ public void setInitValue(double d) {
+ checkType(Type.DOUBLE);
+ if (d != 0.0) {
+ value = new Double(d);
+ }
+ }
- public void setInitValue( int i ) {
- checkType(Type.INT);
- if (i != 0) {
- value = new Integer(i);
- }
- }
+ /**
+ * Remove any initial value.
+ */
+ public void cancelInitValue() {
+ value = null;
+ }
+ private void checkType(Type atype) {
+ if (type == null) {
+ throw new ClassGenException(
+ "You haven't defined the type of the field yet");
+ }
+ if (!isFinal()) {
+ throw new ClassGenException(
+ "Only final fields may have an initial value!");
+ }
+ if (!type.equals(atype)) {
+ throw new ClassGenException("Types are not compatible: " + type
+ + " vs. " + atype);
+ }
+ }
- public void setInitValue( short s ) {
- checkType(Type.SHORT);
- if (s != 0) {
- value = new Integer(s);
- }
- }
+ /**
+ * Get field object after having set up all necessary values.
+ */
+ public Field getField() {
+ String signature = getSignature();
+ int name_index = cp.addUtf8(name);
+ int signature_index = cp.addUtf8(signature);
+ if (value != null) {
+ checkType(type);
+ int index = addConstant();
+ addAttribute(new ConstantValue(cp.addUtf8("ConstantValue"), 2,
+ index, cp.getConstantPool()));
+ }
+ return new Field(access_flags, name_index, signature_index,
+ getAttributes(), cp.getConstantPool());
+ }
+ private int addConstant() {
+ switch (type.getType()) {
+ case Constants.T_INT:
+ case Constants.T_CHAR:
+ case Constants.T_BYTE:
+ case Constants.T_BOOLEAN:
+ case Constants.T_SHORT:
+ return cp.addInteger(((Integer) value).intValue());
+ case Constants.T_FLOAT:
+ return cp.addFloat(((Float) value).floatValue());
+ case Constants.T_DOUBLE:
+ return cp.addDouble(((Double) value).doubleValue());
+ case Constants.T_LONG:
+ return cp.addLong(((Long) value).longValue());
+ case Constants.T_REFERENCE:
+ return cp.addString(((String) value));
+ default:
+ throw new RuntimeException("Oops: Unhandled : " + type.getType());
+ }
+ }
- public void setInitValue( char c ) {
- checkType(Type.CHAR);
- if (c != 0) {
- value = new Integer(c);
- }
- }
+ @Override
+ public String getSignature() {
+ return type.getSignature();
+ }
+ private List observers;
- public void setInitValue( byte b ) {
- checkType(Type.BYTE);
- if (b != 0) {
- value = new Integer(b);
- }
- }
+ /**
+ * Add observer for this object.
+ */
+ public void addObserver(FieldObserver o) {
+ if (observers == null) {
+ observers = new ArrayList();
+ }
+ observers.add(o);
+ }
+ /**
+ * Remove observer for this object.
+ */
+ public void removeObserver(FieldObserver o) {
+ if (observers != null) {
+ observers.remove(o);
+ }
+ }
- public void setInitValue( boolean b ) {
- checkType(Type.BOOLEAN);
- if (b) {
- value = new Integer(1);
- }
- }
+ /**
+ * Call notify() method on all observers. This method is not called
+ * automatically whenever the state has changed, but has to be called by the
+ * user after he has finished editing the object.
+ */
+ public void update() {
+ if (observers != null) {
+ for (Iterator e = observers.iterator(); e.hasNext();) {
+ e.next().notify(this);
+ }
+ }
+ }
+ public String getInitValue() {
+ if (value != null) {
+ return value.toString();
+ } else {
+ return null;
+ }
+ }
- public void setInitValue( float f ) {
- checkType(Type.FLOAT);
- if (f != 0.0) {
- value = new Float(f);
- }
- }
+ /**
+ * Return string representation close to declaration format, `public static
+ * final short MAX = 100', e.g..
+ *
+ * @return String representation of field
+ */
+ @Override
+ public final String toString() {
+ String name, signature, access; // Short cuts to constant pool
+ access = Utility.accessToString(access_flags);
+ access = access.equals("") ? "" : (access + " ");
+ signature = type.toString();
+ name = getName();
+ StringBuffer buf = new StringBuffer(32);
+ buf.append(access).append(signature).append(" ").append(name);
+ String value = getInitValue();
+ if (value != null) {
+ buf.append(" = ").append(value);
+ }
+ return buf.toString();
+ }
+ /**
+ * @return deep copy of this field
+ */
+ public FieldGen copy(ConstantPoolGen cp) {
+ FieldGen fg = (FieldGen) clone();
+ fg.setConstantPool(cp);
+ return fg;
+ }
- public void setInitValue( double d ) {
- checkType(Type.DOUBLE);
- if (d != 0.0) {
- value = new Double(d);
- }
- }
+ /**
+ * @return Comparison strategy object
+ */
+ public static BCELComparator getComparator() {
+ return _cmp;
+ }
+ /**
+ * @param comparator
+ * Comparison strategy object
+ */
+ public static void setComparator(BCELComparator comparator) {
+ _cmp = comparator;
+ }
- /** Remove any initial value.
- */
- public void cancelInitValue() {
- value = null;
- }
+ /**
+ * Return value as defined by given BCELComparator strategy. By default two
+ * FieldGen objects are said to be equal when their names and signatures are
+ * equal.
+ *
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(Object obj) {
+ return _cmp.equals(this, obj);
+ }
-
- private void checkType( Type atype ) {
- if (type == null) {
- throw new ClassGenException("You haven't defined the type of the field yet");
- }
- if (!isFinal()) {
- throw new ClassGenException("Only final fields may have an initial value!");
- }
- if (!type.equals(atype)) {
- throw new ClassGenException("Types are not compatible: " + type + " vs. " + atype);
- }
- }
-
-
- /**
- * Get field object after having set up all necessary values.
- */
- public Field getField() {
- String signature = getSignature();
- int name_index = cp.addUtf8(name);
- int signature_index = cp.addUtf8(signature);
- if (value != null) {
- checkType(type);
- int index = addConstant();
- addAttribute(new ConstantValue(cp.addUtf8("ConstantValue"), 2, index, cp
- .getConstantPool()));
- }
- return new Field(access_flags, name_index, signature_index, getAttributes(), cp
- .getConstantPool());
- }
-
-
- private int addConstant() {
- switch (type.getType()) {
- case Constants.T_INT:
- case Constants.T_CHAR:
- case Constants.T_BYTE:
- case Constants.T_BOOLEAN:
- case Constants.T_SHORT:
- return cp.addInteger(((Integer) value).intValue());
- case Constants.T_FLOAT:
- return cp.addFloat(((Float) value).floatValue());
- case Constants.T_DOUBLE:
- return cp.addDouble(((Double) value).doubleValue());
- case Constants.T_LONG:
- return cp.addLong(((Long) value).longValue());
- case Constants.T_REFERENCE:
- return cp.addString(((String) value));
- default:
- throw new RuntimeException("Oops: Unhandled : " + type.getType());
- }
- }
-
-
- public String getSignature() {
- return type.getSignature();
- }
-
- private List observers;
-
-
- /** Add observer for this object.
- */
- public void addObserver( FieldObserver o ) {
- if (observers == null) {
- observers = new ArrayList();
- }
- observers.add(o);
- }
-
-
- /** Remove observer for this object.
- */
- public void removeObserver( FieldObserver o ) {
- if (observers != null) {
- observers.remove(o);
- }
- }
-
-
- /** Call notify() method on all observers. This method is not called
- * automatically whenever the state has changed, but has to be
- * called by the user after he has finished editing the object.
- */
- public void update() {
- if (observers != null) {
- for (Iterator e = observers.iterator(); e.hasNext();) {
- ((FieldObserver) e.next()).notify(this);
- }
- }
- }
-
-
- public String getInitValue() {
- if (value != null) {
- return value.toString();
- } else {
- return null;
- }
- }
-
-
- /**
- * Return string representation close to declaration format,
- * `public static final short MAX = 100', e.g..
- *
- * @return String representation of field
- */
- public final String toString() {
- String name, signature, access; // Short cuts to constant pool
- access = Utility.accessToString(access_flags);
- access = access.equals("") ? "" : (access + " ");
- signature = type.toString();
- name = getName();
- StringBuffer buf = new StringBuffer(32);
- buf.append(access).append(signature).append(" ").append(name);
- String value = getInitValue();
- if (value != null) {
- buf.append(" = ").append(value);
- }
- return buf.toString();
- }
-
-
- /** @return deep copy of this field
- */
- public FieldGen copy( ConstantPoolGen cp ) {
- FieldGen fg = (FieldGen) clone();
- fg.setConstantPool(cp);
- return fg;
- }
-
-
- /**
- * @return Comparison strategy object
- */
- public static BCELComparator getComparator() {
- return _cmp;
- }
-
-
- /**
- * @param comparator Comparison strategy object
- */
- public static void setComparator( BCELComparator comparator ) {
- _cmp = comparator;
- }
-
-
- /**
- * Return value as defined by given BCELComparator strategy.
- * By default two FieldGen objects are said to be equal when
- * their names and signatures are equal.
- *
- * @see java.lang.Object#equals(java.lang.Object)
- */
- public boolean equals( Object obj ) {
- return _cmp.equals(this, obj);
- }
-
-
- /**
- * Return value as defined by given BCELComparator strategy.
- * By default return the hashcode of the field's name XOR signature.
- *
- * @see java.lang.Object#hashCode()
- */
- public int hashCode() {
- return _cmp.hashCode(this);
- }
+ /**
+ * Return value as defined by given BCELComparator strategy. By default
+ * return the hashcode of the field's name XOR signature.
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ return _cmp.hashCode(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/FieldGenOrMethodGen.java b/src/org/apache/bcel/generic/FieldGenOrMethodGen.java
index c711cae..172d0a6 100644
--- a/src/org/apache/bcel/generic/FieldGenOrMethodGen.java
+++ b/src/org/apache/bcel/generic/FieldGenOrMethodGen.java
@@ -23,109 +23,108 @@ import org.apache.bcel.classfile.AccessFlags;
import org.apache.bcel.classfile.Attribute;
/**
- * Super class for FieldGen and MethodGen objects, since they have
- * some methods in common!
- *
+ * Super class for FieldGen and MethodGen objects, since they have some methods
+ * in common!
+ *
* @version $Id: FieldGenOrMethodGen.java 410087 2006-05-29 12:12:19Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
-public abstract class FieldGenOrMethodGen extends AccessFlags implements NamedAndTyped, Cloneable {
+public abstract class FieldGenOrMethodGen extends AccessFlags implements
+ NamedAndTyped, Cloneable {
- protected String name;
- protected Type type;
- protected ConstantPoolGen cp;
- private List attribute_vec = new ArrayList();
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ protected String name;
+ protected Type type;
+ protected ConstantPoolGen cp;
+ private List attribute_vec = new ArrayList();
+ protected FieldGenOrMethodGen() {
+ }
- protected FieldGenOrMethodGen() {
- }
+ @Override
+ public void setType(Type type) {
+ if (type.getType() == Constants.T_ADDRESS) {
+ throw new IllegalArgumentException("Type can not be " + type);
+ }
+ this.type = type;
+ }
+ @Override
+ public Type getType() {
+ return type;
+ }
- public void setType( Type type ) {
- if (type.getType() == Constants.T_ADDRESS) {
- throw new IllegalArgumentException("Type can not be " + type);
- }
- this.type = type;
- }
+ /**
+ * @return name of method/field.
+ */
+ @Override
+ public String getName() {
+ return name;
+ }
+ @Override
+ public void setName(String name) {
+ this.name = name;
+ }
- public Type getType() {
- return type;
- }
+ public ConstantPoolGen getConstantPool() {
+ return cp;
+ }
+ public void setConstantPool(ConstantPoolGen cp) {
+ this.cp = cp;
+ }
- /** @return name of method/field.
- */
- public String getName() {
- return name;
- }
+ /**
+ * Add an attribute to this method. Currently, the JVM knows about the
+ * `Code', `ConstantValue', `Synthetic' and `Exceptions' attributes. Other
+ * attributes will be ignored by the JVM but do no harm.
+ *
+ * @param a
+ * attribute to be added
+ */
+ public void addAttribute(Attribute a) {
+ attribute_vec.add(a);
+ }
+ /**
+ * Remove an attribute.
+ */
+ public void removeAttribute(Attribute a) {
+ attribute_vec.remove(a);
+ }
- public void setName( String name ) {
- this.name = name;
- }
+ /**
+ * Remove all attributes.
+ */
+ public void removeAttributes() {
+ attribute_vec.clear();
+ }
+ /**
+ * @return all attributes of this method.
+ */
+ public Attribute[] getAttributes() {
+ Attribute[] attributes = new Attribute[attribute_vec.size()];
+ attribute_vec.toArray(attributes);
+ return attributes;
+ }
- public ConstantPoolGen getConstantPool() {
- return cp;
- }
+ /**
+ * @return signature of method/field.
+ */
+ public abstract String getSignature();
-
- public void setConstantPool( ConstantPoolGen cp ) {
- this.cp = cp;
- }
-
-
- /**
- * Add an attribute to this method. Currently, the JVM knows about
- * the `Code', `ConstantValue', `Synthetic' and `Exceptions'
- * attributes. Other attributes will be ignored by the JVM but do no
- * harm.
- *
- * @param a attribute to be added
- */
- public void addAttribute( Attribute a ) {
- attribute_vec.add(a);
- }
-
-
- /**
- * Remove an attribute.
- */
- public void removeAttribute( Attribute a ) {
- attribute_vec.remove(a);
- }
-
-
- /**
- * Remove all attributes.
- */
- public void removeAttributes() {
- attribute_vec.clear();
- }
-
-
- /**
- * @return all attributes of this method.
- */
- public Attribute[] getAttributes() {
- Attribute[] attributes = new Attribute[attribute_vec.size()];
- attribute_vec.toArray(attributes);
- return attributes;
- }
-
-
- /** @return signature of method/field.
- */
- public abstract String getSignature();
-
-
- public Object clone() {
- try {
- return super.clone();
- } catch (CloneNotSupportedException e) {
- System.err.println(e);
- return null;
- }
- }
+ @Override
+ public Object clone() {
+ try {
+ return super.clone();
+ } catch (CloneNotSupportedException e) {
+ System.err.println(e);
+ return null;
+ }
+ }
}
diff --git a/src/org/apache/bcel/generic/FieldInstruction.java b/src/org/apache/bcel/generic/FieldInstruction.java
index 355b859..936be24 100644
--- a/src/org/apache/bcel/generic/FieldInstruction.java
+++ b/src/org/apache/bcel/generic/FieldInstruction.java
@@ -20,61 +20,70 @@ import org.apache.bcel.classfile.ConstantPool;
/**
* Super class for the GET/PUTxxx family of instructions.
- *
+ *
* @version $Id: FieldInstruction.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
-public abstract class FieldInstruction extends FieldOrMethod implements TypedInstruction {
+public abstract class FieldInstruction extends FieldOrMethod implements
+ TypedInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- FieldInstruction() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ FieldInstruction() {
+ }
- /**
- * @param index to constant pool
- */
- protected FieldInstruction(short opcode, int index) {
- super(opcode, index);
- }
+ /**
+ * @param index
+ * to constant pool
+ */
+ protected FieldInstruction(short opcode, int index) {
+ super(opcode, index);
+ }
+ /**
+ * @return mnemonic for instruction with symbolic references resolved
+ */
+ @Override
+ public String toString(ConstantPool cp) {
+ return org.apache.bcel.Constants.OPCODE_NAMES[opcode]
+ + " "
+ + cp.constantToString(index,
+ org.apache.bcel.Constants.CONSTANT_Fieldref);
+ }
- /**
- * @return mnemonic for instruction with symbolic references resolved
- */
- public String toString( ConstantPool cp ) {
- return org.apache.bcel.Constants.OPCODE_NAMES[opcode] + " "
- + cp.constantToString(index, org.apache.bcel.Constants.CONSTANT_Fieldref);
- }
+ /**
+ * @return size of field (1 or 2)
+ */
+ protected int getFieldSize(ConstantPoolGen cpg) {
+ return getType(cpg).getSize();
+ }
+ /**
+ * @return return type of referenced field
+ */
+ @Override
+ public Type getType(ConstantPoolGen cpg) {
+ return getFieldType(cpg);
+ }
- /** @return size of field (1 or 2)
- */
- protected int getFieldSize( ConstantPoolGen cpg ) {
- return getType(cpg).getSize();
- }
+ /**
+ * @return type of field
+ */
+ public Type getFieldType(ConstantPoolGen cpg) {
+ return Type.getType(getSignature(cpg));
+ }
-
- /** @return return type of referenced field
- */
- public Type getType( ConstantPoolGen cpg ) {
- return getFieldType(cpg);
- }
-
-
- /** @return type of field
- */
- public Type getFieldType( ConstantPoolGen cpg ) {
- return Type.getType(getSignature(cpg));
- }
-
-
- /** @return name of referenced field.
- */
- public String getFieldName( ConstantPoolGen cpg ) {
- return getName(cpg);
- }
+ /**
+ * @return name of referenced field.
+ */
+ public String getFieldName(ConstantPoolGen cpg) {
+ return getName(cpg);
+ }
}
diff --git a/src/org/apache/bcel/generic/FieldObserver.java b/src/org/apache/bcel/generic/FieldObserver.java
index 1731abc..9ec13b4 100644
--- a/src/org/apache/bcel/generic/FieldObserver.java
+++ b/src/org/apache/bcel/generic/FieldObserver.java
@@ -17,13 +17,13 @@
package org.apache.bcel.generic;
/**
- * Imnplement this interface if you're interested in changes to a FieldGen object
- * and register yourself with addObserver().
- *
+ * Imnplement this interface if you're interested in changes to a FieldGen
+ * object and register yourself with addObserver().
+ *
* @version $Id: FieldObserver.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public interface FieldObserver {
- public void notify( FieldGen field );
+ public void notify(FieldGen field);
}
diff --git a/src/org/apache/bcel/generic/FieldOrMethod.java b/src/org/apache/bcel/generic/FieldOrMethod.java
index 114f890..287fc54 100644
--- a/src/org/apache/bcel/generic/FieldOrMethod.java
+++ b/src/org/apache/bcel/generic/FieldOrMethod.java
@@ -22,107 +22,117 @@ import org.apache.bcel.classfile.ConstantPool;
import org.apache.bcel.classfile.ConstantUtf8;
/**
- * Super class for InvokeInstruction and FieldInstruction, since they have
- * some methods in common!
- *
+ * Super class for InvokeInstruction and FieldInstruction, since they have some
+ * methods in common!
+ *
* @version $Id: FieldOrMethod.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public abstract class FieldOrMethod extends CPInstruction implements LoadClass {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- FieldOrMethod() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ FieldOrMethod() {
+ }
- /**
- * @param index to constant pool
- */
- protected FieldOrMethod(short opcode, int index) {
- super(opcode, index);
- }
+ /**
+ * @param index
+ * to constant pool
+ */
+ protected FieldOrMethod(short opcode, int index) {
+ super(opcode, index);
+ }
+ /**
+ * @return signature of referenced method/field.
+ */
+ public String getSignature(ConstantPoolGen cpg) {
+ ConstantPool cp = cpg.getConstantPool();
+ ConstantCP cmr = (ConstantCP) cp.getConstant(index);
+ ConstantNameAndType cnat = (ConstantNameAndType) cp.getConstant(cmr
+ .getNameAndTypeIndex());
+ return ((ConstantUtf8) cp.getConstant(cnat.getSignatureIndex()))
+ .getBytes();
+ }
- /** @return signature of referenced method/field.
- */
- public String getSignature( ConstantPoolGen cpg ) {
- ConstantPool cp = cpg.getConstantPool();
- ConstantCP cmr = (ConstantCP) cp.getConstant(index);
- ConstantNameAndType cnat = (ConstantNameAndType) cp.getConstant(cmr.getNameAndTypeIndex());
- return ((ConstantUtf8) cp.getConstant(cnat.getSignatureIndex())).getBytes();
- }
+ /**
+ * @return name of referenced method/field.
+ */
+ public String getName(ConstantPoolGen cpg) {
+ ConstantPool cp = cpg.getConstantPool();
+ ConstantCP cmr = (ConstantCP) cp.getConstant(index);
+ ConstantNameAndType cnat = (ConstantNameAndType) cp.getConstant(cmr
+ .getNameAndTypeIndex());
+ return ((ConstantUtf8) cp.getConstant(cnat.getNameIndex())).getBytes();
+ }
+ /**
+ * @return name of the referenced class/interface
+ * @deprecated If the instruction references an array class, this method
+ * will return "java.lang.Object". For code generated by Java
+ * 1.5, this answer is sometimes wrong (e.g., if the "clone()"
+ * method is called on an array). A better idea is to use the
+ * getReferenceType() method, which correctly distinguishes
+ * between class types and array types.
+ */
+ @Deprecated
+ public String getClassName(ConstantPoolGen cpg) {
+ ConstantPool cp = cpg.getConstantPool();
+ ConstantCP cmr = (ConstantCP) cp.getConstant(index);
+ String className = cp.getConstantString(cmr.getClassIndex(),
+ org.apache.bcel.Constants.CONSTANT_Class);
+ if (className.startsWith("[")) {
+ // Turn array classes into java.lang.Object.
+ return "java.lang.Object";
+ }
+ return className.replace('/', '.');
+ }
- /** @return name of referenced method/field.
- */
- public String getName( ConstantPoolGen cpg ) {
- ConstantPool cp = cpg.getConstantPool();
- ConstantCP cmr = (ConstantCP) cp.getConstant(index);
- ConstantNameAndType cnat = (ConstantNameAndType) cp.getConstant(cmr.getNameAndTypeIndex());
- return ((ConstantUtf8) cp.getConstant(cnat.getNameIndex())).getBytes();
- }
+ /**
+ * @return type of the referenced class/interface
+ * @deprecated If the instruction references an array class, the ObjectType
+ * returned will be invalid. Use getReferenceType() instead.
+ */
+ @Deprecated
+ public ObjectType getClassType(ConstantPoolGen cpg) {
+ return new ObjectType(getClassName(cpg));
+ }
+ /**
+ * Return the reference type representing the class, interface, or array
+ * class referenced by the instruction.
+ *
+ * @param cpg
+ * the ConstantPoolGen used to create the instruction
+ * @return an ObjectType (if the referenced class type is a class or
+ * interface), or an ArrayType (if the referenced class type is an
+ * array class)
+ */
+ public ReferenceType getReferenceType(ConstantPoolGen cpg) {
+ ConstantPool cp = cpg.getConstantPool();
+ ConstantCP cmr = (ConstantCP) cp.getConstant(index);
+ String className = cp.getConstantString(cmr.getClassIndex(),
+ org.apache.bcel.Constants.CONSTANT_Class);
+ if (className.startsWith("[")) {
+ return (ArrayType) Type.getType(className);
+ } else {
+ className = className.replace('/', '.');
+ return new ObjectType(className);
+ }
+ }
- /** @return name of the referenced class/interface
- * @deprecated If the instruction references an array class,
- * this method will return "java.lang.Object".
- * For code generated by Java 1.5, this answer is
- * sometimes wrong (e.g., if the "clone()" method is
- * called on an array). A better idea is to use
- * the getReferenceType() method, which correctly distinguishes
- * between class types and array types.
- */
- public String getClassName( ConstantPoolGen cpg ) {
- ConstantPool cp = cpg.getConstantPool();
- ConstantCP cmr = (ConstantCP) cp.getConstant(index);
- String className = cp.getConstantString(cmr.getClassIndex(),
- org.apache.bcel.Constants.CONSTANT_Class);
- if (className.startsWith("[")) {
- // Turn array classes into java.lang.Object.
- return "java.lang.Object";
- }
- return className.replace('/', '.');
- }
-
-
- /** @return type of the referenced class/interface
- * @deprecated If the instruction references an array class,
- * the ObjectType returned will be invalid. Use
- * getReferenceType() instead.
- */
- public ObjectType getClassType( ConstantPoolGen cpg ) {
- return new ObjectType(getClassName(cpg));
- }
-
-
- /**
- * Return the reference type representing the class, interface,
- * or array class referenced by the instruction.
- * @param cpg the ConstantPoolGen used to create the instruction
- * @return an ObjectType (if the referenced class type is a class
- * or interface), or an ArrayType (if the referenced class
- * type is an array class)
- */
- public ReferenceType getReferenceType( ConstantPoolGen cpg ) {
- ConstantPool cp = cpg.getConstantPool();
- ConstantCP cmr = (ConstantCP) cp.getConstant(index);
- String className = cp.getConstantString(cmr.getClassIndex(),
- org.apache.bcel.Constants.CONSTANT_Class);
- if (className.startsWith("[")) {
- return (ArrayType) Type.getType(className);
- } else {
- className = className.replace('/', '.');
- return new ObjectType(className);
- }
- }
-
-
- /** @return type of the referenced class/interface
- */
- public ObjectType getLoadClassType( ConstantPoolGen cpg ) {
- return getClassType(cpg);
- }
+ /**
+ * @return type of the referenced class/interface
+ */
+ @Override
+ public ObjectType getLoadClassType(ConstantPoolGen cpg) {
+ return getClassType(cpg);
+ }
}
diff --git a/src/org/apache/bcel/generic/GETFIELD.java b/src/org/apache/bcel/generic/GETFIELD.java
index 1ca8708..d72d012 100644
--- a/src/org/apache/bcel/generic/GETFIELD.java
+++ b/src/org/apache/bcel/generic/GETFIELD.java
@@ -19,63 +19,76 @@ package org.apache.bcel.generic;
import org.apache.bcel.Constants;
import org.apache.bcel.ExceptionConstants;
-/**
+/**
* GETFIELD - Fetch field from object
- * Stack: ..., objectref -> ..., value
+ *
+ *
+ * Stack: ..., objectref -> ..., value
+ *
+ *
* OR
- * Stack: ..., objectref -> ..., value.word1, value.word2
- *
+ *
+ *
+ * Stack: ..., objectref -> ..., value.word1, value.word2
+ *
+ *
* @version $Id: GETFIELD.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
-public class GETFIELD extends FieldInstruction implements ExceptionThrower, StackConsumer,
- StackProducer {
+public class GETFIELD extends FieldInstruction implements ExceptionThrower,
+ StackConsumer, StackProducer {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- GETFIELD() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ GETFIELD() {
+ }
- public GETFIELD(int index) {
- super(Constants.GETFIELD, index);
- }
+ public GETFIELD(int index) {
+ super(Constants.GETFIELD, index);
+ }
+ @Override
+ public int produceStack(ConstantPoolGen cpg) {
+ return getFieldSize(cpg);
+ }
- public int produceStack( ConstantPoolGen cpg ) {
- return getFieldSize(cpg);
- }
+ @Override
+ public Class[] getExceptions() {
+ Class[] cs = new Class[2 + ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length];
+ System.arraycopy(ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION,
+ 0, cs, 0,
+ ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length);
+ cs[ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length + 1] = ExceptionConstants.INCOMPATIBLE_CLASS_CHANGE_ERROR;
+ cs[ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length] = ExceptionConstants.NULL_POINTER_EXCEPTION;
+ return cs;
+ }
-
- public Class[] getExceptions() {
- Class[] cs = new Class[2 + ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length];
- System.arraycopy(ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION, 0, cs, 0,
- ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length);
- cs[ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length + 1] = ExceptionConstants.INCOMPATIBLE_CLASS_CHANGE_ERROR;
- cs[ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length] = ExceptionConstants.NULL_POINTER_EXCEPTION;
- return cs;
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitExceptionThrower(this);
- v.visitStackConsumer(this);
- v.visitStackProducer(this);
- v.visitTypedInstruction(this);
- v.visitLoadClass(this);
- v.visitCPInstruction(this);
- v.visitFieldOrMethod(this);
- v.visitFieldInstruction(this);
- v.visitGETFIELD(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitExceptionThrower(this);
+ v.visitStackConsumer(this);
+ v.visitStackProducer(this);
+ v.visitTypedInstruction(this);
+ v.visitLoadClass(this);
+ v.visitCPInstruction(this);
+ v.visitFieldOrMethod(this);
+ v.visitFieldInstruction(this);
+ v.visitGETFIELD(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/GETSTATIC.java b/src/org/apache/bcel/generic/GETSTATIC.java
index 581bada..61c2975 100644
--- a/src/org/apache/bcel/generic/GETSTATIC.java
+++ b/src/org/apache/bcel/generic/GETSTATIC.java
@@ -19,61 +19,75 @@ package org.apache.bcel.generic;
import org.apache.bcel.Constants;
import org.apache.bcel.ExceptionConstants;
-/**
+/**
* GETSTATIC - Fetch static field from class
- * Stack: ..., -> ..., value
+ *
+ *
+ * Stack: ..., -> ..., value
+ *
+ *
* OR
- * Stack: ..., -> ..., value.word1, value.word2
- *
+ *
+ *
+ * Stack: ..., -> ..., value.word1, value.word2
+ *
+ *
* @version $Id: GETSTATIC.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
-public class GETSTATIC extends FieldInstruction implements PushInstruction, ExceptionThrower {
+public class GETSTATIC extends FieldInstruction implements PushInstruction,
+ ExceptionThrower {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- GETSTATIC() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ GETSTATIC() {
+ }
- public GETSTATIC(int index) {
- super(Constants.GETSTATIC, index);
- }
+ public GETSTATIC(int index) {
+ super(Constants.GETSTATIC, index);
+ }
+ @Override
+ public int produceStack(ConstantPoolGen cpg) {
+ return getFieldSize(cpg);
+ }
- public int produceStack( ConstantPoolGen cpg ) {
- return getFieldSize(cpg);
- }
+ @Override
+ public Class[] getExceptions() {
+ Class[] cs = new Class[1 + ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length];
+ System.arraycopy(ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION,
+ 0, cs, 0,
+ ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length);
+ cs[ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length] = ExceptionConstants.INCOMPATIBLE_CLASS_CHANGE_ERROR;
+ return cs;
+ }
-
- public Class[] getExceptions() {
- Class[] cs = new Class[1 + ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length];
- System.arraycopy(ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION, 0, cs, 0,
- ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length);
- cs[ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length] = ExceptionConstants.INCOMPATIBLE_CLASS_CHANGE_ERROR;
- return cs;
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackProducer(this);
- v.visitPushInstruction(this);
- v.visitExceptionThrower(this);
- v.visitTypedInstruction(this);
- v.visitLoadClass(this);
- v.visitCPInstruction(this);
- v.visitFieldOrMethod(this);
- v.visitFieldInstruction(this);
- v.visitGETSTATIC(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackProducer(this);
+ v.visitPushInstruction(this);
+ v.visitExceptionThrower(this);
+ v.visitTypedInstruction(this);
+ v.visitLoadClass(this);
+ v.visitCPInstruction(this);
+ v.visitFieldOrMethod(this);
+ v.visitFieldInstruction(this);
+ v.visitGETSTATIC(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/GOTO.java b/src/org/apache/bcel/generic/GOTO.java
index 50777f6..9dc4d7d 100644
--- a/src/org/apache/bcel/generic/GOTO.java
+++ b/src/org/apache/bcel/generic/GOTO.java
@@ -19,71 +19,80 @@ package org.apache.bcel.generic;
import java.io.DataOutputStream;
import java.io.IOException;
-/**
+/**
* GOTO - Branch always (to relative offset, not absolute address)
- *
+ *
* @version $Id: GOTO.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class GOTO extends GotoInstruction implements VariableLengthInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- GOTO() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ GOTO() {
+ }
- public GOTO(InstructionHandle target) {
- super(org.apache.bcel.Constants.GOTO, target);
- }
+ public GOTO(InstructionHandle target) {
+ super(org.apache.bcel.Constants.GOTO, target);
+ }
+ /**
+ * Dump instruction as byte code to stream out.
+ *
+ * @param out
+ * Output stream
+ */
+ @Override
+ public void dump(DataOutputStream out) throws IOException {
+ index = getTargetOffset();
+ if (opcode == org.apache.bcel.Constants.GOTO) {
+ super.dump(out);
+ } else { // GOTO_W
+ index = getTargetOffset();
+ out.writeByte(opcode);
+ out.writeInt(index);
+ }
+ }
- /**
- * Dump instruction as byte code to stream out.
- * @param out Output stream
- */
- public void dump( DataOutputStream out ) throws IOException {
- index = getTargetOffset();
- if (opcode == org.apache.bcel.Constants.GOTO) {
- super.dump(out);
- } else { // GOTO_W
- index = getTargetOffset();
- out.writeByte(opcode);
- out.writeInt(index);
- }
- }
+ /**
+ * Called in pass 2 of InstructionList.setPositions() in order to update the
+ * branch target, that may shift due to variable length instructions.
+ */
+ @Override
+ protected int updatePosition(int offset, int max_offset) {
+ int i = getTargetOffset(); // Depending on old position value
+ position += offset; // Position may be shifted by preceding expansions
+ if (Math.abs(i) >= (32767 - max_offset)) { // to large for short
+ // (estimate)
+ opcode = org.apache.bcel.Constants.GOTO_W;
+ length = 5;
+ return 2; // 5 - 3
+ }
+ return 0;
+ }
-
- /** Called in pass 2 of InstructionList.setPositions() in order to update
- * the branch target, that may shift due to variable length instructions.
- */
- protected int updatePosition( int offset, int max_offset ) {
- int i = getTargetOffset(); // Depending on old position value
- position += offset; // Position may be shifted by preceding expansions
- if (Math.abs(i) >= (32767 - max_offset)) { // to large for short (estimate)
- opcode = org.apache.bcel.Constants.GOTO_W;
- length = 5;
- return 2; // 5 - 3
- }
- return 0;
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitVariableLengthInstruction(this);
- v.visitUnconditionalBranch(this);
- v.visitBranchInstruction(this);
- v.visitGotoInstruction(this);
- v.visitGOTO(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitVariableLengthInstruction(this);
+ v.visitUnconditionalBranch(this);
+ v.visitBranchInstruction(this);
+ v.visitGotoInstruction(this);
+ v.visitGOTO(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/GOTO_W.java b/src/org/apache/bcel/generic/GOTO_W.java
index 3909cb0..228d95e 100644
--- a/src/org/apache/bcel/generic/GOTO_W.java
+++ b/src/org/apache/bcel/generic/GOTO_W.java
@@ -20,60 +20,68 @@ import java.io.DataOutputStream;
import java.io.IOException;
import org.apache.bcel.util.ByteSequence;
-/**
+/**
* GOTO_W - Branch always (to relative offset, not absolute address)
- *
+ *
* @version $Id: GOTO_W.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class GOTO_W extends GotoInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- GOTO_W() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ GOTO_W() {
+ }
- public GOTO_W(InstructionHandle target) {
- super(org.apache.bcel.Constants.GOTO_W, target);
- length = 5;
- }
+ public GOTO_W(InstructionHandle target) {
+ super(org.apache.bcel.Constants.GOTO_W, target);
+ length = 5;
+ }
+ /**
+ * Dump instruction as byte code to stream out.
+ *
+ * @param out
+ * Output stream
+ */
+ @Override
+ public void dump(DataOutputStream out) throws IOException {
+ index = getTargetOffset();
+ out.writeByte(opcode);
+ out.writeInt(index);
+ }
- /**
- * Dump instruction as byte code to stream out.
- * @param out Output stream
- */
- public void dump( DataOutputStream out ) throws IOException {
- index = getTargetOffset();
- out.writeByte(opcode);
- out.writeInt(index);
- }
+ /**
+ * Read needed data (e.g. index) from file.
+ */
+ @Override
+ protected void initFromFile(ByteSequence bytes, boolean wide)
+ throws IOException {
+ index = bytes.readInt();
+ length = 5;
+ }
-
- /**
- * Read needed data (e.g. index) from file.
- */
- protected void initFromFile( ByteSequence bytes, boolean wide ) throws IOException {
- index = bytes.readInt();
- length = 5;
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitUnconditionalBranch(this);
- v.visitBranchInstruction(this);
- v.visitGotoInstruction(this);
- v.visitGOTO_W(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitUnconditionalBranch(this);
+ v.visitBranchInstruction(this);
+ v.visitGotoInstruction(this);
+ v.visitGOTO_W(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/GotoInstruction.java b/src/org/apache/bcel/generic/GotoInstruction.java
index f263dad..b0ceb55 100644
--- a/src/org/apache/bcel/generic/GotoInstruction.java
+++ b/src/org/apache/bcel/generic/GotoInstruction.java
@@ -16,23 +16,28 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* Super class for GOTO
- *
+ *
* @version $Id: GotoInstruction.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
-public abstract class GotoInstruction extends BranchInstruction implements UnconditionalBranch {
+public abstract class GotoInstruction extends BranchInstruction implements
+ UnconditionalBranch {
- GotoInstruction(short opcode, InstructionHandle target) {
- super(opcode, target);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ GotoInstruction(short opcode, InstructionHandle target) {
+ super(opcode, target);
+ }
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- GotoInstruction() {
- }
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ GotoInstruction() {
+ }
}
diff --git a/src/org/apache/bcel/generic/I2B.java b/src/org/apache/bcel/generic/I2B.java
index b35057c..1f609d4 100644
--- a/src/org/apache/bcel/generic/I2B.java
+++ b/src/org/apache/bcel/generic/I2B.java
@@ -16,35 +16,45 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* I2B - Convert int to byte
- * Stack: ..., value -> ..., result
- *
+ *
+ *
+ * Stack: ..., value -> ..., result
+ *
+ *
* @version $Id: I2B.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class I2B extends ConversionInstruction {
- /** Convert int to byte
- */
- public I2B() {
- super(org.apache.bcel.Constants.I2B);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Convert int to byte
+ */
+ public I2B() {
+ super(org.apache.bcel.Constants.I2B);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitConversionInstruction(this);
- v.visitI2B(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitConversionInstruction(this);
+ v.visitI2B(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/I2C.java b/src/org/apache/bcel/generic/I2C.java
index b2a9849..87c7ee2 100644
--- a/src/org/apache/bcel/generic/I2C.java
+++ b/src/org/apache/bcel/generic/I2C.java
@@ -16,35 +16,45 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* I2C - Convert int to char
- * Stack: ..., value -> ..., result
- *
+ *
+ *
+ * Stack: ..., value -> ..., result
+ *
+ *
* @version $Id: I2C.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class I2C extends ConversionInstruction {
- /** Convert int to char
- */
- public I2C() {
- super(org.apache.bcel.Constants.I2C);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Convert int to char
+ */
+ public I2C() {
+ super(org.apache.bcel.Constants.I2C);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitConversionInstruction(this);
- v.visitI2C(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitConversionInstruction(this);
+ v.visitI2C(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/I2D.java b/src/org/apache/bcel/generic/I2D.java
index cb002df..434685d 100644
--- a/src/org/apache/bcel/generic/I2D.java
+++ b/src/org/apache/bcel/generic/I2D.java
@@ -18,33 +18,43 @@ package org.apache.bcel.generic;
/**
* I2D - Convert int to double
- * Stack: ..., value -> ..., result.word1, result.word2
- *
+ *
+ *
+ * Stack: ..., value -> ..., result.word1, result.word2
+ *
+ *
* @version $Id: I2D.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class I2D extends ConversionInstruction {
- /** Convert int to double
- */
- public I2D() {
- super(org.apache.bcel.Constants.I2D);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Convert int to double
+ */
+ public I2D() {
+ super(org.apache.bcel.Constants.I2D);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitConversionInstruction(this);
- v.visitI2D(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitConversionInstruction(this);
+ v.visitI2D(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/I2F.java b/src/org/apache/bcel/generic/I2F.java
index 235cab9..e4ffa33 100644
--- a/src/org/apache/bcel/generic/I2F.java
+++ b/src/org/apache/bcel/generic/I2F.java
@@ -16,35 +16,45 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* I2F - Convert int to float
- * Stack: ..., value -> ..., result
- *
+ *
+ *
+ * Stack: ..., value -> ..., result
+ *
+ *
* @version $Id: I2F.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class I2F extends ConversionInstruction {
- /** Convert int to float
- */
- public I2F() {
- super(org.apache.bcel.Constants.I2F);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Convert int to float
+ */
+ public I2F() {
+ super(org.apache.bcel.Constants.I2F);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitConversionInstruction(this);
- v.visitI2F(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitConversionInstruction(this);
+ v.visitI2F(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/I2L.java b/src/org/apache/bcel/generic/I2L.java
index 01bb564..f63e22d 100644
--- a/src/org/apache/bcel/generic/I2L.java
+++ b/src/org/apache/bcel/generic/I2L.java
@@ -18,33 +18,43 @@ package org.apache.bcel.generic;
/**
* I2L - Convert int to long
- * Stack: ..., value -> ..., result.word1, result.word2
- *
+ *
+ *
+ * Stack: ..., value -> ..., result.word1, result.word2
+ *
+ *
* @version $Id: I2L.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class I2L extends ConversionInstruction {
- /** Convert int to long
- */
- public I2L() {
- super(org.apache.bcel.Constants.I2L);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Convert int to long
+ */
+ public I2L() {
+ super(org.apache.bcel.Constants.I2L);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitConversionInstruction(this);
- v.visitI2L(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitConversionInstruction(this);
+ v.visitI2L(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/I2S.java b/src/org/apache/bcel/generic/I2S.java
index 3bbd2ae..492d3ef 100644
--- a/src/org/apache/bcel/generic/I2S.java
+++ b/src/org/apache/bcel/generic/I2S.java
@@ -18,31 +18,40 @@ package org.apache.bcel.generic;
/**
* I2S - Convert int to short
- * Stack: ..., value -> ..., result
- *
+ *
+ *
+ * Stack: ..., value -> ..., result
+ *
+ *
* @version $Id: I2S.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class I2S extends ConversionInstruction {
- public I2S() {
- super(org.apache.bcel.Constants.I2S);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ public I2S() {
+ super(org.apache.bcel.Constants.I2S);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitConversionInstruction(this);
- v.visitI2S(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitConversionInstruction(this);
+ v.visitI2S(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IADD.java b/src/org/apache/bcel/generic/IADD.java
index 7fafc4f..ad8bbcf 100644
--- a/src/org/apache/bcel/generic/IADD.java
+++ b/src/org/apache/bcel/generic/IADD.java
@@ -16,35 +16,45 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* IADD - Add ints
- * Stack: ..., value1, value2 -> result
- *
+ *
+ *
+ * Stack: ..., value1, value2 -> result
+ *
+ *
* @version $Id: IADD.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IADD extends ArithmeticInstruction {
- /** Add ints
- */
- public IADD() {
- super(org.apache.bcel.Constants.IADD);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Add ints
+ */
+ public IADD() {
+ super(org.apache.bcel.Constants.IADD);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitArithmeticInstruction(this);
- v.visitIADD(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitArithmeticInstruction(this);
+ v.visitIADD(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IALOAD.java b/src/org/apache/bcel/generic/IALOAD.java
index b90d887..1e43cf9 100644
--- a/src/org/apache/bcel/generic/IALOAD.java
+++ b/src/org/apache/bcel/generic/IALOAD.java
@@ -16,36 +16,45 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* IALOAD - Load int from array
- * Stack: ..., arrayref, index -> ..., value
- *
+ *
+ *
+ * Stack: ..., arrayref, index -> ..., value
+ *
+ *
* @version $Id: IALOAD.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IALOAD extends ArrayInstruction implements StackProducer {
- /**
- * Load int from array
- */
- public IALOAD() {
- super(org.apache.bcel.Constants.IALOAD);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Load int from array
+ */
+ public IALOAD() {
+ super(org.apache.bcel.Constants.IALOAD);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackProducer(this);
- v.visitExceptionThrower(this);
- v.visitTypedInstruction(this);
- v.visitArrayInstruction(this);
- v.visitIALOAD(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackProducer(this);
+ v.visitExceptionThrower(this);
+ v.visitTypedInstruction(this);
+ v.visitArrayInstruction(this);
+ v.visitIALOAD(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IAND.java b/src/org/apache/bcel/generic/IAND.java
index fd6917e..85ab840 100644
--- a/src/org/apache/bcel/generic/IAND.java
+++ b/src/org/apache/bcel/generic/IAND.java
@@ -16,33 +16,42 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* IAND - Bitwise AND int
- * Stack: ..., value1, value2 -> ..., result
- *
+ *
+ *
+ * Stack: ..., value1, value2 -> ..., result
+ *
+ *
* @version $Id: IAND.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IAND extends ArithmeticInstruction {
- public IAND() {
- super(org.apache.bcel.Constants.IAND);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ public IAND() {
+ super(org.apache.bcel.Constants.IAND);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitArithmeticInstruction(this);
- v.visitIAND(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitArithmeticInstruction(this);
+ v.visitIAND(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IASTORE.java b/src/org/apache/bcel/generic/IASTORE.java
index 0b87504..0a159db 100644
--- a/src/org/apache/bcel/generic/IASTORE.java
+++ b/src/org/apache/bcel/generic/IASTORE.java
@@ -16,36 +16,45 @@
*/
package org.apache.bcel.generic;
-/**
- * IASTORE - Store into int array
- * Stack: ..., arrayref, index, value -> ...
- *
+/**
+ * IASTORE - Store into int array
+ *
+ *
+ * Stack: ..., arrayref, index, value -> ...
+ *
+ *
* @version $Id: IASTORE.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IASTORE extends ArrayInstruction implements StackConsumer {
- /**
- * Store into int array
- */
- public IASTORE() {
- super(org.apache.bcel.Constants.IASTORE);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Store into int array
+ */
+ public IASTORE() {
+ super(org.apache.bcel.Constants.IASTORE);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackConsumer(this);
- v.visitExceptionThrower(this);
- v.visitTypedInstruction(this);
- v.visitArrayInstruction(this);
- v.visitIASTORE(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackConsumer(this);
+ v.visitExceptionThrower(this);
+ v.visitTypedInstruction(this);
+ v.visitArrayInstruction(this);
+ v.visitIASTORE(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/ICONST.java b/src/org/apache/bcel/generic/ICONST.java
index 98b9f00..6eab6d5 100644
--- a/src/org/apache/bcel/generic/ICONST.java
+++ b/src/org/apache/bcel/generic/ICONST.java
@@ -16,63 +16,74 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* ICONST - Push value between -1, ..., 5, other values cause an exception
- *
- * Stack: ... -> ...,
- *
+ *
+ *
+ * Stack: ... -> ...,
+ *
+ *
* @version $Id: ICONST.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
-public class ICONST extends Instruction implements ConstantPushInstruction, TypedInstruction {
+public class ICONST extends Instruction implements ConstantPushInstruction,
+ TypedInstruction {
- private int value;
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ private int value;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ ICONST() {
+ }
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- ICONST() {
- }
+ public ICONST(int i) {
+ super(org.apache.bcel.Constants.ICONST_0, (short) 1);
+ if ((i >= -1) && (i <= 5)) {
+ opcode = (short) (org.apache.bcel.Constants.ICONST_0 + i); // Even
+ // works
+ // for i
+ // == -1
+ } else {
+ throw new ClassGenException(
+ "ICONST can be used only for value between -1 and 5: " + i);
+ }
+ value = i;
+ }
+ @Override
+ public Number getValue() {
+ return new Integer(value);
+ }
- public ICONST(int i) {
- super(org.apache.bcel.Constants.ICONST_0, (short) 1);
- if ((i >= -1) && (i <= 5)) {
- opcode = (short) (org.apache.bcel.Constants.ICONST_0 + i); // Even works for i == -1
- } else {
- throw new ClassGenException("ICONST can be used only for value between -1 and 5: " + i);
- }
- value = i;
- }
+ /**
+ * @return Type.INT
+ */
+ @Override
+ public Type getType(ConstantPoolGen cp) {
+ return Type.INT;
+ }
-
- public Number getValue() {
- return new Integer(value);
- }
-
-
- /** @return Type.INT
- */
- public Type getType( ConstantPoolGen cp ) {
- return Type.INT;
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitPushInstruction(this);
- v.visitStackProducer(this);
- v.visitTypedInstruction(this);
- v.visitConstantPushInstruction(this);
- v.visitICONST(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitPushInstruction(this);
+ v.visitStackProducer(this);
+ v.visitTypedInstruction(this);
+ v.visitConstantPushInstruction(this);
+ v.visitICONST(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IDIV.java b/src/org/apache/bcel/generic/IDIV.java
index eb4d404..db8cfeb 100644
--- a/src/org/apache/bcel/generic/IDIV.java
+++ b/src/org/apache/bcel/generic/IDIV.java
@@ -18,43 +18,52 @@ package org.apache.bcel.generic;
/**
* IDIV - Divide ints
- * Stack: ..., value1, value2 -> result
- *
+ *
+ *
+ * Stack: ..., value1, value2 -> result
+ *
+ *
* @version $Id: IDIV.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IDIV extends ArithmeticInstruction implements ExceptionThrower {
- /** Divide ints
- */
- public IDIV() {
- super(org.apache.bcel.Constants.IDIV);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Divide ints
+ */
+ public IDIV() {
+ super(org.apache.bcel.Constants.IDIV);
+ }
- /** @return exceptions this instruction may cause
- */
- public Class[] getExceptions() {
- return new Class[] {
- org.apache.bcel.ExceptionConstants.ARITHMETIC_EXCEPTION
- };
- }
+ /**
+ * @return exceptions this instruction may cause
+ */
+ @Override
+ public Class[] getExceptions() {
+ return new Class[] { org.apache.bcel.ExceptionConstants.ARITHMETIC_EXCEPTION };
+ }
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitExceptionThrower(this);
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitArithmeticInstruction(this);
- v.visitIDIV(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitExceptionThrower(this);
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitArithmeticInstruction(this);
+ v.visitIDIV(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IFEQ.java b/src/org/apache/bcel/generic/IFEQ.java
index 9747dcc..90f05a0 100644
--- a/src/org/apache/bcel/generic/IFEQ.java
+++ b/src/org/apache/bcel/generic/IFEQ.java
@@ -16,49 +16,56 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* IFEQ - Branch if int comparison with zero succeeds
- *
- * Stack: ..., value -> ...
- *
+ *
+ *
+ * Stack: ..., value -> ...
+ *
+ *
* @version $Id: IFEQ.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IFEQ extends IfInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- IFEQ() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ IFEQ() {
+ }
- public IFEQ(InstructionHandle target) {
- super(org.apache.bcel.Constants.IFEQ, target);
- }
+ public IFEQ(InstructionHandle target) {
+ super(org.apache.bcel.Constants.IFEQ, target);
+ }
+ /**
+ * @return negation of instruction, e.g. IFEQ.negate() == IFNE
+ */
+ @Override
+ public IfInstruction negate() {
+ return new IFNE(target);
+ }
- /**
- * @return negation of instruction, e.g. IFEQ.negate() == IFNE
- */
- public IfInstruction negate() {
- return new IFNE(target);
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackConsumer(this);
- v.visitBranchInstruction(this);
- v.visitIfInstruction(this);
- v.visitIFEQ(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackConsumer(this);
+ v.visitBranchInstruction(this);
+ v.visitIfInstruction(this);
+ v.visitIFEQ(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IFGE.java b/src/org/apache/bcel/generic/IFGE.java
index f4478ad..93a4314 100644
--- a/src/org/apache/bcel/generic/IFGE.java
+++ b/src/org/apache/bcel/generic/IFGE.java
@@ -16,49 +16,56 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* IFGE - Branch if int comparison with zero succeeds
- *
- * Stack: ..., value -> ...
- *
+ *
+ *
+ * Stack: ..., value -> ...
+ *
+ *
* @version $Id: IFGE.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IFGE extends IfInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- IFGE() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ IFGE() {
+ }
- public IFGE(InstructionHandle target) {
- super(org.apache.bcel.Constants.IFGE, target);
- }
+ public IFGE(InstructionHandle target) {
+ super(org.apache.bcel.Constants.IFGE, target);
+ }
+ /**
+ * @return negation of instruction
+ */
+ @Override
+ public IfInstruction negate() {
+ return new IFLT(target);
+ }
- /**
- * @return negation of instruction
- */
- public IfInstruction negate() {
- return new IFLT(target);
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackConsumer(this);
- v.visitBranchInstruction(this);
- v.visitIfInstruction(this);
- v.visitIFGE(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackConsumer(this);
+ v.visitBranchInstruction(this);
+ v.visitIfInstruction(this);
+ v.visitIFGE(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IFGT.java b/src/org/apache/bcel/generic/IFGT.java
index 990c163..1b74414 100644
--- a/src/org/apache/bcel/generic/IFGT.java
+++ b/src/org/apache/bcel/generic/IFGT.java
@@ -16,49 +16,56 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* IFGT - Branch if int comparison with zero succeeds
- *
- * Stack: ..., value -> ...
- *
+ *
+ *
+ * Stack: ..., value -> ...
+ *
+ *
* @version $Id: IFGT.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IFGT extends IfInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- IFGT() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ IFGT() {
+ }
- public IFGT(InstructionHandle target) {
- super(org.apache.bcel.Constants.IFGT, target);
- }
+ public IFGT(InstructionHandle target) {
+ super(org.apache.bcel.Constants.IFGT, target);
+ }
+ /**
+ * @return negation of instruction
+ */
+ @Override
+ public IfInstruction negate() {
+ return new IFLE(target);
+ }
- /**
- * @return negation of instruction
- */
- public IfInstruction negate() {
- return new IFLE(target);
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackConsumer(this);
- v.visitBranchInstruction(this);
- v.visitIfInstruction(this);
- v.visitIFGT(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackConsumer(this);
+ v.visitBranchInstruction(this);
+ v.visitIfInstruction(this);
+ v.visitIFGT(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IFLE.java b/src/org/apache/bcel/generic/IFLE.java
index d8f5f37..61326d6 100644
--- a/src/org/apache/bcel/generic/IFLE.java
+++ b/src/org/apache/bcel/generic/IFLE.java
@@ -16,49 +16,56 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* IFLE - Branch if int comparison with zero succeeds
- *
- * Stack: ..., value -> ...
- *
+ *
+ *
+ * Stack: ..., value -> ...
+ *
+ *
* @version $Id: IFLE.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IFLE extends IfInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- IFLE() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ IFLE() {
+ }
- public IFLE(InstructionHandle target) {
- super(org.apache.bcel.Constants.IFLE, target);
- }
+ public IFLE(InstructionHandle target) {
+ super(org.apache.bcel.Constants.IFLE, target);
+ }
+ /**
+ * @return negation of instruction
+ */
+ @Override
+ public IfInstruction negate() {
+ return new IFGT(target);
+ }
- /**
- * @return negation of instruction
- */
- public IfInstruction negate() {
- return new IFGT(target);
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackConsumer(this);
- v.visitBranchInstruction(this);
- v.visitIfInstruction(this);
- v.visitIFLE(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackConsumer(this);
+ v.visitBranchInstruction(this);
+ v.visitIfInstruction(this);
+ v.visitIFLE(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IFLT.java b/src/org/apache/bcel/generic/IFLT.java
index 5a048a6..62c323c 100644
--- a/src/org/apache/bcel/generic/IFLT.java
+++ b/src/org/apache/bcel/generic/IFLT.java
@@ -16,49 +16,56 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* IFLT - Branch if int comparison with zero succeeds
- *
- * Stack: ..., value -> ...
- *
+ *
+ *
+ * Stack: ..., value -> ...
+ *
+ *
* @version $Id: IFLT.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IFLT extends IfInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- IFLT() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ IFLT() {
+ }
- public IFLT(InstructionHandle target) {
- super(org.apache.bcel.Constants.IFLT, target);
- }
+ public IFLT(InstructionHandle target) {
+ super(org.apache.bcel.Constants.IFLT, target);
+ }
+ /**
+ * @return negation of instruction
+ */
+ @Override
+ public IfInstruction negate() {
+ return new IFGE(target);
+ }
- /**
- * @return negation of instruction
- */
- public IfInstruction negate() {
- return new IFGE(target);
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackConsumer(this);
- v.visitBranchInstruction(this);
- v.visitIfInstruction(this);
- v.visitIFLT(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackConsumer(this);
+ v.visitBranchInstruction(this);
+ v.visitIfInstruction(this);
+ v.visitIFLT(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IFNE.java b/src/org/apache/bcel/generic/IFNE.java
index 2658aa1..b76f955 100644
--- a/src/org/apache/bcel/generic/IFNE.java
+++ b/src/org/apache/bcel/generic/IFNE.java
@@ -16,49 +16,56 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* IFNE - Branch if int comparison with zero succeeds
- *
- * Stack: ..., value -> ...
- *
+ *
+ *
+ * Stack: ..., value -> ...
+ *
+ *
* @version $Id: IFNE.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IFNE extends IfInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- IFNE() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ IFNE() {
+ }
- public IFNE(InstructionHandle target) {
- super(org.apache.bcel.Constants.IFNE, target);
- }
+ public IFNE(InstructionHandle target) {
+ super(org.apache.bcel.Constants.IFNE, target);
+ }
+ /**
+ * @return negation of instruction
+ */
+ @Override
+ public IfInstruction negate() {
+ return new IFEQ(target);
+ }
- /**
- * @return negation of instruction
- */
- public IfInstruction negate() {
- return new IFEQ(target);
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackConsumer(this);
- v.visitBranchInstruction(this);
- v.visitIfInstruction(this);
- v.visitIFNE(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackConsumer(this);
+ v.visitBranchInstruction(this);
+ v.visitIfInstruction(this);
+ v.visitIFNE(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IFNONNULL.java b/src/org/apache/bcel/generic/IFNONNULL.java
index e986bdc..8513726 100644
--- a/src/org/apache/bcel/generic/IFNONNULL.java
+++ b/src/org/apache/bcel/generic/IFNONNULL.java
@@ -16,49 +16,56 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* IFNONNULL - Branch if reference is not null
- *
- * Stack: ..., reference -> ...
- *
+ *
+ *
+ * Stack: ..., reference -> ...
+ *
+ *
* @version $Id: IFNONNULL.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IFNONNULL extends IfInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- IFNONNULL() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ IFNONNULL() {
+ }
- public IFNONNULL(InstructionHandle target) {
- super(org.apache.bcel.Constants.IFNONNULL, target);
- }
+ public IFNONNULL(InstructionHandle target) {
+ super(org.apache.bcel.Constants.IFNONNULL, target);
+ }
+ /**
+ * @return negation of instruction
+ */
+ @Override
+ public IfInstruction negate() {
+ return new IFNULL(target);
+ }
- /**
- * @return negation of instruction
- */
- public IfInstruction negate() {
- return new IFNULL(target);
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackConsumer(this);
- v.visitBranchInstruction(this);
- v.visitIfInstruction(this);
- v.visitIFNONNULL(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackConsumer(this);
+ v.visitBranchInstruction(this);
+ v.visitIfInstruction(this);
+ v.visitIFNONNULL(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IFNULL.java b/src/org/apache/bcel/generic/IFNULL.java
index 0e91ca1..4936f2c 100644
--- a/src/org/apache/bcel/generic/IFNULL.java
+++ b/src/org/apache/bcel/generic/IFNULL.java
@@ -16,49 +16,56 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* IFNULL - Branch if reference is not null
- *
- * Stack: ..., reference -> ...
- *
+ *
+ *
+ * Stack: ..., reference -> ...
+ *
+ *
* @version $Id: IFNULL.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IFNULL extends IfInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- IFNULL() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ IFNULL() {
+ }
- public IFNULL(InstructionHandle target) {
- super(org.apache.bcel.Constants.IFNULL, target);
- }
+ public IFNULL(InstructionHandle target) {
+ super(org.apache.bcel.Constants.IFNULL, target);
+ }
+ /**
+ * @return negation of instruction
+ */
+ @Override
+ public IfInstruction negate() {
+ return new IFNONNULL(target);
+ }
- /**
- * @return negation of instruction
- */
- public IfInstruction negate() {
- return new IFNONNULL(target);
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackConsumer(this);
- v.visitBranchInstruction(this);
- v.visitIfInstruction(this);
- v.visitIFNULL(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackConsumer(this);
+ v.visitBranchInstruction(this);
+ v.visitIfInstruction(this);
+ v.visitIFNULL(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IF_ACMPEQ.java b/src/org/apache/bcel/generic/IF_ACMPEQ.java
index 42eed3b..ac61b05 100644
--- a/src/org/apache/bcel/generic/IF_ACMPEQ.java
+++ b/src/org/apache/bcel/generic/IF_ACMPEQ.java
@@ -16,49 +16,56 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* IF_ACMPEQ - Branch if reference comparison succeeds
- *
- * Stack: ..., value1, value2 -> ...
- *
+ *
+ *
+ * Stack: ..., value1, value2 -> ...
+ *
+ *
* @version $Id: IF_ACMPEQ.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IF_ACMPEQ extends IfInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- IF_ACMPEQ() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ IF_ACMPEQ() {
+ }
- public IF_ACMPEQ(InstructionHandle target) {
- super(org.apache.bcel.Constants.IF_ACMPEQ, target);
- }
+ public IF_ACMPEQ(InstructionHandle target) {
+ super(org.apache.bcel.Constants.IF_ACMPEQ, target);
+ }
+ /**
+ * @return negation of instruction
+ */
+ @Override
+ public IfInstruction negate() {
+ return new IF_ACMPNE(target);
+ }
- /**
- * @return negation of instruction
- */
- public IfInstruction negate() {
- return new IF_ACMPNE(target);
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackConsumer(this);
- v.visitBranchInstruction(this);
- v.visitIfInstruction(this);
- v.visitIF_ACMPEQ(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackConsumer(this);
+ v.visitBranchInstruction(this);
+ v.visitIfInstruction(this);
+ v.visitIF_ACMPEQ(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IF_ACMPNE.java b/src/org/apache/bcel/generic/IF_ACMPNE.java
index 14fc230..ddb4a4d 100644
--- a/src/org/apache/bcel/generic/IF_ACMPNE.java
+++ b/src/org/apache/bcel/generic/IF_ACMPNE.java
@@ -16,49 +16,56 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* IF_ACMPNE - Branch if reference comparison doesn't succeed
- *
- * Stack: ..., value1, value2 -> ...
- *
+ *
+ *
+ * Stack: ..., value1, value2 -> ...
+ *
+ *
* @version $Id: IF_ACMPNE.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IF_ACMPNE extends IfInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- IF_ACMPNE() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ IF_ACMPNE() {
+ }
- public IF_ACMPNE(InstructionHandle target) {
- super(org.apache.bcel.Constants.IF_ACMPNE, target);
- }
+ public IF_ACMPNE(InstructionHandle target) {
+ super(org.apache.bcel.Constants.IF_ACMPNE, target);
+ }
+ /**
+ * @return negation of instruction
+ */
+ @Override
+ public IfInstruction negate() {
+ return new IF_ACMPEQ(target);
+ }
- /**
- * @return negation of instruction
- */
- public IfInstruction negate() {
- return new IF_ACMPEQ(target);
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackConsumer(this);
- v.visitBranchInstruction(this);
- v.visitIfInstruction(this);
- v.visitIF_ACMPNE(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackConsumer(this);
+ v.visitBranchInstruction(this);
+ v.visitIfInstruction(this);
+ v.visitIF_ACMPNE(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IF_ICMPEQ.java b/src/org/apache/bcel/generic/IF_ICMPEQ.java
index 5308842..d7dfb4d 100644
--- a/src/org/apache/bcel/generic/IF_ICMPEQ.java
+++ b/src/org/apache/bcel/generic/IF_ICMPEQ.java
@@ -16,49 +16,56 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* IF_ICMPEQ - Branch if int comparison succeeds
- *
- * Stack: ..., value1, value2 -> ...
- *
+ *
+ *
+ * Stack: ..., value1, value2 -> ...
+ *
+ *
* @version $Id: IF_ICMPEQ.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IF_ICMPEQ extends IfInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- IF_ICMPEQ() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ IF_ICMPEQ() {
+ }
- public IF_ICMPEQ(InstructionHandle target) {
- super(org.apache.bcel.Constants.IF_ICMPEQ, target);
- }
+ public IF_ICMPEQ(InstructionHandle target) {
+ super(org.apache.bcel.Constants.IF_ICMPEQ, target);
+ }
+ /**
+ * @return negation of instruction
+ */
+ @Override
+ public IfInstruction negate() {
+ return new IF_ICMPNE(target);
+ }
- /**
- * @return negation of instruction
- */
- public IfInstruction negate() {
- return new IF_ICMPNE(target);
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackConsumer(this);
- v.visitBranchInstruction(this);
- v.visitIfInstruction(this);
- v.visitIF_ICMPEQ(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackConsumer(this);
+ v.visitBranchInstruction(this);
+ v.visitIfInstruction(this);
+ v.visitIF_ICMPEQ(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IF_ICMPGE.java b/src/org/apache/bcel/generic/IF_ICMPGE.java
index 9e23be2..7d30e01 100644
--- a/src/org/apache/bcel/generic/IF_ICMPGE.java
+++ b/src/org/apache/bcel/generic/IF_ICMPGE.java
@@ -16,49 +16,56 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* IF_ICMPGE - Branch if int comparison succeeds
- *
- * Stack: ..., value1, value2 -> ...
- *
+ *
+ *
+ * Stack: ..., value1, value2 -> ...
+ *
+ *
* @version $Id: IF_ICMPGE.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IF_ICMPGE extends IfInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- IF_ICMPGE() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ IF_ICMPGE() {
+ }
- public IF_ICMPGE(InstructionHandle target) {
- super(org.apache.bcel.Constants.IF_ICMPGE, target);
- }
+ public IF_ICMPGE(InstructionHandle target) {
+ super(org.apache.bcel.Constants.IF_ICMPGE, target);
+ }
+ /**
+ * @return negation of instruction
+ */
+ @Override
+ public IfInstruction negate() {
+ return new IF_ICMPLT(target);
+ }
- /**
- * @return negation of instruction
- */
- public IfInstruction negate() {
- return new IF_ICMPLT(target);
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackConsumer(this);
- v.visitBranchInstruction(this);
- v.visitIfInstruction(this);
- v.visitIF_ICMPGE(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackConsumer(this);
+ v.visitBranchInstruction(this);
+ v.visitIfInstruction(this);
+ v.visitIF_ICMPGE(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IF_ICMPGT.java b/src/org/apache/bcel/generic/IF_ICMPGT.java
index 32f1ece..cc907ad 100644
--- a/src/org/apache/bcel/generic/IF_ICMPGT.java
+++ b/src/org/apache/bcel/generic/IF_ICMPGT.java
@@ -16,49 +16,56 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* IF_ICMPGT - Branch if int comparison succeeds
- *
- * Stack: ..., value1, value2 -> ...
- *
+ *
+ *
+ * Stack: ..., value1, value2 -> ...
+ *
+ *
* @version $Id: IF_ICMPGT.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IF_ICMPGT extends IfInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- IF_ICMPGT() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ IF_ICMPGT() {
+ }
- public IF_ICMPGT(InstructionHandle target) {
- super(org.apache.bcel.Constants.IF_ICMPGT, target);
- }
+ public IF_ICMPGT(InstructionHandle target) {
+ super(org.apache.bcel.Constants.IF_ICMPGT, target);
+ }
+ /**
+ * @return negation of instruction
+ */
+ @Override
+ public IfInstruction negate() {
+ return new IF_ICMPLE(target);
+ }
- /**
- * @return negation of instruction
- */
- public IfInstruction negate() {
- return new IF_ICMPLE(target);
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackConsumer(this);
- v.visitBranchInstruction(this);
- v.visitIfInstruction(this);
- v.visitIF_ICMPGT(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackConsumer(this);
+ v.visitBranchInstruction(this);
+ v.visitIfInstruction(this);
+ v.visitIF_ICMPGT(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IF_ICMPLE.java b/src/org/apache/bcel/generic/IF_ICMPLE.java
index 381a78b..0e30a5f 100644
--- a/src/org/apache/bcel/generic/IF_ICMPLE.java
+++ b/src/org/apache/bcel/generic/IF_ICMPLE.java
@@ -16,49 +16,56 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* IF_ICMPLE - Branch if int comparison succeeds
- *
- * Stack: ..., value1, value2 -> ...
- *
+ *
+ *
+ * Stack: ..., value1, value2 -> ...
+ *
+ *
* @version $Id: IF_ICMPLE.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IF_ICMPLE extends IfInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- IF_ICMPLE() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ IF_ICMPLE() {
+ }
- public IF_ICMPLE(InstructionHandle target) {
- super(org.apache.bcel.Constants.IF_ICMPLE, target);
- }
+ public IF_ICMPLE(InstructionHandle target) {
+ super(org.apache.bcel.Constants.IF_ICMPLE, target);
+ }
+ /**
+ * @return negation of instruction
+ */
+ @Override
+ public IfInstruction negate() {
+ return new IF_ICMPGT(target);
+ }
- /**
- * @return negation of instruction
- */
- public IfInstruction negate() {
- return new IF_ICMPGT(target);
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackConsumer(this);
- v.visitBranchInstruction(this);
- v.visitIfInstruction(this);
- v.visitIF_ICMPLE(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackConsumer(this);
+ v.visitBranchInstruction(this);
+ v.visitIfInstruction(this);
+ v.visitIF_ICMPLE(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IF_ICMPLT.java b/src/org/apache/bcel/generic/IF_ICMPLT.java
index c9e269e..9ebabcd 100644
--- a/src/org/apache/bcel/generic/IF_ICMPLT.java
+++ b/src/org/apache/bcel/generic/IF_ICMPLT.java
@@ -16,49 +16,56 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* IF_ICMPLT - Branch if int comparison succeeds
- *
- * Stack: ..., value1, value2 -> ...
- *
+ *
+ *
+ * Stack: ..., value1, value2 -> ...
+ *
+ *
* @version $Id: IF_ICMPLT.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IF_ICMPLT extends IfInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- IF_ICMPLT() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ IF_ICMPLT() {
+ }
- public IF_ICMPLT(InstructionHandle target) {
- super(org.apache.bcel.Constants.IF_ICMPLT, target);
- }
+ public IF_ICMPLT(InstructionHandle target) {
+ super(org.apache.bcel.Constants.IF_ICMPLT, target);
+ }
+ /**
+ * @return negation of instruction
+ */
+ @Override
+ public IfInstruction negate() {
+ return new IF_ICMPGE(target);
+ }
- /**
- * @return negation of instruction
- */
- public IfInstruction negate() {
- return new IF_ICMPGE(target);
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackConsumer(this);
- v.visitBranchInstruction(this);
- v.visitIfInstruction(this);
- v.visitIF_ICMPLT(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackConsumer(this);
+ v.visitBranchInstruction(this);
+ v.visitIfInstruction(this);
+ v.visitIF_ICMPLT(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IF_ICMPNE.java b/src/org/apache/bcel/generic/IF_ICMPNE.java
index 537b416..ca67f6c 100644
--- a/src/org/apache/bcel/generic/IF_ICMPNE.java
+++ b/src/org/apache/bcel/generic/IF_ICMPNE.java
@@ -16,49 +16,56 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* IF_ICMPNE - Branch if int comparison doesn't succeed
- *
- * Stack: ..., value1, value2 -> ...
- *
+ *
+ *
+ * Stack: ..., value1, value2 -> ...
+ *
+ *
* @version $Id: IF_ICMPNE.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IF_ICMPNE extends IfInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- IF_ICMPNE() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ IF_ICMPNE() {
+ }
- public IF_ICMPNE(InstructionHandle target) {
- super(org.apache.bcel.Constants.IF_ICMPNE, target);
- }
+ public IF_ICMPNE(InstructionHandle target) {
+ super(org.apache.bcel.Constants.IF_ICMPNE, target);
+ }
+ /**
+ * @return negation of instruction
+ */
+ @Override
+ public IfInstruction negate() {
+ return new IF_ICMPEQ(target);
+ }
- /**
- * @return negation of instruction
- */
- public IfInstruction negate() {
- return new IF_ICMPEQ(target);
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitStackConsumer(this);
- v.visitBranchInstruction(this);
- v.visitIfInstruction(this);
- v.visitIF_ICMPNE(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitStackConsumer(this);
+ v.visitBranchInstruction(this);
+ v.visitIfInstruction(this);
+ v.visitIF_ICMPNE(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IINC.java b/src/org/apache/bcel/generic/IINC.java
index 72af3ab..ecd01d4 100644
--- a/src/org/apache/bcel/generic/IINC.java
+++ b/src/org/apache/bcel/generic/IINC.java
@@ -22,137 +22,144 @@ import org.apache.bcel.util.ByteSequence;
/**
* IINC - Increment local variable by constant
- *
+ *
* @version $Id: IINC.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IINC extends LocalVariableInstruction {
- private boolean wide;
- private int c;
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ private boolean wide;
+ private int c;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ IINC() {
+ }
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- IINC() {
- }
+ /**
+ * @param n
+ * index of local variable
+ * @param c
+ * increment factor
+ */
+ public IINC(int n, int c) {
+ super(); // Default behaviour of LocalVariableInstruction causes error
+ this.opcode = org.apache.bcel.Constants.IINC;
+ this.length = (short) 3;
+ setIndex(n); // May set wide as side effect
+ setIncrement(c);
+ }
+ /**
+ * Dump instruction as byte code to stream out.
+ *
+ * @param out
+ * Output stream
+ */
+ @Override
+ public void dump(DataOutputStream out) throws IOException {
+ if (wide) {
+ out.writeByte(org.apache.bcel.Constants.WIDE);
+ }
+ out.writeByte(opcode);
+ if (wide) {
+ out.writeShort(n);
+ out.writeShort(c);
+ } else {
+ out.writeByte(n);
+ out.writeByte(c);
+ }
+ }
- /**
- * @param n index of local variable
- * @param c increment factor
- */
- public IINC(int n, int c) {
- super(); // Default behaviour of LocalVariableInstruction causes error
- this.opcode = org.apache.bcel.Constants.IINC;
- this.length = (short) 3;
- setIndex(n); // May set wide as side effect
- setIncrement(c);
- }
+ private final void setWide() {
+ wide = (n > org.apache.bcel.Constants.MAX_BYTE)
+ || (Math.abs(c) > Byte.MAX_VALUE);
+ if (wide) {
+ length = 6; // wide byte included
+ } else {
+ length = 3;
+ }
+ }
+ /**
+ * Read needed data (e.g. index) from file.
+ */
+ @Override
+ protected void initFromFile(ByteSequence bytes, boolean wide)
+ throws IOException {
+ this.wide = wide;
+ if (wide) {
+ length = 6;
+ n = bytes.readUnsignedShort();
+ c = bytes.readShort();
+ } else {
+ length = 3;
+ n = bytes.readUnsignedByte();
+ c = bytes.readByte();
+ }
+ }
- /**
- * Dump instruction as byte code to stream out.
- * @param out Output stream
- */
- public void dump( DataOutputStream out ) throws IOException {
- if (wide) {
- out.writeByte(org.apache.bcel.Constants.WIDE);
- }
- out.writeByte(opcode);
- if (wide) {
- out.writeShort(n);
- out.writeShort(c);
- } else {
- out.writeByte(n);
- out.writeByte(c);
- }
- }
+ /**
+ * @return mnemonic for instruction
+ */
+ @Override
+ public String toString(boolean verbose) {
+ return super.toString(verbose) + " " + c;
+ }
+ /**
+ * Set index of local variable.
+ */
+ @Override
+ public final void setIndex(int n) {
+ if (n < 0) {
+ throw new ClassGenException("Negative index value: " + n);
+ }
+ this.n = n;
+ setWide();
+ }
- private final void setWide() {
- wide = (n > org.apache.bcel.Constants.MAX_BYTE) || (Math.abs(c) > Byte.MAX_VALUE);
- if (wide) {
- length = 6; // wide byte included
- } else {
- length = 3;
- }
- }
+ /**
+ * @return increment factor
+ */
+ public final int getIncrement() {
+ return c;
+ }
+ /**
+ * Set increment factor.
+ */
+ public final void setIncrement(int c) {
+ this.c = c;
+ setWide();
+ }
- /**
- * Read needed data (e.g. index) from file.
- */
- protected void initFromFile( ByteSequence bytes, boolean wide ) throws IOException {
- this.wide = wide;
- if (wide) {
- length = 6;
- n = bytes.readUnsignedShort();
- c = bytes.readShort();
- } else {
- length = 3;
- n = bytes.readUnsignedByte();
- c = bytes.readByte();
- }
- }
+ /**
+ * @return int type
+ */
+ @Override
+ public Type getType(ConstantPoolGen cp) {
+ return Type.INT;
+ }
-
- /**
- * @return mnemonic for instruction
- */
- public String toString( boolean verbose ) {
- return super.toString(verbose) + " " + c;
- }
-
-
- /**
- * Set index of local variable.
- */
- public final void setIndex( int n ) {
- if (n < 0) {
- throw new ClassGenException("Negative index value: " + n);
- }
- this.n = n;
- setWide();
- }
-
-
- /**
- * @return increment factor
- */
- public final int getIncrement() {
- return c;
- }
-
-
- /**
- * Set increment factor.
- */
- public final void setIncrement( int c ) {
- this.c = c;
- setWide();
- }
-
-
- /** @return int type
- */
- public Type getType( ConstantPoolGen cp ) {
- return Type.INT;
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitLocalVariableInstruction(this);
- v.visitIINC(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitLocalVariableInstruction(this);
+ v.visitIINC(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/ILOAD.java b/src/org/apache/bcel/generic/ILOAD.java
index 64368d3..bdcacca 100644
--- a/src/org/apache/bcel/generic/ILOAD.java
+++ b/src/org/apache/bcel/generic/ILOAD.java
@@ -16,42 +16,55 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* ILOAD - Load int from local variable onto stack
- * Stack: ... -> ..., result
- *
+ *
+ *
+ * Stack: ... -> ..., result
+ *
+ *
* @version $Id: ILOAD.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class ILOAD extends LoadInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- ILOAD() {
- super(org.apache.bcel.Constants.ILOAD, org.apache.bcel.Constants.ILOAD_0);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ ILOAD() {
+ super(org.apache.bcel.Constants.ILOAD,
+ org.apache.bcel.Constants.ILOAD_0);
+ }
- /** Load int from local variable
- * @param n index of local variable
- */
- public ILOAD(int n) {
- super(org.apache.bcel.Constants.ILOAD, org.apache.bcel.Constants.ILOAD_0, n);
- }
+ /**
+ * Load int from local variable
+ *
+ * @param n
+ * index of local variable
+ */
+ public ILOAD(int n) {
+ super(org.apache.bcel.Constants.ILOAD,
+ org.apache.bcel.Constants.ILOAD_0, n);
+ }
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- super.accept(v);
- v.visitILOAD(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ super.accept(v);
+ v.visitILOAD(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IMPDEP1.java b/src/org/apache/bcel/generic/IMPDEP1.java
index 2d16659..cfc560b 100644
--- a/src/org/apache/bcel/generic/IMPDEP1.java
+++ b/src/org/apache/bcel/generic/IMPDEP1.java
@@ -18,26 +18,32 @@ package org.apache.bcel.generic;
/**
* IMPDEP1 - Implementation dependent
- *
+ *
* @version $Id: IMPDEP1.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IMPDEP1 extends Instruction {
- public IMPDEP1() {
- super(org.apache.bcel.Constants.IMPDEP1, (short) 1);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ public IMPDEP1() {
+ super(org.apache.bcel.Constants.IMPDEP1, (short) 1);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitIMPDEP1(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitIMPDEP1(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IMPDEP2.java b/src/org/apache/bcel/generic/IMPDEP2.java
index 4efdb87..cd57b29 100644
--- a/src/org/apache/bcel/generic/IMPDEP2.java
+++ b/src/org/apache/bcel/generic/IMPDEP2.java
@@ -18,26 +18,32 @@ package org.apache.bcel.generic;
/**
* IMPDEP2 - Implementation dependent
- *
+ *
* @version $Id: IMPDEP2.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IMPDEP2 extends Instruction {
- public IMPDEP2() {
- super(org.apache.bcel.Constants.IMPDEP2, (short) 1);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ public IMPDEP2() {
+ super(org.apache.bcel.Constants.IMPDEP2, (short) 1);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitIMPDEP2(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitIMPDEP2(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IMUL.java b/src/org/apache/bcel/generic/IMUL.java
index bb212c2..b944b5b 100644
--- a/src/org/apache/bcel/generic/IMUL.java
+++ b/src/org/apache/bcel/generic/IMUL.java
@@ -16,35 +16,45 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* IMUL - Multiply ints
- * Stack: ..., value1, value2 -> result
- *
+ *
+ *
+ * Stack: ..., value1, value2 -> result
+ *
+ *
* @version $Id: IMUL.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IMUL extends ArithmeticInstruction {
- /** Multiply ints
- */
- public IMUL() {
- super(org.apache.bcel.Constants.IMUL);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Multiply ints
+ */
+ public IMUL() {
+ super(org.apache.bcel.Constants.IMUL);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitArithmeticInstruction(this);
- v.visitIMUL(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitArithmeticInstruction(this);
+ v.visitIMUL(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/INEG.java b/src/org/apache/bcel/generic/INEG.java
index c7ef3c8..db25323 100644
--- a/src/org/apache/bcel/generic/INEG.java
+++ b/src/org/apache/bcel/generic/INEG.java
@@ -16,33 +16,42 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* INEG - Negate int
- * Stack: ..., value -> ..., result
- *
+ *
+ *
+ * Stack: ..., value -> ..., result
+ *
+ *
* @version $Id: INEG.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class INEG extends ArithmeticInstruction {
- public INEG() {
- super(org.apache.bcel.Constants.INEG);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ public INEG() {
+ super(org.apache.bcel.Constants.INEG);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitArithmeticInstruction(this);
- v.visitINEG(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitArithmeticInstruction(this);
+ v.visitINEG(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/INSTANCEOF.java b/src/org/apache/bcel/generic/INSTANCEOF.java
index 139f708..db79830 100644
--- a/src/org/apache/bcel/generic/INSTANCEOF.java
+++ b/src/org/apache/bcel/generic/INSTANCEOF.java
@@ -16,58 +16,66 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* INSTANCEOF - Determine if object is of given type
- * Stack: ..., objectref -> ..., result
- *
+ *
+ *
+ * Stack: ..., objectref -> ..., result
+ *
+ *
* @version $Id: INSTANCEOF.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
-public class INSTANCEOF extends CPInstruction implements LoadClass, ExceptionThrower,
- StackProducer, StackConsumer {
+public class INSTANCEOF extends CPInstruction implements LoadClass,
+ ExceptionThrower, StackProducer, StackConsumer {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- INSTANCEOF() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ INSTANCEOF() {
+ }
- public INSTANCEOF(int index) {
- super(org.apache.bcel.Constants.INSTANCEOF, index);
- }
+ public INSTANCEOF(int index) {
+ super(org.apache.bcel.Constants.INSTANCEOF, index);
+ }
+ @Override
+ public Class[] getExceptions() {
+ return org.apache.bcel.ExceptionConstants.EXCS_CLASS_AND_INTERFACE_RESOLUTION;
+ }
- public Class[] getExceptions() {
- return org.apache.bcel.ExceptionConstants.EXCS_CLASS_AND_INTERFACE_RESOLUTION;
- }
+ @Override
+ public ObjectType getLoadClassType(ConstantPoolGen cpg) {
+ Type t = getType(cpg);
+ if (t instanceof ArrayType) {
+ t = ((ArrayType) t).getBasicType();
+ }
+ return (t instanceof ObjectType) ? (ObjectType) t : null;
+ }
-
- public ObjectType getLoadClassType( ConstantPoolGen cpg ) {
- Type t = getType(cpg);
- if (t instanceof ArrayType) {
- t = ((ArrayType) t).getBasicType();
- }
- return (t instanceof ObjectType) ? (ObjectType) t : null;
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitLoadClass(this);
- v.visitExceptionThrower(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitTypedInstruction(this);
- v.visitCPInstruction(this);
- v.visitINSTANCEOF(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitLoadClass(this);
+ v.visitExceptionThrower(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitTypedInstruction(this);
+ v.visitCPInstruction(this);
+ v.visitINSTANCEOF(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/INVOKEINTERFACE.java b/src/org/apache/bcel/generic/INVOKEINTERFACE.java
index 99da626..4af8f41 100644
--- a/src/org/apache/bcel/generic/INVOKEINTERFACE.java
+++ b/src/org/apache/bcel/generic/INVOKEINTERFACE.java
@@ -23,110 +23,122 @@ import org.apache.bcel.ExceptionConstants;
import org.apache.bcel.classfile.ConstantPool;
import org.apache.bcel.util.ByteSequence;
-/**
+/**
* INVOKEINTERFACE - Invoke interface method
- * Stack: ..., objectref, [arg1, [arg2 ...]] -> ...
- *
+ *
+ *
+ * Stack: ..., objectref, [arg1, [arg2 ...]] -> ...
+ *
+ *
* @version $Id: INVOKEINTERFACE.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public final class INVOKEINTERFACE extends InvokeInstruction {
- private int nargs; // Number of arguments on stack (number of stack slots), called "count" in vmspec2
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ private int nargs; // Number of arguments on stack (number of stack slots),
+ // called "count" in vmspec2
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ INVOKEINTERFACE() {
+ }
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- INVOKEINTERFACE() {
- }
+ public INVOKEINTERFACE(int index, int nargs) {
+ super(Constants.INVOKEINTERFACE, index);
+ length = 5;
+ if (nargs < 1) {
+ throw new ClassGenException("Number of arguments must be > 0 "
+ + nargs);
+ }
+ this.nargs = nargs;
+ }
+ /**
+ * Dump instruction as byte code to stream out.
+ *
+ * @param out
+ * Output stream
+ */
+ @Override
+ public void dump(DataOutputStream out) throws IOException {
+ out.writeByte(opcode);
+ out.writeShort(index);
+ out.writeByte(nargs);
+ out.writeByte(0);
+ }
- public INVOKEINTERFACE(int index, int nargs) {
- super(Constants.INVOKEINTERFACE, index);
- length = 5;
- if (nargs < 1) {
- throw new ClassGenException("Number of arguments must be > 0 " + nargs);
- }
- this.nargs = nargs;
- }
+ /**
+ * The count argument according to the Java Language Specification,
+ * Second Edition.
+ */
+ public int getCount() {
+ return nargs;
+ }
+ /**
+ * Read needed data (i.e., index) from file.
+ */
+ @Override
+ protected void initFromFile(ByteSequence bytes, boolean wide)
+ throws IOException {
+ super.initFromFile(bytes, wide);
+ length = 5;
+ nargs = bytes.readUnsignedByte();
+ bytes.readByte(); // Skip 0 byte
+ }
- /**
- * Dump instruction as byte code to stream out.
- * @param out Output stream
- */
- public void dump( DataOutputStream out ) throws IOException {
- out.writeByte(opcode);
- out.writeShort(index);
- out.writeByte(nargs);
- out.writeByte(0);
- }
+ /**
+ * @return mnemonic for instruction with symbolic references resolved
+ */
+ @Override
+ public String toString(ConstantPool cp) {
+ return super.toString(cp) + " " + nargs;
+ }
+ @Override
+ public int consumeStack(ConstantPoolGen cpg) { // nargs is given in
+ // byte-code
+ return nargs; // nargs includes this reference
+ }
- /**
- * The count argument according to the Java Language Specification,
- * Second Edition.
- */
- public int getCount() {
- return nargs;
- }
+ @Override
+ public Class[] getExceptions() {
+ Class[] cs = new Class[4 + ExceptionConstants.EXCS_INTERFACE_METHOD_RESOLUTION.length];
+ System.arraycopy(ExceptionConstants.EXCS_INTERFACE_METHOD_RESOLUTION,
+ 0, cs, 0,
+ ExceptionConstants.EXCS_INTERFACE_METHOD_RESOLUTION.length);
+ cs[ExceptionConstants.EXCS_INTERFACE_METHOD_RESOLUTION.length + 3] = ExceptionConstants.INCOMPATIBLE_CLASS_CHANGE_ERROR;
+ cs[ExceptionConstants.EXCS_INTERFACE_METHOD_RESOLUTION.length + 2] = ExceptionConstants.ILLEGAL_ACCESS_ERROR;
+ cs[ExceptionConstants.EXCS_INTERFACE_METHOD_RESOLUTION.length + 1] = ExceptionConstants.ABSTRACT_METHOD_ERROR;
+ cs[ExceptionConstants.EXCS_INTERFACE_METHOD_RESOLUTION.length] = ExceptionConstants.UNSATISFIED_LINK_ERROR;
+ return cs;
+ }
-
- /**
- * Read needed data (i.e., index) from file.
- */
- protected void initFromFile( ByteSequence bytes, boolean wide ) throws IOException {
- super.initFromFile(bytes, wide);
- length = 5;
- nargs = bytes.readUnsignedByte();
- bytes.readByte(); // Skip 0 byte
- }
-
-
- /**
- * @return mnemonic for instruction with symbolic references resolved
- */
- public String toString( ConstantPool cp ) {
- return super.toString(cp) + " " + nargs;
- }
-
-
- public int consumeStack( ConstantPoolGen cpg ) { // nargs is given in byte-code
- return nargs; // nargs includes this reference
- }
-
-
- public Class[] getExceptions() {
- Class[] cs = new Class[4 + ExceptionConstants.EXCS_INTERFACE_METHOD_RESOLUTION.length];
- System.arraycopy(ExceptionConstants.EXCS_INTERFACE_METHOD_RESOLUTION, 0, cs, 0,
- ExceptionConstants.EXCS_INTERFACE_METHOD_RESOLUTION.length);
- cs[ExceptionConstants.EXCS_INTERFACE_METHOD_RESOLUTION.length + 3] = ExceptionConstants.INCOMPATIBLE_CLASS_CHANGE_ERROR;
- cs[ExceptionConstants.EXCS_INTERFACE_METHOD_RESOLUTION.length + 2] = ExceptionConstants.ILLEGAL_ACCESS_ERROR;
- cs[ExceptionConstants.EXCS_INTERFACE_METHOD_RESOLUTION.length + 1] = ExceptionConstants.ABSTRACT_METHOD_ERROR;
- cs[ExceptionConstants.EXCS_INTERFACE_METHOD_RESOLUTION.length] = ExceptionConstants.UNSATISFIED_LINK_ERROR;
- return cs;
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitExceptionThrower(this);
- v.visitTypedInstruction(this);
- v.visitStackConsumer(this);
- v.visitStackProducer(this);
- v.visitLoadClass(this);
- v.visitCPInstruction(this);
- v.visitFieldOrMethod(this);
- v.visitInvokeInstruction(this);
- v.visitINVOKEINTERFACE(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitExceptionThrower(this);
+ v.visitTypedInstruction(this);
+ v.visitStackConsumer(this);
+ v.visitStackProducer(this);
+ v.visitLoadClass(this);
+ v.visitCPInstruction(this);
+ v.visitFieldOrMethod(this);
+ v.visitInvokeInstruction(this);
+ v.visitINVOKEINTERFACE(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/INVOKESPECIAL.java b/src/org/apache/bcel/generic/INVOKESPECIAL.java
index d960c49..3b9bfc5 100644
--- a/src/org/apache/bcel/generic/INVOKESPECIAL.java
+++ b/src/org/apache/bcel/generic/INVOKESPECIAL.java
@@ -19,59 +19,67 @@ package org.apache.bcel.generic;
import org.apache.bcel.Constants;
import org.apache.bcel.ExceptionConstants;
-/**
- * INVOKESPECIAL - Invoke instance method; special handling for superclass, private
- * and instance initialization method invocations
- *
- * Stack: ..., objectref, [arg1, [arg2 ...]] -> ...
- *
+/**
+ * INVOKESPECIAL - Invoke instance method; special handling for superclass,
+ * private and instance initialization method invocations
+ *
+ *
+ * Stack: ..., objectref, [arg1, [arg2 ...]] -> ...
+ *
+ *
* @version $Id: INVOKESPECIAL.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class INVOKESPECIAL extends InvokeInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- INVOKESPECIAL() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ INVOKESPECIAL() {
+ }
- public INVOKESPECIAL(int index) {
- super(Constants.INVOKESPECIAL, index);
- }
+ public INVOKESPECIAL(int index) {
+ super(Constants.INVOKESPECIAL, index);
+ }
+ @Override
+ public Class[] getExceptions() {
+ Class[] cs = new Class[4 + ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length];
+ System.arraycopy(ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION,
+ 0, cs, 0,
+ ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length);
+ cs[ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length + 3] = ExceptionConstants.UNSATISFIED_LINK_ERROR;
+ cs[ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length + 2] = ExceptionConstants.ABSTRACT_METHOD_ERROR;
+ cs[ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length + 1] = ExceptionConstants.INCOMPATIBLE_CLASS_CHANGE_ERROR;
+ cs[ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length] = ExceptionConstants.NULL_POINTER_EXCEPTION;
+ return cs;
+ }
- public Class[] getExceptions() {
- Class[] cs = new Class[4 + ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length];
- System.arraycopy(ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION, 0, cs, 0,
- ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length);
- cs[ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length + 3] = ExceptionConstants.UNSATISFIED_LINK_ERROR;
- cs[ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length + 2] = ExceptionConstants.ABSTRACT_METHOD_ERROR;
- cs[ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length + 1] = ExceptionConstants.INCOMPATIBLE_CLASS_CHANGE_ERROR;
- cs[ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length] = ExceptionConstants.NULL_POINTER_EXCEPTION;
- return cs;
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitExceptionThrower(this);
- v.visitTypedInstruction(this);
- v.visitStackConsumer(this);
- v.visitStackProducer(this);
- v.visitLoadClass(this);
- v.visitCPInstruction(this);
- v.visitFieldOrMethod(this);
- v.visitInvokeInstruction(this);
- v.visitINVOKESPECIAL(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitExceptionThrower(this);
+ v.visitTypedInstruction(this);
+ v.visitStackConsumer(this);
+ v.visitStackProducer(this);
+ v.visitLoadClass(this);
+ v.visitCPInstruction(this);
+ v.visitFieldOrMethod(this);
+ v.visitInvokeInstruction(this);
+ v.visitINVOKESPECIAL(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/INVOKESTATIC.java b/src/org/apache/bcel/generic/INVOKESTATIC.java
index 6300182..72409d4 100644
--- a/src/org/apache/bcel/generic/INVOKESTATIC.java
+++ b/src/org/apache/bcel/generic/INVOKESTATIC.java
@@ -19,56 +19,64 @@ package org.apache.bcel.generic;
import org.apache.bcel.Constants;
import org.apache.bcel.ExceptionConstants;
-/**
+/**
* INVOKESTATIC - Invoke a class (static) method
- *
- * Stack: ..., [arg1, [arg2 ...]] -> ...
- *
+ *
+ *
+ * Stack: ..., [arg1, [arg2 ...]] -> ...
+ *
+ *
* @version $Id: INVOKESTATIC.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class INVOKESTATIC extends InvokeInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- INVOKESTATIC() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ INVOKESTATIC() {
+ }
- public INVOKESTATIC(int index) {
- super(Constants.INVOKESTATIC, index);
- }
+ public INVOKESTATIC(int index) {
+ super(Constants.INVOKESTATIC, index);
+ }
+ @Override
+ public Class[] getExceptions() {
+ Class[] cs = new Class[2 + ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length];
+ System.arraycopy(ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION,
+ 0, cs, 0,
+ ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length);
+ cs[ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length] = ExceptionConstants.UNSATISFIED_LINK_ERROR;
+ cs[ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length + 1] = ExceptionConstants.INCOMPATIBLE_CLASS_CHANGE_ERROR;
+ return cs;
+ }
- public Class[] getExceptions() {
- Class[] cs = new Class[2 + ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length];
- System.arraycopy(ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION, 0, cs, 0,
- ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length);
- cs[ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length] = ExceptionConstants.UNSATISFIED_LINK_ERROR;
- cs[ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length + 1] = ExceptionConstants.INCOMPATIBLE_CLASS_CHANGE_ERROR;
- return cs;
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitExceptionThrower(this);
- v.visitTypedInstruction(this);
- v.visitStackConsumer(this);
- v.visitStackProducer(this);
- v.visitLoadClass(this);
- v.visitCPInstruction(this);
- v.visitFieldOrMethod(this);
- v.visitInvokeInstruction(this);
- v.visitINVOKESTATIC(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitExceptionThrower(this);
+ v.visitTypedInstruction(this);
+ v.visitStackConsumer(this);
+ v.visitStackProducer(this);
+ v.visitLoadClass(this);
+ v.visitCPInstruction(this);
+ v.visitFieldOrMethod(this);
+ v.visitInvokeInstruction(this);
+ v.visitINVOKESTATIC(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/INVOKEVIRTUAL.java b/src/org/apache/bcel/generic/INVOKEVIRTUAL.java
index d4faaac..fd4fbee 100644
--- a/src/org/apache/bcel/generic/INVOKEVIRTUAL.java
+++ b/src/org/apache/bcel/generic/INVOKEVIRTUAL.java
@@ -19,58 +19,66 @@ package org.apache.bcel.generic;
import org.apache.bcel.Constants;
import org.apache.bcel.ExceptionConstants;
-/**
+/**
* INVOKEVIRTUAL - Invoke instance method; dispatch based on class
- *
- * Stack: ..., objectref, [arg1, [arg2 ...]] -> ...
- *
+ *
+ *
+ * Stack: ..., objectref, [arg1, [arg2 ...]] -> ...
+ *
+ *
* @version $Id: INVOKEVIRTUAL.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class INVOKEVIRTUAL extends InvokeInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- INVOKEVIRTUAL() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ INVOKEVIRTUAL() {
+ }
- public INVOKEVIRTUAL(int index) {
- super(Constants.INVOKEVIRTUAL, index);
- }
+ public INVOKEVIRTUAL(int index) {
+ super(Constants.INVOKEVIRTUAL, index);
+ }
+ @Override
+ public Class[] getExceptions() {
+ Class[] cs = new Class[4 + ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length];
+ System.arraycopy(ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION,
+ 0, cs, 0,
+ ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length);
+ cs[ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length + 3] = ExceptionConstants.UNSATISFIED_LINK_ERROR;
+ cs[ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length + 2] = ExceptionConstants.ABSTRACT_METHOD_ERROR;
+ cs[ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length + 1] = ExceptionConstants.INCOMPATIBLE_CLASS_CHANGE_ERROR;
+ cs[ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length] = ExceptionConstants.NULL_POINTER_EXCEPTION;
+ return cs;
+ }
- public Class[] getExceptions() {
- Class[] cs = new Class[4 + ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length];
- System.arraycopy(ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION, 0, cs, 0,
- ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length);
- cs[ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length + 3] = ExceptionConstants.UNSATISFIED_LINK_ERROR;
- cs[ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length + 2] = ExceptionConstants.ABSTRACT_METHOD_ERROR;
- cs[ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length + 1] = ExceptionConstants.INCOMPATIBLE_CLASS_CHANGE_ERROR;
- cs[ExceptionConstants.EXCS_FIELD_AND_METHOD_RESOLUTION.length] = ExceptionConstants.NULL_POINTER_EXCEPTION;
- return cs;
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitExceptionThrower(this);
- v.visitTypedInstruction(this);
- v.visitStackConsumer(this);
- v.visitStackProducer(this);
- v.visitLoadClass(this);
- v.visitCPInstruction(this);
- v.visitFieldOrMethod(this);
- v.visitInvokeInstruction(this);
- v.visitINVOKEVIRTUAL(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitExceptionThrower(this);
+ v.visitTypedInstruction(this);
+ v.visitStackConsumer(this);
+ v.visitStackProducer(this);
+ v.visitLoadClass(this);
+ v.visitCPInstruction(this);
+ v.visitFieldOrMethod(this);
+ v.visitInvokeInstruction(this);
+ v.visitINVOKEVIRTUAL(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IOR.java b/src/org/apache/bcel/generic/IOR.java
index c1c6598..21547eb 100644
--- a/src/org/apache/bcel/generic/IOR.java
+++ b/src/org/apache/bcel/generic/IOR.java
@@ -16,33 +16,42 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* IOR - Bitwise OR int
- * Stack: ..., value1, value2 -> ..., result
- *
+ *
+ *
+ * Stack: ..., value1, value2 -> ..., result
+ *
+ *
* @version $Id: IOR.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IOR extends ArithmeticInstruction {
- public IOR() {
- super(org.apache.bcel.Constants.IOR);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ public IOR() {
+ super(org.apache.bcel.Constants.IOR);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitArithmeticInstruction(this);
- v.visitIOR(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitArithmeticInstruction(this);
+ v.visitIOR(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IREM.java b/src/org/apache/bcel/generic/IREM.java
index 9504b9d..4977625 100644
--- a/src/org/apache/bcel/generic/IREM.java
+++ b/src/org/apache/bcel/generic/IREM.java
@@ -18,43 +18,52 @@ package org.apache.bcel.generic;
/**
* IREM - Remainder of int
- * Stack: ..., value1, value2 -> result
- *
+ *
+ *
+ * Stack: ..., value1, value2 -> result
+ *
+ *
* @version $Id: IREM.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IREM extends ArithmeticInstruction implements ExceptionThrower {
- /** Remainder of ints
- */
- public IREM() {
- super(org.apache.bcel.Constants.IREM);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Remainder of ints
+ */
+ public IREM() {
+ super(org.apache.bcel.Constants.IREM);
+ }
- /** @return exceptions this instruction may cause
- */
- public Class[] getExceptions() {
- return new Class[] {
- org.apache.bcel.ExceptionConstants.ARITHMETIC_EXCEPTION
- };
- }
+ /**
+ * @return exceptions this instruction may cause
+ */
+ @Override
+ public Class[] getExceptions() {
+ return new Class[] { org.apache.bcel.ExceptionConstants.ARITHMETIC_EXCEPTION };
+ }
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitExceptionThrower(this);
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitArithmeticInstruction(this);
- v.visitIREM(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitExceptionThrower(this);
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitArithmeticInstruction(this);
+ v.visitIREM(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IRETURN.java b/src/org/apache/bcel/generic/IRETURN.java
index 61d45bd..767b4be 100644
--- a/src/org/apache/bcel/generic/IRETURN.java
+++ b/src/org/apache/bcel/generic/IRETURN.java
@@ -16,35 +16,45 @@
*/
package org.apache.bcel.generic;
-/**
- * IRETURN - Return int from method
- * Stack: ..., value -> <empty>
- *
+/**
+ * IRETURN - Return int from method
+ *
+ *
+ * Stack: ..., value -> <empty>
+ *
+ *
* @version $Id: IRETURN.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IRETURN extends ReturnInstruction {
- /** Return int from method
- */
- public IRETURN() {
- super(org.apache.bcel.Constants.IRETURN);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Return int from method
+ */
+ public IRETURN() {
+ super(org.apache.bcel.Constants.IRETURN);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitExceptionThrower(this);
- v.visitTypedInstruction(this);
- v.visitStackConsumer(this);
- v.visitReturnInstruction(this);
- v.visitIRETURN(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitExceptionThrower(this);
+ v.visitTypedInstruction(this);
+ v.visitStackConsumer(this);
+ v.visitReturnInstruction(this);
+ v.visitIRETURN(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/ISHL.java b/src/org/apache/bcel/generic/ISHL.java
index 510773c..05244cf 100644
--- a/src/org/apache/bcel/generic/ISHL.java
+++ b/src/org/apache/bcel/generic/ISHL.java
@@ -18,31 +18,40 @@ package org.apache.bcel.generic;
/**
* ISHL - Arithmetic shift left int
- * Stack: ..., value1, value2 -> ..., result
- *
+ *
+ *
+ * Stack: ..., value1, value2 -> ..., result
+ *
+ *
* @version $Id: ISHL.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class ISHL extends ArithmeticInstruction {
- public ISHL() {
- super(org.apache.bcel.Constants.ISHL);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ public ISHL() {
+ super(org.apache.bcel.Constants.ISHL);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitArithmeticInstruction(this);
- v.visitISHL(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitArithmeticInstruction(this);
+ v.visitISHL(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/ISHR.java b/src/org/apache/bcel/generic/ISHR.java
index 2bc71a3..03f3178 100644
--- a/src/org/apache/bcel/generic/ISHR.java
+++ b/src/org/apache/bcel/generic/ISHR.java
@@ -18,31 +18,40 @@ package org.apache.bcel.generic;
/**
* ISHR - Arithmetic shift right int
- * Stack: ..., value1, value2 -> ..., result
- *
+ *
+ *
+ * Stack: ..., value1, value2 -> ..., result
+ *
+ *
* @version $Id: ISHR.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class ISHR extends ArithmeticInstruction {
- public ISHR() {
- super(org.apache.bcel.Constants.ISHR);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ public ISHR() {
+ super(org.apache.bcel.Constants.ISHR);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitArithmeticInstruction(this);
- v.visitISHR(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitArithmeticInstruction(this);
+ v.visitISHR(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/ISTORE.java b/src/org/apache/bcel/generic/ISTORE.java
index bca07c1..3f80b96 100644
--- a/src/org/apache/bcel/generic/ISTORE.java
+++ b/src/org/apache/bcel/generic/ISTORE.java
@@ -16,42 +16,55 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* ISTORE - Store int from stack into local variable
- * Stack: ..., value -> ...
- *
+ *
+ *
+ * Stack: ..., value -> ...
+ *
+ *
* @version $Id: ISTORE.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class ISTORE extends StoreInstruction {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- ISTORE() {
- super(org.apache.bcel.Constants.ISTORE, org.apache.bcel.Constants.ISTORE_0);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ ISTORE() {
+ super(org.apache.bcel.Constants.ISTORE,
+ org.apache.bcel.Constants.ISTORE_0);
+ }
- /** Store int into local variable
- * @param n index of local variable
- */
- public ISTORE(int n) {
- super(org.apache.bcel.Constants.ISTORE, org.apache.bcel.Constants.ISTORE_0, n);
- }
+ /**
+ * Store int into local variable
+ *
+ * @param n
+ * index of local variable
+ */
+ public ISTORE(int n) {
+ super(org.apache.bcel.Constants.ISTORE,
+ org.apache.bcel.Constants.ISTORE_0, n);
+ }
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- super.accept(v);
- v.visitISTORE(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ super.accept(v);
+ v.visitISTORE(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/ISUB.java b/src/org/apache/bcel/generic/ISUB.java
index 9885687..a303f30 100644
--- a/src/org/apache/bcel/generic/ISUB.java
+++ b/src/org/apache/bcel/generic/ISUB.java
@@ -16,35 +16,45 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* ISUB - Substract ints
- * Stack: ..., value1, value2 -> result
- *
+ *
+ *
+ * Stack: ..., value1, value2 -> result
+ *
+ *
* @version $Id: ISUB.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class ISUB extends ArithmeticInstruction {
- /** Substract ints
- */
- public ISUB() {
- super(org.apache.bcel.Constants.ISUB);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Substract ints
+ */
+ public ISUB() {
+ super(org.apache.bcel.Constants.ISUB);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitArithmeticInstruction(this);
- v.visitISUB(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitArithmeticInstruction(this);
+ v.visitISUB(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IUSHR.java b/src/org/apache/bcel/generic/IUSHR.java
index 6e5cc1c..36bc1ec 100644
--- a/src/org/apache/bcel/generic/IUSHR.java
+++ b/src/org/apache/bcel/generic/IUSHR.java
@@ -16,33 +16,42 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* IUSHR - Logical shift right int
- * Stack: ..., value1, value2 -> ..., result
- *
+ *
+ *
+ * Stack: ..., value1, value2 -> ..., result
+ *
+ *
* @version $Id: IUSHR.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IUSHR extends ArithmeticInstruction {
- public IUSHR() {
- super(org.apache.bcel.Constants.IUSHR);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ public IUSHR() {
+ super(org.apache.bcel.Constants.IUSHR);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitArithmeticInstruction(this);
- v.visitIUSHR(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitArithmeticInstruction(this);
+ v.visitIUSHR(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IXOR.java b/src/org/apache/bcel/generic/IXOR.java
index 0e3472f..9338502 100644
--- a/src/org/apache/bcel/generic/IXOR.java
+++ b/src/org/apache/bcel/generic/IXOR.java
@@ -16,33 +16,42 @@
*/
package org.apache.bcel.generic;
-/**
+/**
* IXOR - Bitwise XOR int
- * Stack: ..., value1, value2 -> ..., result
- *
+ *
+ *
+ * Stack: ..., value1, value2 -> ..., result
+ *
+ *
* @version $Id: IXOR.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public class IXOR extends ArithmeticInstruction {
- public IXOR() {
- super(org.apache.bcel.Constants.IXOR);
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ public IXOR() {
+ super(org.apache.bcel.Constants.IXOR);
+ }
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public void accept( Visitor v ) {
- v.visitTypedInstruction(this);
- v.visitStackProducer(this);
- v.visitStackConsumer(this);
- v.visitArithmeticInstruction(this);
- v.visitIXOR(this);
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ @Override
+ public void accept(Visitor v) {
+ v.visitTypedInstruction(this);
+ v.visitStackProducer(this);
+ v.visitStackConsumer(this);
+ v.visitArithmeticInstruction(this);
+ v.visitIXOR(this);
+ }
}
diff --git a/src/org/apache/bcel/generic/IfInstruction.java b/src/org/apache/bcel/generic/IfInstruction.java
index 33af0c0..c443b9c 100644
--- a/src/org/apache/bcel/generic/IfInstruction.java
+++ b/src/org/apache/bcel/generic/IfInstruction.java
@@ -18,31 +18,37 @@ package org.apache.bcel.generic;
/**
* Super class for the IFxxx family of instructions.
- *
+ *
* @version $Id: IfInstruction.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
-public abstract class IfInstruction extends BranchInstruction implements StackConsumer {
+public abstract class IfInstruction extends BranchInstruction implements
+ StackConsumer {
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- IfInstruction() {
- }
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ IfInstruction() {
+ }
- /**
- * @param opcode opcode of instruction
- * @param target Target instruction to branch to
- */
- protected IfInstruction(short opcode, InstructionHandle target) {
- super(opcode, target);
- }
+ /**
+ * @param opcode
+ * opcode of instruction
+ * @param target
+ * Target instruction to branch to
+ */
+ protected IfInstruction(short opcode, InstructionHandle target) {
+ super(opcode, target);
+ }
-
- /**
- * @return negation of instruction, e.g. IFEQ.negate() == IFNE
- */
- public abstract IfInstruction negate();
+ /**
+ * @return negation of instruction, e.g. IFEQ.negate() == IFNE
+ */
+ public abstract IfInstruction negate();
}
diff --git a/src/org/apache/bcel/generic/IndexedInstruction.java b/src/org/apache/bcel/generic/IndexedInstruction.java
index 3735f2c..25bf990 100644
--- a/src/org/apache/bcel/generic/IndexedInstruction.java
+++ b/src/org/apache/bcel/generic/IndexedInstruction.java
@@ -17,16 +17,15 @@
package org.apache.bcel.generic;
/**
- * Denote entity that refers to an index, e.g. local variable instructions,
- * RET, CPInstruction, etc.
- *
+ * Denote entity that refers to an index, e.g. local variable instructions, RET,
+ * CPInstruction, etc.
+ *
* @version $Id: IndexedInstruction.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public interface IndexedInstruction {
- public int getIndex();
+ public int getIndex();
-
- public void setIndex( int index );
+ public void setIndex(int index);
}
diff --git a/src/org/apache/bcel/generic/Instruction.java b/src/org/apache/bcel/generic/Instruction.java
index 4de3c5c..0704729 100644
--- a/src/org/apache/bcel/generic/Instruction.java
+++ b/src/org/apache/bcel/generic/Instruction.java
@@ -24,269 +24,278 @@ import org.apache.bcel.Constants;
import org.apache.bcel.classfile.ConstantPool;
import org.apache.bcel.util.ByteSequence;
-/**
+/**
* Abstract super class for all Java byte codes.
- *
+ *
* @version $Id: Instruction.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public abstract class Instruction implements Cloneable, Serializable {
- protected short length = 1; // Length of instruction in bytes
- protected short opcode = -1; // Opcode number
- private static InstructionComparator cmp = InstructionComparator.DEFAULT;
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ protected short length = 1; // Length of instruction in bytes
+ protected short opcode = -1; // Opcode number
+ private static InstructionComparator cmp = InstructionComparator.DEFAULT;
+ /**
+ * Empty constructor needed for the Class.newInstance() statement in
+ * Instruction.readInstruction(). Not to be used otherwise.
+ */
+ Instruction() {
+ }
- /**
- * Empty constructor needed for the Class.newInstance() statement in
- * Instruction.readInstruction(). Not to be used otherwise.
- */
- Instruction() {
- }
+ public Instruction(short opcode, short length) {
+ this.length = length;
+ this.opcode = opcode;
+ }
+ /**
+ * Dump instruction as byte code to stream out.
+ *
+ * @param out
+ * Output stream
+ */
+ public void dump(DataOutputStream out) throws IOException {
+ out.writeByte(opcode); // Common for all instructions
+ }
- public Instruction(short opcode, short length) {
- this.length = length;
- this.opcode = opcode;
- }
+ /**
+ * @return name of instruction, i.e., opcode name
+ */
+ public String getName() {
+ return Constants.OPCODE_NAMES[opcode];
+ }
+ /**
+ * Long output format:
+ *
+ * <name of opcode> "["<opcode number>"]" "("<length of
+ * instruction>")"
+ *
+ * @param verbose
+ * long/short format switch
+ * @return mnemonic for instruction
+ */
+ public String toString(boolean verbose) {
+ if (verbose) {
+ return getName() + "[" + opcode + "](" + length + ")";
+ } else {
+ return getName();
+ }
+ }
- /**
- * Dump instruction as byte code to stream out.
- * @param out Output stream
- */
- public void dump( DataOutputStream out ) throws IOException {
- out.writeByte(opcode); // Common for all instructions
- }
+ /**
+ * @return mnemonic for instruction in verbose format
+ */
+ @Override
+ public String toString() {
+ return toString(true);
+ }
+ /**
+ * @return mnemonic for instruction with sumbolic references resolved
+ */
+ public String toString(ConstantPool cp) {
+ return toString(false);
+ }
- /** @return name of instruction, i.e., opcode name
- */
- public String getName() {
- return Constants.OPCODE_NAMES[opcode];
- }
+ /**
+ * Use with caution, since `BranchInstruction's have a `target' reference
+ * which is not copied correctly (only basic types are). This also applies
+ * for `Select' instructions with their multiple branch targets.
+ *
+ * @see BranchInstruction
+ * @return (shallow) copy of an instruction
+ */
+ public Instruction copy() {
+ Instruction i = null;
+ // "Constant" instruction, no need to duplicate
+ if (InstructionConstants.INSTRUCTIONS[this.getOpcode()] != null) {
+ i = this;
+ } else {
+ try {
+ i = (Instruction) clone();
+ } catch (CloneNotSupportedException e) {
+ System.err.println(e);
+ }
+ }
+ return i;
+ }
+ /**
+ * Read needed data (e.g. index) from file.
+ *
+ * @param bytes
+ * byte sequence to read from
+ * @param wide
+ * "wide" instruction flag
+ */
+ protected void initFromFile(ByteSequence bytes, boolean wide)
+ throws IOException {
+ }
- /**
- * Long output format:
- *
- * <name of opcode> "["<opcode number>"]"
- * "("<length of instruction>")"
- *
- * @param verbose long/short format switch
- * @return mnemonic for instruction
- */
- public String toString( boolean verbose ) {
- if (verbose) {
- return getName() + "[" + opcode + "](" + length + ")";
- } else {
- return getName();
- }
- }
+ /**
+ * Read an instruction from (byte code) input stream and return the
+ * appropiate object.
+ *
+ * @param bytes
+ * input stream bytes
+ * @return instruction object being read
+ */
+ public static final Instruction readInstruction(ByteSequence bytes)
+ throws IOException {
+ boolean wide = false;
+ short opcode = (short) bytes.readUnsignedByte();
+ Instruction obj = null;
+ if (opcode == Constants.WIDE) { // Read next opcode after wide byte
+ wide = true;
+ opcode = (short) bytes.readUnsignedByte();
+ }
+ if (InstructionConstants.INSTRUCTIONS[opcode] != null) {
+ return InstructionConstants.INSTRUCTIONS[opcode]; // Used predefined
+ // immutable
+ // object, if
+ // available
+ }
+ /*
+ * Find appropiate class, instantiate an (empty) instruction object and
+ * initialize it by hand.
+ */
+ Class clazz;
+ try {
+ clazz = Class.forName(className(opcode));
+ } catch (ClassNotFoundException cnfe) {
+ // If a class by that name does not exist, the opcode is illegal.
+ // Note that IMPDEP1, IMPDEP2, BREAKPOINT are also illegal in a
+ // sense.
+ throw new ClassGenException("Illegal opcode detected.");
+ }
+ try {
+ obj = (Instruction) clazz.newInstance();
+ if (wide
+ && !((obj instanceof LocalVariableInstruction)
+ || (obj instanceof IINC) || (obj instanceof RET))) {
+ throw new Exception("Illegal opcode after wide: " + opcode);
+ }
+ obj.setOpcode(opcode);
+ obj.initFromFile(bytes, wide); // Do further initializations, if any
+ // Byte code offset set in InstructionList
+ } catch (Exception e) {
+ throw new ClassGenException(e.toString());
+ }
+ return obj;
+ }
+ private static final String className(short opcode) {
+ String name = Constants.OPCODE_NAMES[opcode]
+ .toUpperCase(Locale.ENGLISH);
+ /*
+ * ICONST_0, etc. will be shortened to ICONST, etc., since ICONST_0 and
+ * the like are not implemented (directly).
+ */
+ try {
+ int len = name.length();
+ char ch1 = name.charAt(len - 2), ch2 = name.charAt(len - 1);
+ if ((ch1 == '_') && (ch2 >= '0') && (ch2 <= '5')) {
+ name = name.substring(0, len - 2);
+ }
+ if (name.equals("ICONST_M1")) {
+ name = "ICONST";
+ }
+ } catch (StringIndexOutOfBoundsException e) {
+ System.err.println(e);
+ }
+ return "org.apache.bcel.generic." + name;
+ }
- /**
- * @return mnemonic for instruction in verbose format
- */
- public String toString() {
- return toString(true);
- }
+ /**
+ * This method also gives right results for instructions whose effect on the
+ * stack depends on the constant pool entry they reference.
+ *
+ * @return Number of words consumed from stack by this instruction, or
+ * Constants.UNPREDICTABLE, if this can not be computed statically
+ */
+ public int consumeStack(ConstantPoolGen cpg) {
+ return Constants.CONSUME_STACK[opcode];
+ }
+ /**
+ * This method also gives right results for instructions whose effect on the
+ * stack depends on the constant pool entry they reference.
+ *
+ * @return Number of words produced onto stack by this instruction, or
+ * Constants.UNPREDICTABLE, if this can not be computed statically
+ */
+ public int produceStack(ConstantPoolGen cpg) {
+ return Constants.PRODUCE_STACK[opcode];
+ }
- /**
- * @return mnemonic for instruction with sumbolic references resolved
- */
- public String toString( ConstantPool cp ) {
- return toString(false);
- }
+ /**
+ * @return this instructions opcode
+ */
+ public short getOpcode() {
+ return opcode;
+ }
+ /**
+ * @return length (in bytes) of instruction
+ */
+ public int getLength() {
+ return length;
+ }
- /**
- * Use with caution, since `BranchInstruction's have a `target' reference which
- * is not copied correctly (only basic types are). This also applies for
- * `Select' instructions with their multiple branch targets.
- *
- * @see BranchInstruction
- * @return (shallow) copy of an instruction
- */
- public Instruction copy() {
- Instruction i = null;
- // "Constant" instruction, no need to duplicate
- if (InstructionConstants.INSTRUCTIONS[this.getOpcode()] != null) {
- i = this;
- } else {
- try {
- i = (Instruction) clone();
- } catch (CloneNotSupportedException e) {
- System.err.println(e);
- }
- }
- return i;
- }
+ /**
+ * Needed in readInstruction.
+ */
+ private void setOpcode(short opcode) {
+ this.opcode = opcode;
+ }
+ /**
+ * Some instructions may be reused, so don't do anything by default.
+ */
+ void dispose() {
+ }
- /**
- * Read needed data (e.g. index) from file.
- *
- * @param bytes byte sequence to read from
- * @param wide "wide" instruction flag
- */
- protected void initFromFile( ByteSequence bytes, boolean wide ) throws IOException {
- }
+ /**
+ * Call corresponding visitor method(s). The order is: Call visitor methods
+ * of implemented interfaces first, then call methods according to the class
+ * hierarchy in descending order, i.e., the most specific visitXXX() call
+ * comes last.
+ *
+ * @param v
+ * Visitor object
+ */
+ public abstract void accept(Visitor v);
+ /**
+ * Get Comparator object used in the equals() method to determine equality
+ * of instructions.
+ *
+ * @return currently used comparator for equals()
+ */
+ public static InstructionComparator getComparator() {
+ return cmp;
+ }
- /**
- * Read an instruction from (byte code) input stream and return the
- * appropiate object.
- *
- * @param bytes input stream bytes
- * @return instruction object being read
- */
- public static final Instruction readInstruction( ByteSequence bytes ) throws IOException {
- boolean wide = false;
- short opcode = (short) bytes.readUnsignedByte();
- Instruction obj = null;
- if (opcode == Constants.WIDE) { // Read next opcode after wide byte
- wide = true;
- opcode = (short) bytes.readUnsignedByte();
- }
- if (InstructionConstants.INSTRUCTIONS[opcode] != null) {
- return InstructionConstants.INSTRUCTIONS[opcode]; // Used predefined immutable object, if available
- }
- /* Find appropiate class, instantiate an (empty) instruction object
- * and initialize it by hand.
- */
- Class clazz;
- try {
- clazz = Class.forName(className(opcode));
- } catch (ClassNotFoundException cnfe) {
- // If a class by that name does not exist, the opcode is illegal.
- // Note that IMPDEP1, IMPDEP2, BREAKPOINT are also illegal in a sense.
- throw new ClassGenException("Illegal opcode detected.");
- }
- try {
- obj = (Instruction) clazz.newInstance();
- if (wide
- && !((obj instanceof LocalVariableInstruction) || (obj instanceof IINC) || (obj instanceof RET))) {
- throw new Exception("Illegal opcode after wide: " + opcode);
- }
- obj.setOpcode(opcode);
- obj.initFromFile(bytes, wide); // Do further initializations, if any
- // Byte code offset set in InstructionList
- } catch (Exception e) {
- throw new ClassGenException(e.toString());
- }
- return obj;
- }
+ /**
+ * Set comparator to be used for equals().
+ */
+ public static void setComparator(InstructionComparator c) {
+ cmp = c;
+ }
-
- private static final String className( short opcode ) {
- String name = Constants.OPCODE_NAMES[opcode].toUpperCase(Locale.ENGLISH);
- /* ICONST_0, etc. will be shortened to ICONST, etc., since ICONST_0 and the like
- * are not implemented (directly).
- */
- try {
- int len = name.length();
- char ch1 = name.charAt(len - 2), ch2 = name.charAt(len - 1);
- if ((ch1 == '_') && (ch2 >= '0') && (ch2 <= '5')) {
- name = name.substring(0, len - 2);
- }
- if (name.equals("ICONST_M1")) {
- name = "ICONST";
- }
- } catch (StringIndexOutOfBoundsException e) {
- System.err.println(e);
- }
- return "org.apache.bcel.generic." + name;
- }
-
-
- /**
- * This method also gives right results for instructions whose
- * effect on the stack depends on the constant pool entry they
- * reference.
- * @return Number of words consumed from stack by this instruction,
- * or Constants.UNPREDICTABLE, if this can not be computed statically
- */
- public int consumeStack( ConstantPoolGen cpg ) {
- return Constants.CONSUME_STACK[opcode];
- }
-
-
- /**
- * This method also gives right results for instructions whose
- * effect on the stack depends on the constant pool entry they
- * reference.
- * @return Number of words produced onto stack by this instruction,
- * or Constants.UNPREDICTABLE, if this can not be computed statically
- */
- public int produceStack( ConstantPoolGen cpg ) {
- return Constants.PRODUCE_STACK[opcode];
- }
-
-
- /**
- * @return this instructions opcode
- */
- public short getOpcode() {
- return opcode;
- }
-
-
- /**
- * @return length (in bytes) of instruction
- */
- public int getLength() {
- return length;
- }
-
-
- /**
- * Needed in readInstruction.
- */
- private void setOpcode( short opcode ) {
- this.opcode = opcode;
- }
-
-
- /** Some instructions may be reused, so don't do anything by default.
- */
- void dispose() {
- }
-
-
- /**
- * Call corresponding visitor method(s). The order is:
- * Call visitor methods of implemented interfaces first, then
- * call methods according to the class hierarchy in descending order,
- * i.e., the most specific visitXXX() call comes last.
- *
- * @param v Visitor object
- */
- public abstract void accept( Visitor v );
-
-
- /** Get Comparator object used in the equals() method to determine
- * equality of instructions.
- *
- * @return currently used comparator for equals()
- */
- public static InstructionComparator getComparator() {
- return cmp;
- }
-
-
- /** Set comparator to be used for equals().
- */
- public static void setComparator( InstructionComparator c ) {
- cmp = c;
- }
-
-
- /** Check for equality, delegated to comparator
- * @return true if that is an Instruction and has the same opcode
- */
- public boolean equals( Object that ) {
- return (that instanceof Instruction) ? cmp.equals(this, (Instruction) that) : false;
- }
+ /**
+ * Check for equality, delegated to comparator
+ *
+ * @return true if that is an Instruction and has the same opcode
+ */
+ @Override
+ public boolean equals(Object that) {
+ return (that instanceof Instruction) ? cmp.equals(this,
+ (Instruction) that) : false;
+ }
}
diff --git a/src/org/apache/bcel/generic/InstructionComparator.java b/src/org/apache/bcel/generic/InstructionComparator.java
index 0813011..7717631 100644
--- a/src/org/apache/bcel/generic/InstructionComparator.java
+++ b/src/org/apache/bcel/generic/InstructionComparator.java
@@ -17,53 +17,54 @@
package org.apache.bcel.generic;
/**
- * Equality of instructions isn't clearly to be defined. You might
- * wish, for example, to compare whether instructions have the same
- * meaning. E.g., whether two INVOKEVIRTUALs describe the same
- * call.
The DEFAULT comparator however, considers two instructions
- * to be equal if they have same opcode and point to the same indexes
- * (if any) in the constant pool or the same local variable index. Branch
- * instructions must have the same target.
- *
+ * Equality of instructions isn't clearly to be defined. You might wish, for
+ * example, to compare whether instructions have the same meaning. E.g., whether
+ * two INVOKEVIRTUALs describe the same call.
+ * The DEFAULT comparator however, considers two instructions to be equal if
+ * they have same opcode and point to the same indexes (if any) in the constant
+ * pool or the same local variable index. Branch instructions must have the same
+ * target.
+ *
* @see Instruction
* @version $Id: InstructionComparator.java 386056 2006-03-15 11:31:56Z tcurdt $
* @author M. Dahm
*/
public interface InstructionComparator {
- public static final InstructionComparator DEFAULT = new InstructionComparator() {
+ public static final InstructionComparator DEFAULT = new InstructionComparator() {
- public boolean equals( Instruction i1, Instruction i2 ) {
- if (i1.opcode == i2.opcode) {
- if (i1 instanceof Select) {
- InstructionHandle[] t1 = ((Select) i1).getTargets();
- InstructionHandle[] t2 = ((Select) i2).getTargets();
- if (t1.length == t2.length) {
- for (int i = 0; i < t1.length; i++) {
- if (t1[i] != t2[i]) {
- return false;
- }
- }
- return true;
- }
- } else if (i1 instanceof BranchInstruction) {
- return ((BranchInstruction) i1).target == ((BranchInstruction) i2).target;
- } else if (i1 instanceof ConstantPushInstruction) {
- return ((ConstantPushInstruction) i1).getValue().equals(
- ((ConstantPushInstruction) i2).getValue());
- } else if (i1 instanceof IndexedInstruction) {
- return ((IndexedInstruction) i1).getIndex() == ((IndexedInstruction) i2)
- .getIndex();
- } else if (i1 instanceof NEWARRAY) {
- return ((NEWARRAY) i1).getTypecode() == ((NEWARRAY) i2).getTypecode();
- } else {
- return true;
- }
- }
- return false;
- }
- };
+ @Override
+ public boolean equals(Instruction i1, Instruction i2) {
+ if (i1.opcode == i2.opcode) {
+ if (i1 instanceof Select) {
+ InstructionHandle[] t1 = ((Select) i1).getTargets();
+ InstructionHandle[] t2 = ((Select) i2).getTargets();
+ if (t1.length == t2.length) {
+ for (int i = 0; i < t1.length; i++) {
+ if (t1[i] != t2[i]) {
+ return false;
+ }
+ }
+ return true;
+ }
+ } else if (i1 instanceof BranchInstruction) {
+ return ((BranchInstruction) i1).target == ((BranchInstruction) i2).target;
+ } else if (i1 instanceof ConstantPushInstruction) {
+ return ((ConstantPushInstruction) i1).getValue().equals(
+ ((ConstantPushInstruction) i2).getValue());
+ } else if (i1 instanceof IndexedInstruction) {
+ return ((IndexedInstruction) i1).getIndex() == ((IndexedInstruction) i2)
+ .getIndex();
+ } else if (i1 instanceof NEWARRAY) {
+ return ((NEWARRAY) i1).getTypecode() == ((NEWARRAY) i2)
+ .getTypecode();
+ } else {
+ return true;
+ }
+ }
+ return false;
+ }
+ };
-
- public boolean equals( Instruction i1, Instruction i2 );
+ public boolean equals(Instruction i1, Instruction i2);
}
diff --git a/src/org/apache/bcel/generic/InstructionConstants.java b/src/org/apache/bcel/generic/InstructionConstants.java
index 38846bf..4d78841 100644
--- a/src/org/apache/bcel/generic/InstructionConstants.java
+++ b/src/org/apache/bcel/generic/InstructionConstants.java
@@ -18,269 +18,273 @@ package org.apache.bcel.generic;
import org.apache.bcel.Constants;
-/**
+/**
* This interface contains shareable instruction objects.
- *
- * In order to save memory you can use some instructions multiply,
- * since they have an immutable state and are directly derived from
- * Instruction. I.e. they have no instance fields that could be
- * changed. Since some of these instructions like ICONST_0 occur
- * very frequently this can save a lot of time and space. This
- * feature is an adaptation of the FlyWeight design pattern, we
+ *
+ * In order to save memory you can use some instructions multiply, since they
+ * have an immutable state and are directly derived from Instruction. I.e. they
+ * have no instance fields that could be changed. Since some of these
+ * instructions like ICONST_0 occur very frequently this can save a lot of time
+ * and space. This feature is an adaptation of the FlyWeight design pattern, we
* just use an array instead of a factory.
- *
- * The Instructions can also accessed directly under their names, so
- * it's possible to write il.append(Instruction.ICONST_0);
- *
+ *
+ * The Instructions can also accessed directly under their names, so it's
+ * possible to write il.append(Instruction.ICONST_0);
+ *
* @version $Id: InstructionConstants.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
*/
public interface InstructionConstants {
- /** Predefined instruction objects
- */
- public static final Instruction NOP = new NOP();
- public static final Instruction ACONST_NULL = new ACONST_NULL();
- public static final Instruction ICONST_M1 = new ICONST(-1);
- public static final Instruction ICONST_0 = new ICONST(0);
- public static final Instruction ICONST_1 = new ICONST(1);
- public static final Instruction ICONST_2 = new ICONST(2);
- public static final Instruction ICONST_3 = new ICONST(3);
- public static final Instruction ICONST_4 = new ICONST(4);
- public static final Instruction ICONST_5 = new ICONST(5);
- public static final Instruction LCONST_0 = new LCONST(0);
- public static final Instruction LCONST_1 = new LCONST(1);
- public static final Instruction FCONST_0 = new FCONST(0);
- public static final Instruction FCONST_1 = new FCONST(1);
- public static final Instruction FCONST_2 = new FCONST(2);
- public static final Instruction DCONST_0 = new DCONST(0);
- public static final Instruction DCONST_1 = new DCONST(1);
- public static final ArrayInstruction IALOAD = new IALOAD();
- public static final ArrayInstruction LALOAD = new LALOAD();
- public static final ArrayInstruction FALOAD = new FALOAD();
- public static final ArrayInstruction DALOAD = new DALOAD();
- public static final ArrayInstruction AALOAD = new AALOAD();
- public static final ArrayInstruction BALOAD = new BALOAD();
- public static final ArrayInstruction CALOAD = new CALOAD();
- public static final ArrayInstruction SALOAD = new SALOAD();
- public static final ArrayInstruction IASTORE = new IASTORE();
- public static final ArrayInstruction LASTORE = new LASTORE();
- public static final ArrayInstruction FASTORE = new FASTORE();
- public static final ArrayInstruction DASTORE = new DASTORE();
- public static final ArrayInstruction AASTORE = new AASTORE();
- public static final ArrayInstruction BASTORE = new BASTORE();
- public static final ArrayInstruction CASTORE = new CASTORE();
- public static final ArrayInstruction SASTORE = new SASTORE();
- public static final StackInstruction POP = new POP();
- public static final StackInstruction POP2 = new POP2();
- public static final StackInstruction DUP = new DUP();
- public static final StackInstruction DUP_X1 = new DUP_X1();
- public static final StackInstruction DUP_X2 = new DUP_X2();
- public static final StackInstruction DUP2 = new DUP2();
- public static final StackInstruction DUP2_X1 = new DUP2_X1();
- public static final StackInstruction DUP2_X2 = new DUP2_X2();
- public static final StackInstruction SWAP = new SWAP();
- public static final ArithmeticInstruction IADD = new IADD();
- public static final ArithmeticInstruction LADD = new LADD();
- public static final ArithmeticInstruction FADD = new FADD();
- public static final ArithmeticInstruction DADD = new DADD();
- public static final ArithmeticInstruction ISUB = new ISUB();
- public static final ArithmeticInstruction LSUB = new LSUB();
- public static final ArithmeticInstruction FSUB = new FSUB();
- public static final ArithmeticInstruction DSUB = new DSUB();
- public static final ArithmeticInstruction IMUL = new IMUL();
- public static final ArithmeticInstruction LMUL = new LMUL();
- public static final ArithmeticInstruction FMUL = new FMUL();
- public static final ArithmeticInstruction DMUL = new DMUL();
- public static final ArithmeticInstruction IDIV = new IDIV();
- public static final ArithmeticInstruction LDIV = new LDIV();
- public static final ArithmeticInstruction FDIV = new FDIV();
- public static final ArithmeticInstruction DDIV = new DDIV();
- public static final ArithmeticInstruction IREM = new IREM();
- public static final ArithmeticInstruction LREM = new LREM();
- public static final ArithmeticInstruction FREM = new FREM();
- public static final ArithmeticInstruction DREM = new DREM();
- public static final ArithmeticInstruction INEG = new INEG();
- public static final ArithmeticInstruction LNEG = new LNEG();
- public static final ArithmeticInstruction FNEG = new FNEG();
- public static final ArithmeticInstruction DNEG = new DNEG();
- public static final ArithmeticInstruction ISHL = new ISHL();
- public static final ArithmeticInstruction LSHL = new LSHL();
- public static final ArithmeticInstruction ISHR = new ISHR();
- public static final ArithmeticInstruction LSHR = new LSHR();
- public static final ArithmeticInstruction IUSHR = new IUSHR();
- public static final ArithmeticInstruction LUSHR = new LUSHR();
- public static final ArithmeticInstruction IAND = new IAND();
- public static final ArithmeticInstruction LAND = new LAND();
- public static final ArithmeticInstruction IOR = new IOR();
- public static final ArithmeticInstruction LOR = new LOR();
- public static final ArithmeticInstruction IXOR = new IXOR();
- public static final ArithmeticInstruction LXOR = new LXOR();
- public static final ConversionInstruction I2L = new I2L();
- public static final ConversionInstruction I2F = new I2F();
- public static final ConversionInstruction I2D = new I2D();
- public static final ConversionInstruction L2I = new L2I();
- public static final ConversionInstruction L2F = new L2F();
- public static final ConversionInstruction L2D = new L2D();
- public static final ConversionInstruction F2I = new F2I();
- public static final ConversionInstruction F2L = new F2L();
- public static final ConversionInstruction F2D = new F2D();
- public static final ConversionInstruction D2I = new D2I();
- public static final ConversionInstruction D2L = new D2L();
- public static final ConversionInstruction D2F = new D2F();
- public static final ConversionInstruction I2B = new I2B();
- public static final ConversionInstruction I2C = new I2C();
- public static final ConversionInstruction I2S = new I2S();
- public static final Instruction LCMP = new LCMP();
- public static final Instruction FCMPL = new FCMPL();
- public static final Instruction FCMPG = new FCMPG();
- public static final Instruction DCMPL = new DCMPL();
- public static final Instruction DCMPG = new DCMPG();
- public static final ReturnInstruction IRETURN = new IRETURN();
- public static final ReturnInstruction LRETURN = new LRETURN();
- public static final ReturnInstruction FRETURN = new FRETURN();
- public static final ReturnInstruction DRETURN = new DRETURN();
- public static final ReturnInstruction ARETURN = new ARETURN();
- public static final ReturnInstruction RETURN = new RETURN();
- public static final Instruction ARRAYLENGTH = new ARRAYLENGTH();
- public static final Instruction ATHROW = new ATHROW();
- public static final Instruction MONITORENTER = new MONITORENTER();
- public static final Instruction MONITOREXIT = new MONITOREXIT();
- /** You can use these constants in multiple places safely, if you can guarantee
- * that you will never alter their internal values, e.g. call setIndex().
- */
- public static final LocalVariableInstruction THIS = new ALOAD(0);
- public static final LocalVariableInstruction ALOAD_0 = THIS;
- public static final LocalVariableInstruction ALOAD_1 = new ALOAD(1);
- public static final LocalVariableInstruction ALOAD_2 = new ALOAD(2);
- public static final LocalVariableInstruction ILOAD_0 = new ILOAD(0);
- public static final LocalVariableInstruction ILOAD_1 = new ILOAD(1);
- public static final LocalVariableInstruction ILOAD_2 = new ILOAD(2);
- public static final LocalVariableInstruction ASTORE_0 = new ASTORE(0);
- public static final LocalVariableInstruction ASTORE_1 = new ASTORE(1);
- public static final LocalVariableInstruction ASTORE_2 = new ASTORE(2);
- public static final LocalVariableInstruction ISTORE_0 = new ISTORE(0);
- public static final LocalVariableInstruction ISTORE_1 = new ISTORE(1);
- public static final LocalVariableInstruction ISTORE_2 = new ISTORE(2);
- /** Get object via its opcode, for immutable instructions like
- * branch instructions entries are set to null.
- */
- public static final Instruction[] INSTRUCTIONS = new Instruction[256];
- /** Interfaces may have no static initializers, so we simulate this
- * with an inner class.
- */
- static final Clinit bla = new Clinit();
+ /**
+ * Predefined instruction objects
+ */
+ public static final Instruction NOP = new NOP();
+ public static final Instruction ACONST_NULL = new ACONST_NULL();
+ public static final Instruction ICONST_M1 = new ICONST(-1);
+ public static final Instruction ICONST_0 = new ICONST(0);
+ public static final Instruction ICONST_1 = new ICONST(1);
+ public static final Instruction ICONST_2 = new ICONST(2);
+ public static final Instruction ICONST_3 = new ICONST(3);
+ public static final Instruction ICONST_4 = new ICONST(4);
+ public static final Instruction ICONST_5 = new ICONST(5);
+ public static final Instruction LCONST_0 = new LCONST(0);
+ public static final Instruction LCONST_1 = new LCONST(1);
+ public static final Instruction FCONST_0 = new FCONST(0);
+ public static final Instruction FCONST_1 = new FCONST(1);
+ public static final Instruction FCONST_2 = new FCONST(2);
+ public static final Instruction DCONST_0 = new DCONST(0);
+ public static final Instruction DCONST_1 = new DCONST(1);
+ public static final ArrayInstruction IALOAD = new IALOAD();
+ public static final ArrayInstruction LALOAD = new LALOAD();
+ public static final ArrayInstruction FALOAD = new FALOAD();
+ public static final ArrayInstruction DALOAD = new DALOAD();
+ public static final ArrayInstruction AALOAD = new AALOAD();
+ public static final ArrayInstruction BALOAD = new BALOAD();
+ public static final ArrayInstruction CALOAD = new CALOAD();
+ public static final ArrayInstruction SALOAD = new SALOAD();
+ public static final ArrayInstruction IASTORE = new IASTORE();
+ public static final ArrayInstruction LASTORE = new LASTORE();
+ public static final ArrayInstruction FASTORE = new FASTORE();
+ public static final ArrayInstruction DASTORE = new DASTORE();
+ public static final ArrayInstruction AASTORE = new AASTORE();
+ public static final ArrayInstruction BASTORE = new BASTORE();
+ public static final ArrayInstruction CASTORE = new CASTORE();
+ public static final ArrayInstruction SASTORE = new SASTORE();
+ public static final StackInstruction POP = new POP();
+ public static final StackInstruction POP2 = new POP2();
+ public static final StackInstruction DUP = new DUP();
+ public static final StackInstruction DUP_X1 = new DUP_X1();
+ public static final StackInstruction DUP_X2 = new DUP_X2();
+ public static final StackInstruction DUP2 = new DUP2();
+ public static final StackInstruction DUP2_X1 = new DUP2_X1();
+ public static final StackInstruction DUP2_X2 = new DUP2_X2();
+ public static final StackInstruction SWAP = new SWAP();
+ public static final ArithmeticInstruction IADD = new IADD();
+ public static final ArithmeticInstruction LADD = new LADD();
+ public static final ArithmeticInstruction FADD = new FADD();
+ public static final ArithmeticInstruction DADD = new DADD();
+ public static final ArithmeticInstruction ISUB = new ISUB();
+ public static final ArithmeticInstruction LSUB = new LSUB();
+ public static final ArithmeticInstruction FSUB = new FSUB();
+ public static final ArithmeticInstruction DSUB = new DSUB();
+ public static final ArithmeticInstruction IMUL = new IMUL();
+ public static final ArithmeticInstruction LMUL = new LMUL();
+ public static final ArithmeticInstruction FMUL = new FMUL();
+ public static final ArithmeticInstruction DMUL = new DMUL();
+ public static final ArithmeticInstruction IDIV = new IDIV();
+ public static final ArithmeticInstruction LDIV = new LDIV();
+ public static final ArithmeticInstruction FDIV = new FDIV();
+ public static final ArithmeticInstruction DDIV = new DDIV();
+ public static final ArithmeticInstruction IREM = new IREM();
+ public static final ArithmeticInstruction LREM = new LREM();
+ public static final ArithmeticInstruction FREM = new FREM();
+ public static final ArithmeticInstruction DREM = new DREM();
+ public static final ArithmeticInstruction INEG = new INEG();
+ public static final ArithmeticInstruction LNEG = new LNEG();
+ public static final ArithmeticInstruction FNEG = new FNEG();
+ public static final ArithmeticInstruction DNEG = new DNEG();
+ public static final ArithmeticInstruction ISHL = new ISHL();
+ public static final ArithmeticInstruction LSHL = new LSHL();
+ public static final ArithmeticInstruction ISHR = new ISHR();
+ public static final ArithmeticInstruction LSHR = new LSHR();
+ public static final ArithmeticInstruction IUSHR = new IUSHR();
+ public static final ArithmeticInstruction LUSHR = new LUSHR();
+ public static final ArithmeticInstruction IAND = new IAND();
+ public static final ArithmeticInstruction LAND = new LAND();
+ public static final ArithmeticInstruction IOR = new IOR();
+ public static final ArithmeticInstruction LOR = new LOR();
+ public static final ArithmeticInstruction IXOR = new IXOR();
+ public static final ArithmeticInstruction LXOR = new LXOR();
+ public static final ConversionInstruction I2L = new I2L();
+ public static final ConversionInstruction I2F = new I2F();
+ public static final ConversionInstruction I2D = new I2D();
+ public static final ConversionInstruction L2I = new L2I();
+ public static final ConversionInstruction L2F = new L2F();
+ public static final ConversionInstruction L2D = new L2D();
+ public static final ConversionInstruction F2I = new F2I();
+ public static final ConversionInstruction F2L = new F2L();
+ public static final ConversionInstruction F2D = new F2D();
+ public static final ConversionInstruction D2I = new D2I();
+ public static final ConversionInstruction D2L = new D2L();
+ public static final ConversionInstruction D2F = new D2F();
+ public static final ConversionInstruction I2B = new I2B();
+ public static final ConversionInstruction I2C = new I2C();
+ public static final ConversionInstruction I2S = new I2S();
+ public static final Instruction LCMP = new LCMP();
+ public static final Instruction FCMPL = new FCMPL();
+ public static final Instruction FCMPG = new FCMPG();
+ public static final Instruction DCMPL = new DCMPL();
+ public static final Instruction DCMPG = new DCMPG();
+ public static final ReturnInstruction IRETURN = new IRETURN();
+ public static final ReturnInstruction LRETURN = new LRETURN();
+ public static final ReturnInstruction FRETURN = new FRETURN();
+ public static final ReturnInstruction DRETURN = new DRETURN();
+ public static final ReturnInstruction ARETURN = new ARETURN();
+ public static final ReturnInstruction RETURN = new RETURN();
+ public static final Instruction ARRAYLENGTH = new ARRAYLENGTH();
+ public static final Instruction ATHROW = new ATHROW();
+ public static final Instruction MONITORENTER = new MONITORENTER();
+ public static final Instruction MONITOREXIT = new MONITOREXIT();
+ /**
+ * You can use these constants in multiple places safely, if you can
+ * guarantee that you will never alter their internal values, e.g. call
+ * setIndex().
+ */
+ public static final LocalVariableInstruction THIS = new ALOAD(0);
+ public static final LocalVariableInstruction ALOAD_0 = THIS;
+ public static final LocalVariableInstruction ALOAD_1 = new ALOAD(1);
+ public static final LocalVariableInstruction ALOAD_2 = new ALOAD(2);
+ public static final LocalVariableInstruction ILOAD_0 = new ILOAD(0);
+ public static final LocalVariableInstruction ILOAD_1 = new ILOAD(1);
+ public static final LocalVariableInstruction ILOAD_2 = new ILOAD(2);
+ public static final LocalVariableInstruction ASTORE_0 = new ASTORE(0);
+ public static final LocalVariableInstruction ASTORE_1 = new ASTORE(1);
+ public static final LocalVariableInstruction ASTORE_2 = new ASTORE(2);
+ public static final LocalVariableInstruction ISTORE_0 = new ISTORE(0);
+ public static final LocalVariableInstruction ISTORE_1 = new ISTORE(1);
+ public static final LocalVariableInstruction ISTORE_2 = new ISTORE(2);
+ /**
+ * Get object via its opcode, for immutable instructions like branch
+ * instructions entries are set to null.
+ */
+ public static final Instruction[] INSTRUCTIONS = new Instruction[256];
+ /**
+ * Interfaces may have no static initializers, so we simulate this with an
+ * inner class.
+ */
+ static final Clinit bla = new Clinit();
- static class Clinit {
+ static class Clinit {
- Clinit() {
- INSTRUCTIONS[Constants.NOP] = NOP;
- INSTRUCTIONS[Constants.ACONST_NULL] = ACONST_NULL;
- INSTRUCTIONS[Constants.ICONST_M1] = ICONST_M1;
- INSTRUCTIONS[Constants.ICONST_0] = ICONST_0;
- INSTRUCTIONS[Constants.ICONST_1] = ICONST_1;
- INSTRUCTIONS[Constants.ICONST_2] = ICONST_2;
- INSTRUCTIONS[Constants.ICONST_3] = ICONST_3;
- INSTRUCTIONS[Constants.ICONST_4] = ICONST_4;
- INSTRUCTIONS[Constants.ICONST_5] = ICONST_5;
- INSTRUCTIONS[Constants.LCONST_0] = LCONST_0;
- INSTRUCTIONS[Constants.LCONST_1] = LCONST_1;
- INSTRUCTIONS[Constants.FCONST_0] = FCONST_0;
- INSTRUCTIONS[Constants.FCONST_1] = FCONST_1;
- INSTRUCTIONS[Constants.FCONST_2] = FCONST_2;
- INSTRUCTIONS[Constants.DCONST_0] = DCONST_0;
- INSTRUCTIONS[Constants.DCONST_1] = DCONST_1;
- INSTRUCTIONS[Constants.IALOAD] = IALOAD;
- INSTRUCTIONS[Constants.LALOAD] = LALOAD;
- INSTRUCTIONS[Constants.FALOAD] = FALOAD;
- INSTRUCTIONS[Constants.DALOAD] = DALOAD;
- INSTRUCTIONS[Constants.AALOAD] = AALOAD;
- INSTRUCTIONS[Constants.BALOAD] = BALOAD;
- INSTRUCTIONS[Constants.CALOAD] = CALOAD;
- INSTRUCTIONS[Constants.SALOAD] = SALOAD;
- INSTRUCTIONS[Constants.IASTORE] = IASTORE;
- INSTRUCTIONS[Constants.LASTORE] = LASTORE;
- INSTRUCTIONS[Constants.FASTORE] = FASTORE;
- INSTRUCTIONS[Constants.DASTORE] = DASTORE;
- INSTRUCTIONS[Constants.AASTORE] = AASTORE;
- INSTRUCTIONS[Constants.BASTORE] = BASTORE;
- INSTRUCTIONS[Constants.CASTORE] = CASTORE;
- INSTRUCTIONS[Constants.SASTORE] = SASTORE;
- INSTRUCTIONS[Constants.POP] = POP;
- INSTRUCTIONS[Constants.POP2] = POP2;
- INSTRUCTIONS[Constants.DUP] = DUP;
- INSTRUCTIONS[Constants.DUP_X1] = DUP_X1;
- INSTRUCTIONS[Constants.DUP_X2] = DUP_X2;
- INSTRUCTIONS[Constants.DUP2] = DUP2;
- INSTRUCTIONS[Constants.DUP2_X1] = DUP2_X1;
- INSTRUCTIONS[Constants.DUP2_X2] = DUP2_X2;
- INSTRUCTIONS[Constants.SWAP] = SWAP;
- INSTRUCTIONS[Constants.IADD] = IADD;
- INSTRUCTIONS[Constants.LADD] = LADD;
- INSTRUCTIONS[Constants.FADD] = FADD;
- INSTRUCTIONS[Constants.DADD] = DADD;
- INSTRUCTIONS[Constants.ISUB] = ISUB;
- INSTRUCTIONS[Constants.LSUB] = LSUB;
- INSTRUCTIONS[Constants.FSUB] = FSUB;
- INSTRUCTIONS[Constants.DSUB] = DSUB;
- INSTRUCTIONS[Constants.IMUL] = IMUL;
- INSTRUCTIONS[Constants.LMUL] = LMUL;
- INSTRUCTIONS[Constants.FMUL] = FMUL;
- INSTRUCTIONS[Constants.DMUL] = DMUL;
- INSTRUCTIONS[Constants.IDIV] = IDIV;
- INSTRUCTIONS[Constants.LDIV] = LDIV;
- INSTRUCTIONS[Constants.FDIV] = FDIV;
- INSTRUCTIONS[Constants.DDIV] = DDIV;
- INSTRUCTIONS[Constants.IREM] = IREM;
- INSTRUCTIONS[Constants.LREM] = LREM;
- INSTRUCTIONS[Constants.FREM] = FREM;
- INSTRUCTIONS[Constants.DREM] = DREM;
- INSTRUCTIONS[Constants.INEG] = INEG;
- INSTRUCTIONS[Constants.LNEG] = LNEG;
- INSTRUCTIONS[Constants.FNEG] = FNEG;
- INSTRUCTIONS[Constants.DNEG] = DNEG;
- INSTRUCTIONS[Constants.ISHL] = ISHL;
- INSTRUCTIONS[Constants.LSHL] = LSHL;
- INSTRUCTIONS[Constants.ISHR] = ISHR;
- INSTRUCTIONS[Constants.LSHR] = LSHR;
- INSTRUCTIONS[Constants.IUSHR] = IUSHR;
- INSTRUCTIONS[Constants.LUSHR] = LUSHR;
- INSTRUCTIONS[Constants.IAND] = IAND;
- INSTRUCTIONS[Constants.LAND] = LAND;
- INSTRUCTIONS[Constants.IOR] = IOR;
- INSTRUCTIONS[Constants.LOR] = LOR;
- INSTRUCTIONS[Constants.IXOR] = IXOR;
- INSTRUCTIONS[Constants.LXOR] = LXOR;
- INSTRUCTIONS[Constants.I2L] = I2L;
- INSTRUCTIONS[Constants.I2F] = I2F;
- INSTRUCTIONS[Constants.I2D] = I2D;
- INSTRUCTIONS[Constants.L2I] = L2I;
- INSTRUCTIONS[Constants.L2F] = L2F;
- INSTRUCTIONS[Constants.L2D] = L2D;
- INSTRUCTIONS[Constants.F2I] = F2I;
- INSTRUCTIONS[Constants.F2L] = F2L;
- INSTRUCTIONS[Constants.F2D] = F2D;
- INSTRUCTIONS[Constants.D2I] = D2I;
- INSTRUCTIONS[Constants.D2L] = D2L;
- INSTRUCTIONS[Constants.D2F] = D2F;
- INSTRUCTIONS[Constants.I2B] = I2B;
- INSTRUCTIONS[Constants.I2C] = I2C;
- INSTRUCTIONS[Constants.I2S] = I2S;
- INSTRUCTIONS[Constants.LCMP] = LCMP;
- INSTRUCTIONS[Constants.FCMPL] = FCMPL;
- INSTRUCTIONS[Constants.FCMPG] = FCMPG;
- INSTRUCTIONS[Constants.DCMPL] = DCMPL;
- INSTRUCTIONS[Constants.DCMPG] = DCMPG;
- INSTRUCTIONS[Constants.IRETURN] = IRETURN;
- INSTRUCTIONS[Constants.LRETURN] = LRETURN;
- INSTRUCTIONS[Constants.FRETURN] = FRETURN;
- INSTRUCTIONS[Constants.DRETURN] = DRETURN;
- INSTRUCTIONS[Constants.ARETURN] = ARETURN;
- INSTRUCTIONS[Constants.RETURN] = RETURN;
- INSTRUCTIONS[Constants.ARRAYLENGTH] = ARRAYLENGTH;
- INSTRUCTIONS[Constants.ATHROW] = ATHROW;
- INSTRUCTIONS[Constants.MONITORENTER] = MONITORENTER;
- INSTRUCTIONS[Constants.MONITOREXIT] = MONITOREXIT;
- }
- }
+ Clinit() {
+ INSTRUCTIONS[Constants.NOP] = NOP;
+ INSTRUCTIONS[Constants.ACONST_NULL] = ACONST_NULL;
+ INSTRUCTIONS[Constants.ICONST_M1] = ICONST_M1;
+ INSTRUCTIONS[Constants.ICONST_0] = ICONST_0;
+ INSTRUCTIONS[Constants.ICONST_1] = ICONST_1;
+ INSTRUCTIONS[Constants.ICONST_2] = ICONST_2;
+ INSTRUCTIONS[Constants.ICONST_3] = ICONST_3;
+ INSTRUCTIONS[Constants.ICONST_4] = ICONST_4;
+ INSTRUCTIONS[Constants.ICONST_5] = ICONST_5;
+ INSTRUCTIONS[Constants.LCONST_0] = LCONST_0;
+ INSTRUCTIONS[Constants.LCONST_1] = LCONST_1;
+ INSTRUCTIONS[Constants.FCONST_0] = FCONST_0;
+ INSTRUCTIONS[Constants.FCONST_1] = FCONST_1;
+ INSTRUCTIONS[Constants.FCONST_2] = FCONST_2;
+ INSTRUCTIONS[Constants.DCONST_0] = DCONST_0;
+ INSTRUCTIONS[Constants.DCONST_1] = DCONST_1;
+ INSTRUCTIONS[Constants.IALOAD] = IALOAD;
+ INSTRUCTIONS[Constants.LALOAD] = LALOAD;
+ INSTRUCTIONS[Constants.FALOAD] = FALOAD;
+ INSTRUCTIONS[Constants.DALOAD] = DALOAD;
+ INSTRUCTIONS[Constants.AALOAD] = AALOAD;
+ INSTRUCTIONS[Constants.BALOAD] = BALOAD;
+ INSTRUCTIONS[Constants.CALOAD] = CALOAD;
+ INSTRUCTIONS[Constants.SALOAD] = SALOAD;
+ INSTRUCTIONS[Constants.IASTORE] = IASTORE;
+ INSTRUCTIONS[Constants.LASTORE] = LASTORE;
+ INSTRUCTIONS[Constants.FASTORE] = FASTORE;
+ INSTRUCTIONS[Constants.DASTORE] = DASTORE;
+ INSTRUCTIONS[Constants.AASTORE] = AASTORE;
+ INSTRUCTIONS[Constants.BASTORE] = BASTORE;
+ INSTRUCTIONS[Constants.CASTORE] = CASTORE;
+ INSTRUCTIONS[Constants.SASTORE] = SASTORE;
+ INSTRUCTIONS[Constants.POP] = POP;
+ INSTRUCTIONS[Constants.POP2] = POP2;
+ INSTRUCTIONS[Constants.DUP] = DUP;
+ INSTRUCTIONS[Constants.DUP_X1] = DUP_X1;
+ INSTRUCTIONS[Constants.DUP_X2] = DUP_X2;
+ INSTRUCTIONS[Constants.DUP2] = DUP2;
+ INSTRUCTIONS[Constants.DUP2_X1] = DUP2_X1;
+ INSTRUCTIONS[Constants.DUP2_X2] = DUP2_X2;
+ INSTRUCTIONS[Constants.SWAP] = SWAP;
+ INSTRUCTIONS[Constants.IADD] = IADD;
+ INSTRUCTIONS[Constants.LADD] = LADD;
+ INSTRUCTIONS[Constants.FADD] = FADD;
+ INSTRUCTIONS[Constants.DADD] = DADD;
+ INSTRUCTIONS[Constants.ISUB] = ISUB;
+ INSTRUCTIONS[Constants.LSUB] = LSUB;
+ INSTRUCTIONS[Constants.FSUB] = FSUB;
+ INSTRUCTIONS[Constants.DSUB] = DSUB;
+ INSTRUCTIONS[Constants.IMUL] = IMUL;
+ INSTRUCTIONS[Constants.LMUL] = LMUL;
+ INSTRUCTIONS[Constants.FMUL] = FMUL;
+ INSTRUCTIONS[Constants.DMUL] = DMUL;
+ INSTRUCTIONS[Constants.IDIV] = IDIV;
+ INSTRUCTIONS[Constants.LDIV] = LDIV;
+ INSTRUCTIONS[Constants.FDIV] = FDIV;
+ INSTRUCTIONS[Constants.DDIV] = DDIV;
+ INSTRUCTIONS[Constants.IREM] = IREM;
+ INSTRUCTIONS[Constants.LREM] = LREM;
+ INSTRUCTIONS[Constants.FREM] = FREM;
+ INSTRUCTIONS[Constants.DREM] = DREM;
+ INSTRUCTIONS[Constants.INEG] = INEG;
+ INSTRUCTIONS[Constants.LNEG] = LNEG;
+ INSTRUCTIONS[Constants.FNEG] = FNEG;
+ INSTRUCTIONS[Constants.DNEG] = DNEG;
+ INSTRUCTIONS[Constants.ISHL] = ISHL;
+ INSTRUCTIONS[Constants.LSHL] = LSHL;
+ INSTRUCTIONS[Constants.ISHR] = ISHR;
+ INSTRUCTIONS[Constants.LSHR] = LSHR;
+ INSTRUCTIONS[Constants.IUSHR] = IUSHR;
+ INSTRUCTIONS[Constants.LUSHR] = LUSHR;
+ INSTRUCTIONS[Constants.IAND] = IAND;
+ INSTRUCTIONS[Constants.LAND] = LAND;
+ INSTRUCTIONS[Constants.IOR] = IOR;
+ INSTRUCTIONS[Constants.LOR] = LOR;
+ INSTRUCTIONS[Constants.IXOR] = IXOR;
+ INSTRUCTIONS[Constants.LXOR] = LXOR;
+ INSTRUCTIONS[Constants.I2L] = I2L;
+ INSTRUCTIONS[Constants.I2F] = I2F;
+ INSTRUCTIONS[Constants.I2D] = I2D;
+ INSTRUCTIONS[Constants.L2I] = L2I;
+ INSTRUCTIONS[Constants.L2F] = L2F;
+ INSTRUCTIONS[Constants.L2D] = L2D;
+ INSTRUCTIONS[Constants.F2I] = F2I;
+ INSTRUCTIONS[Constants.F2L] = F2L;
+ INSTRUCTIONS[Constants.F2D] = F2D;
+ INSTRUCTIONS[Constants.D2I] = D2I;
+ INSTRUCTIONS[Constants.D2L] = D2L;
+ INSTRUCTIONS[Constants.D2F] = D2F;
+ INSTRUCTIONS[Constants.I2B] = I2B;
+ INSTRUCTIONS[Constants.I2C] = I2C;
+ INSTRUCTIONS[Constants.I2S] = I2S;
+ INSTRUCTIONS[Constants.LCMP] = LCMP;
+ INSTRUCTIONS[Constants.FCMPL] = FCMPL;
+ INSTRUCTIONS[Constants.FCMPG] = FCMPG;
+ INSTRUCTIONS[Constants.DCMPL] = DCMPL;
+ INSTRUCTIONS[Constants.DCMPG] = DCMPG;
+ INSTRUCTIONS[Constants.IRETURN] = IRETURN;
+ INSTRUCTIONS[Constants.LRETURN] = LRETURN;
+ INSTRUCTIONS[Constants.FRETURN] = FRETURN;
+ INSTRUCTIONS[Constants.DRETURN] = DRETURN;
+ INSTRUCTIONS[Constants.ARETURN] = ARETURN;
+ INSTRUCTIONS[Constants.RETURN] = RETURN;
+ INSTRUCTIONS[Constants.ARRAYLENGTH] = ARRAYLENGTH;
+ INSTRUCTIONS[Constants.ATHROW] = ATHROW;
+ INSTRUCTIONS[Constants.MONITORENTER] = MONITORENTER;
+ INSTRUCTIONS[Constants.MONITOREXIT] = MONITOREXIT;
+ }
+ }
}
diff --git a/src/org/apache/bcel/generic/InstructionFactory.java b/src/org/apache/bcel/generic/InstructionFactory.java
index 54d4304..35c1c5f 100644
--- a/src/org/apache/bcel/generic/InstructionFactory.java
+++ b/src/org/apache/bcel/generic/InstructionFactory.java
@@ -18,726 +18,729 @@ package org.apache.bcel.generic;
import org.apache.bcel.Constants;
-/**
- * Instances of this class may be used, e.g., to generate typed
- * versions of instructions. Its main purpose is to be used as the
- * byte code generating backend of a compiler. You can subclass it to
- * add your own create methods.
- *
+/**
+ * Instances of this class may be used, e.g., to generate typed versions of
+ * instructions. Its main purpose is to be used as the byte code generating
+ * backend of a compiler. You can subclass it to add your own create methods.
+ *
* @version $Id: InstructionFactory.java 386056 2006-03-15 11:31:56Z tcurdt $
* @author M. Dahm
* @see Constants
*/
-public class InstructionFactory implements InstructionConstants, java.io.Serializable {
+public class InstructionFactory implements InstructionConstants,
+ java.io.Serializable {
- protected ClassGen cg;
- protected ConstantPoolGen cp;
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ protected ClassGen cg;
+ protected ConstantPoolGen cp;
+ public InstructionFactory(ClassGen cg, ConstantPoolGen cp) {
+ this.cg = cg;
+ this.cp = cp;
+ }
- public InstructionFactory(ClassGen cg, ConstantPoolGen cp) {
- this.cg = cg;
- this.cp = cp;
- }
+ /**
+ * Initialize with ClassGen object
+ */
+ public InstructionFactory(ClassGen cg) {
+ this(cg, cg.getConstantPool());
+ }
+ /**
+ * Initialize just with ConstantPoolGen object
+ */
+ public InstructionFactory(ConstantPoolGen cp) {
+ this(null, cp);
+ }
- /** Initialize with ClassGen object
- */
- public InstructionFactory(ClassGen cg) {
- this(cg, cg.getConstantPool());
- }
+ /**
+ * Create an invoke instruction.
+ *
+ * @param class_name
+ * name of the called class
+ * @param name
+ * name of the called method
+ * @param ret_type
+ * return type of method
+ * @param arg_types
+ * argument types of method
+ * @param kind
+ * how to invoke, i.e., INVOKEINTERFACE, INVOKESTATIC,
+ * INVOKEVIRTUAL, or INVOKESPECIAL
+ * @see Constants
+ */
+ public InvokeInstruction createInvoke(String class_name, String name,
+ Type ret_type, Type[] arg_types, short kind) {
+ int index;
+ int nargs = 0;
+ String signature = Type.getMethodSignature(ret_type, arg_types);
+ for (int i = 0; i < arg_types.length; i++) {
+ nargs += arg_types[i].getSize();
+ }
+ if (kind == Constants.INVOKEINTERFACE) {
+ index = cp.addInterfaceMethodref(class_name, name, signature);
+ } else {
+ index = cp.addMethodref(class_name, name, signature);
+ }
+ switch (kind) {
+ case Constants.INVOKESPECIAL:
+ return new INVOKESPECIAL(index);
+ case Constants.INVOKEVIRTUAL:
+ return new INVOKEVIRTUAL(index);
+ case Constants.INVOKESTATIC:
+ return new INVOKESTATIC(index);
+ case Constants.INVOKEINTERFACE:
+ return new INVOKEINTERFACE(index, nargs + 1);
+ default:
+ throw new RuntimeException("Oops: Unknown invoke kind:" + kind);
+ }
+ }
+ /**
+ * Create a call to the most popular System.out.println() method.
+ *
+ * @param s
+ * the string to print
+ */
+ public InstructionList createPrintln(String s) {
+ InstructionList il = new InstructionList();
+ int out = cp.addFieldref("java.lang.System", "out",
+ "Ljava/io/PrintStream;");
+ int println = cp.addMethodref("java.io.PrintStream", "println",
+ "(Ljava/lang/String;)V");
+ il.append(new GETSTATIC(out));
+ il.append(new PUSH(cp, s));
+ il.append(new INVOKEVIRTUAL(println));
+ return il;
+ }
- /** Initialize just with ConstantPoolGen object
- */
- public InstructionFactory(ConstantPoolGen cp) {
- this(null, cp);
- }
+ /**
+ * Uses PUSH to push a constant value onto the stack.
+ *
+ * @param value
+ * must be of type Number, Boolean, Character or String
+ */
+ public Instruction createConstant(Object value) {
+ PUSH push;
+ if (value instanceof Number) {
+ push = new PUSH(cp, (Number) value);
+ } else if (value instanceof String) {
+ push = new PUSH(cp, (String) value);
+ } else if (value instanceof Boolean) {
+ push = new PUSH(cp, (Boolean) value);
+ } else if (value instanceof Character) {
+ push = new PUSH(cp, (Character) value);
+ } else {
+ throw new ClassGenException("Illegal type: " + value.getClass());
+ }
+ return push.getInstruction();
+ }
+ private static class MethodObject {
- /** Create an invoke instruction.
- *
- * @param class_name name of the called class
- * @param name name of the called method
- * @param ret_type return type of method
- * @param arg_types argument types of method
- * @param kind how to invoke, i.e., INVOKEINTERFACE, INVOKESTATIC, INVOKEVIRTUAL,
- * or INVOKESPECIAL
- * @see Constants
- */
- public InvokeInstruction createInvoke( String class_name, String name, Type ret_type,
- Type[] arg_types, short kind ) {
- int index;
- int nargs = 0;
- String signature = Type.getMethodSignature(ret_type, arg_types);
- for (int i = 0; i < arg_types.length; i++) {
- nargs += arg_types[i].getSize();
- }
- if (kind == Constants.INVOKEINTERFACE) {
- index = cp.addInterfaceMethodref(class_name, name, signature);
- } else {
- index = cp.addMethodref(class_name, name, signature);
- }
- switch (kind) {
- case Constants.INVOKESPECIAL:
- return new INVOKESPECIAL(index);
- case Constants.INVOKEVIRTUAL:
- return new INVOKEVIRTUAL(index);
- case Constants.INVOKESTATIC:
- return new INVOKESTATIC(index);
- case Constants.INVOKEINTERFACE:
- return new INVOKEINTERFACE(index, nargs + 1);
- default:
- throw new RuntimeException("Oops: Unknown invoke kind:" + kind);
- }
- }
+ Type[] arg_types;
+ Type result_type;
+ String class_name;
+ String name;
+ MethodObject(String c, String n, Type r, Type[] a, int acc) {
+ class_name = c;
+ name = n;
+ result_type = r;
+ arg_types = a;
+ }
+ }
- /** Create a call to the most popular System.out.println() method.
- *
- * @param s the string to print
- */
- public InstructionList createPrintln( String s ) {
- InstructionList il = new InstructionList();
- int out = cp.addFieldref("java.lang.System", "out", "Ljava/io/PrintStream;");
- int println = cp.addMethodref("java.io.PrintStream", "println", "(Ljava/lang/String;)V");
- il.append(new GETSTATIC(out));
- il.append(new PUSH(cp, s));
- il.append(new INVOKEVIRTUAL(println));
- return il;
- }
+ private InvokeInstruction createInvoke(MethodObject m, short kind) {
+ return createInvoke(m.class_name, m.name, m.result_type, m.arg_types,
+ kind);
+ }
+ private static MethodObject[] append_mos = {
+ new MethodObject("java.lang.StringBuffer", "append",
+ Type.STRINGBUFFER, new Type[] { Type.STRING },
+ Constants.ACC_PUBLIC),
+ new MethodObject("java.lang.StringBuffer", "append",
+ Type.STRINGBUFFER, new Type[] { Type.OBJECT },
+ Constants.ACC_PUBLIC),
+ null,
+ null, // indices 2, 3
+ new MethodObject("java.lang.StringBuffer", "append",
+ Type.STRINGBUFFER, new Type[] { Type.BOOLEAN },
+ Constants.ACC_PUBLIC),
+ new MethodObject("java.lang.StringBuffer", "append",
+ Type.STRINGBUFFER, new Type[] { Type.CHAR },
+ Constants.ACC_PUBLIC),
+ new MethodObject("java.lang.StringBuffer", "append",
+ Type.STRINGBUFFER, new Type[] { Type.FLOAT },
+ Constants.ACC_PUBLIC),
+ new MethodObject("java.lang.StringBuffer", "append",
+ Type.STRINGBUFFER, new Type[] { Type.DOUBLE },
+ Constants.ACC_PUBLIC),
+ new MethodObject("java.lang.StringBuffer", "append",
+ Type.STRINGBUFFER, new Type[] { Type.INT },
+ Constants.ACC_PUBLIC),
+ new MethodObject("java.lang.StringBuffer", "append",
+ Type.STRINGBUFFER, // No append(byte)
+ new Type[] { Type.INT }, Constants.ACC_PUBLIC),
+ new MethodObject("java.lang.StringBuffer", "append",
+ Type.STRINGBUFFER, // No append(short)
+ new Type[] { Type.INT }, Constants.ACC_PUBLIC),
+ new MethodObject("java.lang.StringBuffer", "append",
+ Type.STRINGBUFFER, new Type[] { Type.LONG },
+ Constants.ACC_PUBLIC) };
- /** Uses PUSH to push a constant value onto the stack.
- * @param value must be of type Number, Boolean, Character or String
- */
- public Instruction createConstant( Object value ) {
- PUSH push;
- if (value instanceof Number) {
- push = new PUSH(cp, (Number) value);
- } else if (value instanceof String) {
- push = new PUSH(cp, (String) value);
- } else if (value instanceof Boolean) {
- push = new PUSH(cp, (Boolean) value);
- } else if (value instanceof Character) {
- push = new PUSH(cp, (Character) value);
- } else {
- throw new ClassGenException("Illegal type: " + value.getClass());
- }
- return push.getInstruction();
- }
+ private static final boolean isString(Type type) {
+ return ((type instanceof ObjectType) && ((ObjectType) type)
+ .getClassName().equals("java.lang.String"));
+ }
- private static class MethodObject {
+ public Instruction createAppend(Type type) {
+ byte t = type.getType();
+ if (isString(type)) {
+ return createInvoke(append_mos[0], Constants.INVOKEVIRTUAL);
+ }
+ switch (t) {
+ case Constants.T_BOOLEAN:
+ case Constants.T_CHAR:
+ case Constants.T_FLOAT:
+ case Constants.T_DOUBLE:
+ case Constants.T_BYTE:
+ case Constants.T_SHORT:
+ case Constants.T_INT:
+ case Constants.T_LONG:
+ return createInvoke(append_mos[t], Constants.INVOKEVIRTUAL);
+ case Constants.T_ARRAY:
+ case Constants.T_OBJECT:
+ return createInvoke(append_mos[1], Constants.INVOKEVIRTUAL);
+ default:
+ throw new RuntimeException("Oops: No append for this type? " + type);
+ }
+ }
- Type[] arg_types;
- Type result_type;
- String class_name;
- String name;
- int access;
+ /**
+ * Create a field instruction.
+ *
+ * @param class_name
+ * name of the accessed class
+ * @param name
+ * name of the referenced field
+ * @param type
+ * type of field
+ * @param kind
+ * how to access, i.e., GETFIELD, PUTFIELD, GETSTATIC, PUTSTATIC
+ * @see Constants
+ */
+ public FieldInstruction createFieldAccess(String class_name, String name,
+ Type type, short kind) {
+ int index;
+ String signature = type.getSignature();
+ index = cp.addFieldref(class_name, name, signature);
+ switch (kind) {
+ case Constants.GETFIELD:
+ return new GETFIELD(index);
+ case Constants.PUTFIELD:
+ return new PUTFIELD(index);
+ case Constants.GETSTATIC:
+ return new GETSTATIC(index);
+ case Constants.PUTSTATIC:
+ return new PUTSTATIC(index);
+ default:
+ throw new RuntimeException("Oops: Unknown getfield kind:" + kind);
+ }
+ }
+ /**
+ * Create reference to `this'
+ */
+ public static Instruction createThis() {
+ return new ALOAD(0);
+ }
- MethodObject(String c, String n, Type r, Type[] a, int acc) {
- class_name = c;
- name = n;
- result_type = r;
- arg_types = a;
- access = acc;
- }
- }
+ /**
+ * Create typed return
+ */
+ public static ReturnInstruction createReturn(Type type) {
+ switch (type.getType()) {
+ case Constants.T_ARRAY:
+ case Constants.T_OBJECT:
+ return ARETURN;
+ case Constants.T_INT:
+ case Constants.T_SHORT:
+ case Constants.T_BOOLEAN:
+ case Constants.T_CHAR:
+ case Constants.T_BYTE:
+ return IRETURN;
+ case Constants.T_FLOAT:
+ return FRETURN;
+ case Constants.T_DOUBLE:
+ return DRETURN;
+ case Constants.T_LONG:
+ return LRETURN;
+ case Constants.T_VOID:
+ return RETURN;
+ default:
+ throw new RuntimeException("Invalid type: " + type);
+ }
+ }
+ private static final ArithmeticInstruction createBinaryIntOp(char first,
+ String op) {
+ switch (first) {
+ case '-':
+ return ISUB;
+ case '+':
+ return IADD;
+ case '%':
+ return IREM;
+ case '*':
+ return IMUL;
+ case '/':
+ return IDIV;
+ case '&':
+ return IAND;
+ case '|':
+ return IOR;
+ case '^':
+ return IXOR;
+ case '<':
+ return ISHL;
+ case '>':
+ return op.equals(">>>") ? (ArithmeticInstruction) IUSHR
+ : (ArithmeticInstruction) ISHR;
+ default:
+ throw new RuntimeException("Invalid operand " + op);
+ }
+ }
- private InvokeInstruction createInvoke( MethodObject m, short kind ) {
- return createInvoke(m.class_name, m.name, m.result_type, m.arg_types, kind);
- }
+ private static final ArithmeticInstruction createBinaryLongOp(char first,
+ String op) {
+ switch (first) {
+ case '-':
+ return LSUB;
+ case '+':
+ return LADD;
+ case '%':
+ return LREM;
+ case '*':
+ return LMUL;
+ case '/':
+ return LDIV;
+ case '&':
+ return LAND;
+ case '|':
+ return LOR;
+ case '^':
+ return LXOR;
+ case '<':
+ return LSHL;
+ case '>':
+ return op.equals(">>>") ? (ArithmeticInstruction) LUSHR
+ : (ArithmeticInstruction) LSHR;
+ default:
+ throw new RuntimeException("Invalid operand " + op);
+ }
+ }
- private static MethodObject[] append_mos = {
- new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER, new Type[] {
- Type.STRING
- }, Constants.ACC_PUBLIC),
- new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER, new Type[] {
- Type.OBJECT
- }, Constants.ACC_PUBLIC),
- null,
- null, // indices 2, 3
- new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER, new Type[] {
- Type.BOOLEAN
- }, Constants.ACC_PUBLIC),
- new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER, new Type[] {
- Type.CHAR
- }, Constants.ACC_PUBLIC),
- new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER, new Type[] {
- Type.FLOAT
- }, Constants.ACC_PUBLIC),
- new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER, new Type[] {
- Type.DOUBLE
- }, Constants.ACC_PUBLIC),
- new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER, new Type[] {
- Type.INT
- }, Constants.ACC_PUBLIC),
- new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER, // No append(byte)
- new Type[] {
- Type.INT
- }, Constants.ACC_PUBLIC),
- new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER, // No append(short)
- new Type[] {
- Type.INT
- }, Constants.ACC_PUBLIC),
- new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER, new Type[] {
- Type.LONG
- }, Constants.ACC_PUBLIC)
- };
+ private static final ArithmeticInstruction createBinaryFloatOp(char op) {
+ switch (op) {
+ case '-':
+ return FSUB;
+ case '+':
+ return FADD;
+ case '*':
+ return FMUL;
+ case '/':
+ return FDIV;
+ default:
+ throw new RuntimeException("Invalid operand " + op);
+ }
+ }
+ private static final ArithmeticInstruction createBinaryDoubleOp(char op) {
+ switch (op) {
+ case '-':
+ return DSUB;
+ case '+':
+ return DADD;
+ case '*':
+ return DMUL;
+ case '/':
+ return DDIV;
+ default:
+ throw new RuntimeException("Invalid operand " + op);
+ }
+ }
- private static final boolean isString( Type type ) {
- return ((type instanceof ObjectType) && ((ObjectType) type).getClassName().equals(
- "java.lang.String"));
- }
-
-
- public Instruction createAppend( Type type ) {
- byte t = type.getType();
- if (isString(type)) {
- return createInvoke(append_mos[0], Constants.INVOKEVIRTUAL);
- }
- switch (t) {
- case Constants.T_BOOLEAN:
- case Constants.T_CHAR:
- case Constants.T_FLOAT:
- case Constants.T_DOUBLE:
- case Constants.T_BYTE:
- case Constants.T_SHORT:
- case Constants.T_INT:
- case Constants.T_LONG:
- return createInvoke(append_mos[t], Constants.INVOKEVIRTUAL);
- case Constants.T_ARRAY:
- case Constants.T_OBJECT:
- return createInvoke(append_mos[1], Constants.INVOKEVIRTUAL);
- default:
- throw new RuntimeException("Oops: No append for this type? " + type);
- }
- }
-
-
- /** Create a field instruction.
- *
- * @param class_name name of the accessed class
- * @param name name of the referenced field
- * @param type type of field
- * @param kind how to access, i.e., GETFIELD, PUTFIELD, GETSTATIC, PUTSTATIC
- * @see Constants
- */
- public FieldInstruction createFieldAccess( String class_name, String name, Type type, short kind ) {
- int index;
- String signature = type.getSignature();
- index = cp.addFieldref(class_name, name, signature);
- switch (kind) {
- case Constants.GETFIELD:
- return new GETFIELD(index);
- case Constants.PUTFIELD:
- return new PUTFIELD(index);
- case Constants.GETSTATIC:
- return new GETSTATIC(index);
- case Constants.PUTSTATIC:
- return new PUTSTATIC(index);
- default:
- throw new RuntimeException("Oops: Unknown getfield kind:" + kind);
- }
- }
-
-
- /** Create reference to `this'
- */
- public static Instruction createThis() {
- return new ALOAD(0);
- }
-
-
- /** Create typed return
- */
- public static ReturnInstruction createReturn( Type type ) {
- switch (type.getType()) {
- case Constants.T_ARRAY:
- case Constants.T_OBJECT:
- return ARETURN;
- case Constants.T_INT:
- case Constants.T_SHORT:
- case Constants.T_BOOLEAN:
- case Constants.T_CHAR:
- case Constants.T_BYTE:
- return IRETURN;
- case Constants.T_FLOAT:
- return FRETURN;
- case Constants.T_DOUBLE:
- return DRETURN;
- case Constants.T_LONG:
- return LRETURN;
- case Constants.T_VOID:
- return RETURN;
- default:
- throw new RuntimeException("Invalid type: " + type);
- }
- }
-
-
- private static final ArithmeticInstruction createBinaryIntOp( char first, String op ) {
- switch (first) {
- case '-':
- return ISUB;
- case '+':
- return IADD;
- case '%':
- return IREM;
- case '*':
- return IMUL;
- case '/':
- return IDIV;
- case '&':
- return IAND;
- case '|':
- return IOR;
- case '^':
- return IXOR;
- case '<':
- return ISHL;
- case '>':
- return op.equals(">>>")
- ? (ArithmeticInstruction) IUSHR
- : (ArithmeticInstruction) ISHR;
- default:
- throw new RuntimeException("Invalid operand " + op);
- }
- }
-
-
- private static final ArithmeticInstruction createBinaryLongOp( char first, String op ) {
- switch (first) {
- case '-':
- return LSUB;
- case '+':
- return LADD;
- case '%':
- return LREM;
- case '*':
- return LMUL;
- case '/':
- return LDIV;
- case '&':
- return LAND;
- case '|':
- return LOR;
- case '^':
- return LXOR;
- case '<':
- return LSHL;
- case '>':
- return op.equals(">>>")
- ? (ArithmeticInstruction) LUSHR
- : (ArithmeticInstruction) LSHR;
- default:
- throw new RuntimeException("Invalid operand " + op);
- }
- }
-
-
- private static final ArithmeticInstruction createBinaryFloatOp( char op ) {
- switch (op) {
- case '-':
- return FSUB;
- case '+':
- return FADD;
- case '*':
- return FMUL;
- case '/':
- return FDIV;
- default:
- throw new RuntimeException("Invalid operand " + op);
- }
- }
-
-
- private static final ArithmeticInstruction createBinaryDoubleOp( char op ) {
- switch (op) {
- case '-':
- return DSUB;
- case '+':
- return DADD;
- case '*':
- return DMUL;
- case '/':
- return DDIV;
- default:
- throw new RuntimeException("Invalid operand " + op);
- }
- }
-
-
- /**
+/**
* Create binary operation for simple basic types, such as int and float.
*
* @param op operation, such as "+", "*", "<<", etc.
*/
- public static ArithmeticInstruction createBinaryOperation( String op, Type type ) {
- char first = op.toCharArray()[0];
- switch (type.getType()) {
- case Constants.T_BYTE:
- case Constants.T_SHORT:
- case Constants.T_INT:
- case Constants.T_CHAR:
- return createBinaryIntOp(first, op);
- case Constants.T_LONG:
- return createBinaryLongOp(first, op);
- case Constants.T_FLOAT:
- return createBinaryFloatOp(first);
- case Constants.T_DOUBLE:
- return createBinaryDoubleOp(first);
- default:
- throw new RuntimeException("Invalid type " + type);
- }
- }
+ public static ArithmeticInstruction createBinaryOperation(String op,
+ Type type) {
+ char first = op.toCharArray()[0];
+ switch (type.getType()) {
+ case Constants.T_BYTE:
+ case Constants.T_SHORT:
+ case Constants.T_INT:
+ case Constants.T_CHAR:
+ return createBinaryIntOp(first, op);
+ case Constants.T_LONG:
+ return createBinaryLongOp(first, op);
+ case Constants.T_FLOAT:
+ return createBinaryFloatOp(first);
+ case Constants.T_DOUBLE:
+ return createBinaryDoubleOp(first);
+ default:
+ throw new RuntimeException("Invalid type " + type);
+ }
+ }
+ /**
+ * @param size
+ * size of operand, either 1 (int, e.g.) or 2 (double)
+ */
+ public static StackInstruction createPop(int size) {
+ return (size == 2) ? (StackInstruction) POP2 : (StackInstruction) POP;
+ }
- /**
- * @param size size of operand, either 1 (int, e.g.) or 2 (double)
- */
- public static StackInstruction createPop( int size ) {
- return (size == 2) ? (StackInstruction) POP2 : (StackInstruction) POP;
- }
+ /**
+ * @param size
+ * size of operand, either 1 (int, e.g.) or 2 (double)
+ */
+ public static StackInstruction createDup(int size) {
+ return (size == 2) ? (StackInstruction) DUP2 : (StackInstruction) DUP;
+ }
+ /**
+ * @param size
+ * size of operand, either 1 (int, e.g.) or 2 (double)
+ */
+ public static StackInstruction createDup_2(int size) {
+ return (size == 2) ? (StackInstruction) DUP2_X2
+ : (StackInstruction) DUP_X2;
+ }
- /**
- * @param size size of operand, either 1 (int, e.g.) or 2 (double)
- */
- public static StackInstruction createDup( int size ) {
- return (size == 2) ? (StackInstruction) DUP2 : (StackInstruction) DUP;
- }
+ /**
+ * @param size
+ * size of operand, either 1 (int, e.g.) or 2 (double)
+ */
+ public static StackInstruction createDup_1(int size) {
+ return (size == 2) ? (StackInstruction) DUP2_X1
+ : (StackInstruction) DUP_X1;
+ }
+ /**
+ * @param index
+ * index of local variable
+ */
+ public static LocalVariableInstruction createStore(Type type, int index) {
+ switch (type.getType()) {
+ case Constants.T_BOOLEAN:
+ case Constants.T_CHAR:
+ case Constants.T_BYTE:
+ case Constants.T_SHORT:
+ case Constants.T_INT:
+ return new ISTORE(index);
+ case Constants.T_FLOAT:
+ return new FSTORE(index);
+ case Constants.T_DOUBLE:
+ return new DSTORE(index);
+ case Constants.T_LONG:
+ return new LSTORE(index);
+ case Constants.T_ARRAY:
+ case Constants.T_OBJECT:
+ return new ASTORE(index);
+ default:
+ throw new RuntimeException("Invalid type " + type);
+ }
+ }
- /**
- * @param size size of operand, either 1 (int, e.g.) or 2 (double)
- */
- public static StackInstruction createDup_2( int size ) {
- return (size == 2) ? (StackInstruction) DUP2_X2 : (StackInstruction) DUP_X2;
- }
+ /**
+ * @param index
+ * index of local variable
+ */
+ public static LocalVariableInstruction createLoad(Type type, int index) {
+ switch (type.getType()) {
+ case Constants.T_BOOLEAN:
+ case Constants.T_CHAR:
+ case Constants.T_BYTE:
+ case Constants.T_SHORT:
+ case Constants.T_INT:
+ return new ILOAD(index);
+ case Constants.T_FLOAT:
+ return new FLOAD(index);
+ case Constants.T_DOUBLE:
+ return new DLOAD(index);
+ case Constants.T_LONG:
+ return new LLOAD(index);
+ case Constants.T_ARRAY:
+ case Constants.T_OBJECT:
+ return new ALOAD(index);
+ default:
+ throw new RuntimeException("Invalid type " + type);
+ }
+ }
+ /**
+ * @param type
+ * type of elements of array, i.e., array.getElementType()
+ */
+ public static ArrayInstruction createArrayLoad(Type type) {
+ switch (type.getType()) {
+ case Constants.T_BOOLEAN:
+ case Constants.T_BYTE:
+ return BALOAD;
+ case Constants.T_CHAR:
+ return CALOAD;
+ case Constants.T_SHORT:
+ return SALOAD;
+ case Constants.T_INT:
+ return IALOAD;
+ case Constants.T_FLOAT:
+ return FALOAD;
+ case Constants.T_DOUBLE:
+ return DALOAD;
+ case Constants.T_LONG:
+ return LALOAD;
+ case Constants.T_ARRAY:
+ case Constants.T_OBJECT:
+ return AALOAD;
+ default:
+ throw new RuntimeException("Invalid type " + type);
+ }
+ }
- /**
- * @param size size of operand, either 1 (int, e.g.) or 2 (double)
- */
- public static StackInstruction createDup_1( int size ) {
- return (size == 2) ? (StackInstruction) DUP2_X1 : (StackInstruction) DUP_X1;
- }
+ /**
+ * @param type
+ * type of elements of array, i.e., array.getElementType()
+ */
+ public static ArrayInstruction createArrayStore(Type type) {
+ switch (type.getType()) {
+ case Constants.T_BOOLEAN:
+ case Constants.T_BYTE:
+ return BASTORE;
+ case Constants.T_CHAR:
+ return CASTORE;
+ case Constants.T_SHORT:
+ return SASTORE;
+ case Constants.T_INT:
+ return IASTORE;
+ case Constants.T_FLOAT:
+ return FASTORE;
+ case Constants.T_DOUBLE:
+ return DASTORE;
+ case Constants.T_LONG:
+ return LASTORE;
+ case Constants.T_ARRAY:
+ case Constants.T_OBJECT:
+ return AASTORE;
+ default:
+ throw new RuntimeException("Invalid type " + type);
+ }
+ }
+ /**
+ * Create conversion operation for two stack operands, this may be an I2C,
+ * instruction, e.g., if the operands are basic types and CHECKCAST if they
+ * are reference types.
+ */
+ public Instruction createCast(Type src_type, Type dest_type) {
+ if ((src_type instanceof BasicType) && (dest_type instanceof BasicType)) {
+ byte dest = dest_type.getType();
+ byte src = src_type.getType();
+ if (dest == Constants.T_LONG
+ && (src == Constants.T_CHAR || src == Constants.T_BYTE || src == Constants.T_SHORT)) {
+ src = Constants.T_INT;
+ }
+ String[] short_names = { "C", "F", "D", "B", "S", "I", "L" };
+ String name = "org.apache.bcel.generic."
+ + short_names[src - Constants.T_CHAR] + "2"
+ + short_names[dest - Constants.T_CHAR];
+ Instruction i = null;
+ try {
+ i = (Instruction) java.lang.Class.forName(name).newInstance();
+ } catch (Exception e) {
+ throw new RuntimeException("Could not find instruction: "
+ + name);
+ }
+ return i;
+ } else if ((src_type instanceof ReferenceType)
+ && (dest_type instanceof ReferenceType)) {
+ if (dest_type instanceof ArrayType) {
+ return new CHECKCAST(cp.addArrayClass((ArrayType) dest_type));
+ } else {
+ return new CHECKCAST(cp.addClass(((ObjectType) dest_type)
+ .getClassName()));
+ }
+ } else {
+ throw new RuntimeException("Can not cast " + src_type + " to "
+ + dest_type);
+ }
+ }
- /**
- * @param index index of local variable
- */
- public static LocalVariableInstruction createStore( Type type, int index ) {
- switch (type.getType()) {
- case Constants.T_BOOLEAN:
- case Constants.T_CHAR:
- case Constants.T_BYTE:
- case Constants.T_SHORT:
- case Constants.T_INT:
- return new ISTORE(index);
- case Constants.T_FLOAT:
- return new FSTORE(index);
- case Constants.T_DOUBLE:
- return new DSTORE(index);
- case Constants.T_LONG:
- return new LSTORE(index);
- case Constants.T_ARRAY:
- case Constants.T_OBJECT:
- return new ASTORE(index);
- default:
- throw new RuntimeException("Invalid type " + type);
- }
- }
+ public GETFIELD createGetField(String class_name, String name, Type t) {
+ return new GETFIELD(cp.addFieldref(class_name, name, t.getSignature()));
+ }
+ public GETSTATIC createGetStatic(String class_name, String name, Type t) {
+ return new GETSTATIC(cp.addFieldref(class_name, name, t.getSignature()));
+ }
- /**
- * @param index index of local variable
- */
- public static LocalVariableInstruction createLoad( Type type, int index ) {
- switch (type.getType()) {
- case Constants.T_BOOLEAN:
- case Constants.T_CHAR:
- case Constants.T_BYTE:
- case Constants.T_SHORT:
- case Constants.T_INT:
- return new ILOAD(index);
- case Constants.T_FLOAT:
- return new FLOAD(index);
- case Constants.T_DOUBLE:
- return new DLOAD(index);
- case Constants.T_LONG:
- return new LLOAD(index);
- case Constants.T_ARRAY:
- case Constants.T_OBJECT:
- return new ALOAD(index);
- default:
- throw new RuntimeException("Invalid type " + type);
- }
- }
+ public PUTFIELD createPutField(String class_name, String name, Type t) {
+ return new PUTFIELD(cp.addFieldref(class_name, name, t.getSignature()));
+ }
+ public PUTSTATIC createPutStatic(String class_name, String name, Type t) {
+ return new PUTSTATIC(cp.addFieldref(class_name, name, t.getSignature()));
+ }
- /**
- * @param type type of elements of array, i.e., array.getElementType()
- */
- public static ArrayInstruction createArrayLoad( Type type ) {
- switch (type.getType()) {
- case Constants.T_BOOLEAN:
- case Constants.T_BYTE:
- return BALOAD;
- case Constants.T_CHAR:
- return CALOAD;
- case Constants.T_SHORT:
- return SALOAD;
- case Constants.T_INT:
- return IALOAD;
- case Constants.T_FLOAT:
- return FALOAD;
- case Constants.T_DOUBLE:
- return DALOAD;
- case Constants.T_LONG:
- return LALOAD;
- case Constants.T_ARRAY:
- case Constants.T_OBJECT:
- return AALOAD;
- default:
- throw new RuntimeException("Invalid type " + type);
- }
- }
+ public CHECKCAST createCheckCast(ReferenceType t) {
+ if (t instanceof ArrayType) {
+ return new CHECKCAST(cp.addArrayClass((ArrayType) t));
+ } else {
+ return new CHECKCAST(cp.addClass((ObjectType) t));
+ }
+ }
+ public INSTANCEOF createInstanceOf(ReferenceType t) {
+ if (t instanceof ArrayType) {
+ return new INSTANCEOF(cp.addArrayClass((ArrayType) t));
+ } else {
+ return new INSTANCEOF(cp.addClass((ObjectType) t));
+ }
+ }
- /**
- * @param type type of elements of array, i.e., array.getElementType()
- */
- public static ArrayInstruction createArrayStore( Type type ) {
- switch (type.getType()) {
- case Constants.T_BOOLEAN:
- case Constants.T_BYTE:
- return BASTORE;
- case Constants.T_CHAR:
- return CASTORE;
- case Constants.T_SHORT:
- return SASTORE;
- case Constants.T_INT:
- return IASTORE;
- case Constants.T_FLOAT:
- return FASTORE;
- case Constants.T_DOUBLE:
- return DASTORE;
- case Constants.T_LONG:
- return LASTORE;
- case Constants.T_ARRAY:
- case Constants.T_OBJECT:
- return AASTORE;
- default:
- throw new RuntimeException("Invalid type " + type);
- }
- }
+ public NEW createNew(ObjectType t) {
+ return new NEW(cp.addClass(t));
+ }
+ public NEW createNew(String s) {
+ return createNew(new ObjectType(s));
+ }
- /** Create conversion operation for two stack operands, this may be an I2C, instruction, e.g.,
- * if the operands are basic types and CHECKCAST if they are reference types.
- */
- public Instruction createCast( Type src_type, Type dest_type ) {
- if ((src_type instanceof BasicType) && (dest_type instanceof BasicType)) {
- byte dest = dest_type.getType();
- byte src = src_type.getType();
- if (dest == Constants.T_LONG
- && (src == Constants.T_CHAR || src == Constants.T_BYTE || src == Constants.T_SHORT)) {
- src = Constants.T_INT;
- }
- String[] short_names = {
- "C", "F", "D", "B", "S", "I", "L"
- };
- String name = "org.apache.bcel.generic." + short_names[src - Constants.T_CHAR] + "2"
- + short_names[dest - Constants.T_CHAR];
- Instruction i = null;
- try {
- i = (Instruction) java.lang.Class.forName(name).newInstance();
- } catch (Exception e) {
- throw new RuntimeException("Could not find instruction: " + name);
- }
- return i;
- } else if ((src_type instanceof ReferenceType) && (dest_type instanceof ReferenceType)) {
- if (dest_type instanceof ArrayType) {
- return new CHECKCAST(cp.addArrayClass((ArrayType) dest_type));
- } else {
- return new CHECKCAST(cp.addClass(((ObjectType) dest_type).getClassName()));
- }
- } else {
- throw new RuntimeException("Can not cast " + src_type + " to " + dest_type);
- }
- }
+ /**
+ * Create new array of given size and type.
+ *
+ * @return an instruction that creates the corresponding array at runtime,
+ * i.e. is an AllocationInstruction
+ */
+ public Instruction createNewArray(Type t, short dim) {
+ if (dim == 1) {
+ if (t instanceof ObjectType) {
+ return new ANEWARRAY(cp.addClass((ObjectType) t));
+ } else if (t instanceof ArrayType) {
+ return new ANEWARRAY(cp.addArrayClass((ArrayType) t));
+ } else {
+ return new NEWARRAY(((BasicType) t).getType());
+ }
+ } else {
+ ArrayType at;
+ if (t instanceof ArrayType) {
+ at = (ArrayType) t;
+ } else {
+ at = new ArrayType(t, dim);
+ }
+ return new MULTIANEWARRAY(cp.addArrayClass(at), dim);
+ }
+ }
+ /**
+ * Create "null" value for reference types, 0 for basic types like int
+ */
+ public static Instruction createNull(Type type) {
+ switch (type.getType()) {
+ case Constants.T_ARRAY:
+ case Constants.T_OBJECT:
+ return ACONST_NULL;
+ case Constants.T_INT:
+ case Constants.T_SHORT:
+ case Constants.T_BOOLEAN:
+ case Constants.T_CHAR:
+ case Constants.T_BYTE:
+ return ICONST_0;
+ case Constants.T_FLOAT:
+ return FCONST_0;
+ case Constants.T_DOUBLE:
+ return DCONST_0;
+ case Constants.T_LONG:
+ return LCONST_0;
+ case Constants.T_VOID:
+ return NOP;
+ default:
+ throw new RuntimeException("Invalid type: " + type);
+ }
+ }
- public GETFIELD createGetField( String class_name, String name, Type t ) {
- return new GETFIELD(cp.addFieldref(class_name, name, t.getSignature()));
- }
+ /**
+ * Create branch instruction by given opcode, except LOOKUPSWITCH and
+ * TABLESWITCH. For those you should use the SWITCH compound instruction.
+ */
+ public static BranchInstruction createBranchInstruction(short opcode,
+ InstructionHandle target) {
+ switch (opcode) {
+ case Constants.IFEQ:
+ return new IFEQ(target);
+ case Constants.IFNE:
+ return new IFNE(target);
+ case Constants.IFLT:
+ return new IFLT(target);
+ case Constants.IFGE:
+ return new IFGE(target);
+ case Constants.IFGT:
+ return new IFGT(target);
+ case Constants.IFLE:
+ return new IFLE(target);
+ case Constants.IF_ICMPEQ:
+ return new IF_ICMPEQ(target);
+ case Constants.IF_ICMPNE:
+ return new IF_ICMPNE(target);
+ case Constants.IF_ICMPLT:
+ return new IF_ICMPLT(target);
+ case Constants.IF_ICMPGE:
+ return new IF_ICMPGE(target);
+ case Constants.IF_ICMPGT:
+ return new IF_ICMPGT(target);
+ case Constants.IF_ICMPLE:
+ return new IF_ICMPLE(target);
+ case Constants.IF_ACMPEQ:
+ return new IF_ACMPEQ(target);
+ case Constants.IF_ACMPNE:
+ return new IF_ACMPNE(target);
+ case Constants.GOTO:
+ return new GOTO(target);
+ case Constants.JSR:
+ return new JSR(target);
+ case Constants.IFNULL:
+ return new IFNULL(target);
+ case Constants.IFNONNULL:
+ return new IFNONNULL(target);
+ case Constants.GOTO_W:
+ return new GOTO_W(target);
+ case Constants.JSR_W:
+ return new JSR_W(target);
+ default:
+ throw new RuntimeException("Invalid opcode: " + opcode);
+ }
+ }
+ public void setClassGen(ClassGen c) {
+ cg = c;
+ }
- public GETSTATIC createGetStatic( String class_name, String name, Type t ) {
- return new GETSTATIC(cp.addFieldref(class_name, name, t.getSignature()));
- }
+ public ClassGen getClassGen() {
+ return cg;
+ }
+ public void setConstantPool(ConstantPoolGen c) {
+ cp = c;
+ }
- public PUTFIELD createPutField( String class_name, String name, Type t ) {
- return new PUTFIELD(cp.addFieldref(class_name, name, t.getSignature()));
- }
-
-
- public PUTSTATIC createPutStatic( String class_name, String name, Type t ) {
- return new PUTSTATIC(cp.addFieldref(class_name, name, t.getSignature()));
- }
-
-
- public CHECKCAST createCheckCast( ReferenceType t ) {
- if (t instanceof ArrayType) {
- return new CHECKCAST(cp.addArrayClass((ArrayType) t));
- } else {
- return new CHECKCAST(cp.addClass((ObjectType) t));
- }
- }
-
-
- public INSTANCEOF createInstanceOf( ReferenceType t ) {
- if (t instanceof ArrayType) {
- return new INSTANCEOF(cp.addArrayClass((ArrayType) t));
- } else {
- return new INSTANCEOF(cp.addClass((ObjectType) t));
- }
- }
-
-
- public NEW createNew( ObjectType t ) {
- return new NEW(cp.addClass(t));
- }
-
-
- public NEW createNew( String s ) {
- return createNew(new ObjectType(s));
- }
-
-
- /** Create new array of given size and type.
- * @return an instruction that creates the corresponding array at runtime, i.e. is an AllocationInstruction
- */
- public Instruction createNewArray( Type t, short dim ) {
- if (dim == 1) {
- if (t instanceof ObjectType) {
- return new ANEWARRAY(cp.addClass((ObjectType) t));
- } else if (t instanceof ArrayType) {
- return new ANEWARRAY(cp.addArrayClass((ArrayType) t));
- } else {
- return new NEWARRAY(((BasicType) t).getType());
- }
- } else {
- ArrayType at;
- if (t instanceof ArrayType) {
- at = (ArrayType) t;
- } else {
- at = new ArrayType(t, dim);
- }
- return new MULTIANEWARRAY(cp.addArrayClass(at), dim);
- }
- }
-
-
- /** Create "null" value for reference types, 0 for basic types like int
- */
- public static Instruction createNull( Type type ) {
- switch (type.getType()) {
- case Constants.T_ARRAY:
- case Constants.T_OBJECT:
- return ACONST_NULL;
- case Constants.T_INT:
- case Constants.T_SHORT:
- case Constants.T_BOOLEAN:
- case Constants.T_CHAR:
- case Constants.T_BYTE:
- return ICONST_0;
- case Constants.T_FLOAT:
- return FCONST_0;
- case Constants.T_DOUBLE:
- return DCONST_0;
- case Constants.T_LONG:
- return LCONST_0;
- case Constants.T_VOID:
- return NOP;
- default:
- throw new RuntimeException("Invalid type: " + type);
- }
- }
-
-
- /** Create branch instruction by given opcode, except LOOKUPSWITCH and TABLESWITCH.
- * For those you should use the SWITCH compound instruction.
- */
- public static BranchInstruction createBranchInstruction( short opcode, InstructionHandle target ) {
- switch (opcode) {
- case Constants.IFEQ:
- return new IFEQ(target);
- case Constants.IFNE:
- return new IFNE(target);
- case Constants.IFLT:
- return new IFLT(target);
- case Constants.IFGE:
- return new IFGE(target);
- case Constants.IFGT:
- return new IFGT(target);
- case Constants.IFLE:
- return new IFLE(target);
- case Constants.IF_ICMPEQ:
- return new IF_ICMPEQ(target);
- case Constants.IF_ICMPNE:
- return new IF_ICMPNE(target);
- case Constants.IF_ICMPLT:
- return new IF_ICMPLT(target);
- case Constants.IF_ICMPGE:
- return new IF_ICMPGE(target);
- case Constants.IF_ICMPGT:
- return new IF_ICMPGT(target);
- case Constants.IF_ICMPLE:
- return new IF_ICMPLE(target);
- case Constants.IF_ACMPEQ:
- return new IF_ACMPEQ(target);
- case Constants.IF_ACMPNE:
- return new IF_ACMPNE(target);
- case Constants.GOTO:
- return new GOTO(target);
- case Constants.JSR:
- return new JSR(target);
- case Constants.IFNULL:
- return new IFNULL(target);
- case Constants.IFNONNULL:
- return new IFNONNULL(target);
- case Constants.GOTO_W:
- return new GOTO_W(target);
- case Constants.JSR_W:
- return new JSR_W(target);
- default:
- throw new RuntimeException("Invalid opcode: " + opcode);
- }
- }
-
-
- public void setClassGen( ClassGen c ) {
- cg = c;
- }
-
-
- public ClassGen getClassGen() {
- return cg;
- }
-
-
- public void setConstantPool( ConstantPoolGen c ) {
- cp = c;
- }
-
-
- public ConstantPoolGen getConstantPool() {
- return cp;
- }
+ public ConstantPoolGen getConstantPool() {
+ return cp;
+ }
}
diff --git a/src/org/apache/bcel/generic/InstructionHandle.java b/src/org/apache/bcel/generic/InstructionHandle.java
index 176b76f..5129d00 100644
--- a/src/org/apache/bcel/generic/InstructionHandle.java
+++ b/src/org/apache/bcel/generic/InstructionHandle.java
@@ -21,270 +21,276 @@ import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
+
import org.apache.bcel.classfile.Utility;
/**
* Instances of this class give users a handle to the instructions contained in
* an InstructionList. Instruction objects may be used more than once within a
* list, this is useful because it saves memory and may be much faster.
- *
- * Within an InstructionList an InstructionHandle object is wrapped
- * around all instructions, i.e., it implements a cell in a
- * doubly-linked list. From the outside only the next and the
- * previous instruction (handle) are accessible. One
- * can traverse the list via an Enumeration returned by
+ *
+ * Within an InstructionList an InstructionHandle object is wrapped around all
+ * instructions, i.e., it implements a cell in a doubly-linked list. From the
+ * outside only the next and the previous instruction (handle) are accessible.
+ * One can traverse the list via an Enumeration returned by
* InstructionList.elements().
- *
+ *
* @version $Id: InstructionHandle.java 386056 2006-03-15 11:31:56Z tcurdt $
- * @author M. Dahm
+ * @author M. Dahm
* @see Instruction
* @see BranchHandle
- * @see InstructionList
+ * @see InstructionList
*/
public class InstructionHandle implements java.io.Serializable {
- InstructionHandle next, prev; // Will be set from the outside
- Instruction instruction;
- protected int i_position = -1; // byte code offset of instruction
- private Set targeters;
- private Map attributes;
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ InstructionHandle next, prev; // Will be set from the outside
+ Instruction instruction;
+ protected int i_position = -1; // byte code offset of instruction
+ private Set targeters;
+ private Map attributes;
+ public final InstructionHandle getNext() {
+ return next;
+ }
- public final InstructionHandle getNext() {
- return next;
- }
+ public final InstructionHandle getPrev() {
+ return prev;
+ }
+ public final Instruction getInstruction() {
+ return instruction;
+ }
- public final InstructionHandle getPrev() {
- return prev;
- }
+ /**
+ * Replace current instruction contained in this handle. Old instruction is
+ * disposed using Instruction.dispose().
+ */
+ public void setInstruction(Instruction i) { // Overridden in BranchHandle
+ if (i == null) {
+ throw new ClassGenException("Assigning null to handle");
+ }
+ if ((this.getClass() != BranchHandle.class)
+ && (i instanceof BranchInstruction)) {
+ throw new ClassGenException("Assigning branch instruction " + i
+ + " to plain handle");
+ }
+ if (instruction != null) {
+ instruction.dispose();
+ }
+ instruction = i;
+ }
+ /**
+ * Temporarily swap the current instruction, without disturbing anything.
+ * Meant to be used by a debugger, implementing breakpoints. Current
+ * instruction is returned.
+ */
+ public Instruction swapInstruction(Instruction i) {
+ Instruction oldInstruction = instruction;
+ instruction = i;
+ return oldInstruction;
+ }
- public final Instruction getInstruction() {
- return instruction;
- }
+ /* private */protected InstructionHandle(Instruction i) {
+ setInstruction(i);
+ }
+ private static InstructionHandle ih_list = null; // List of reusable handles
- /**
- * Replace current instruction contained in this handle.
- * Old instruction is disposed using Instruction.dispose().
- */
- public void setInstruction( Instruction i ) { // Overridden in BranchHandle
- if (i == null) {
- throw new ClassGenException("Assigning null to handle");
- }
- if ((this.getClass() != BranchHandle.class) && (i instanceof BranchInstruction)) {
- throw new ClassGenException("Assigning branch instruction " + i + " to plain handle");
- }
- if (instruction != null) {
- instruction.dispose();
- }
- instruction = i;
- }
+ /**
+ * Factory method.
+ */
+ static final InstructionHandle getInstructionHandle(Instruction i) {
+ if (ih_list == null) {
+ return new InstructionHandle(i);
+ } else {
+ InstructionHandle ih = ih_list;
+ ih_list = ih.next;
+ ih.setInstruction(i);
+ return ih;
+ }
+ }
+ /**
+ * 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) {
+ i_position += offset;
+ return 0;
+ }
- /**
- * Temporarily swap the current instruction, without disturbing
- * anything. Meant to be used by a debugger, implementing
- * breakpoints. Current instruction is returned.
- */
- public Instruction swapInstruction( Instruction i ) {
- Instruction oldInstruction = instruction;
- instruction = i;
- return oldInstruction;
- }
+ /**
+ * @return the position, i.e., the byte code offset of the contained
+ * instruction. This is accurate only after
+ * InstructionList.setPositions() has been called.
+ */
+ public int getPosition() {
+ return i_position;
+ }
+ /**
+ * Set the position, i.e., the byte code offset of the contained
+ * instruction.
+ */
+ void setPosition(int pos) {
+ i_position = pos;
+ }
- /*private*/protected InstructionHandle(Instruction i) {
- setInstruction(i);
- }
+ /**
+ * Overridden in BranchHandle
+ */
+ protected void addHandle() {
+ next = ih_list;
+ ih_list = this;
+ }
- private static InstructionHandle ih_list = null; // List of reusable handles
+ /**
+ * Delete contents, i.e., remove user access and make handle reusable.
+ */
+ void dispose() {
+ next = prev = null;
+ instruction.dispose();
+ instruction = null;
+ i_position = -1;
+ attributes = null;
+ removeAllTargeters();
+ addHandle();
+ }
+ /**
+ * Remove all targeters, if any.
+ */
+ public void removeAllTargeters() {
+ if (targeters != null) {
+ targeters.clear();
+ }
+ }
- /** Factory method.
- */
- static final InstructionHandle getInstructionHandle( Instruction i ) {
- if (ih_list == null) {
- return new InstructionHandle(i);
- } else {
- InstructionHandle ih = ih_list;
- ih_list = ih.next;
- ih.setInstruction(i);
- return ih;
- }
- }
+ /**
+ * Denote this handle isn't referenced anymore by t.
+ */
+ public void removeTargeter(InstructionTargeter t) {
+ if (targeters != null) {
+ targeters.remove(t);
+ }
+ }
+ /**
+ * Denote this handle is being referenced by t.
+ */
+ public void addTargeter(InstructionTargeter t) {
+ if (targeters == null) {
+ targeters = new HashSet();
+ }
+ // if(!targeters.contains(t))
+ targeters.add(t);
+ }
- /**
- * 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 ) {
- i_position += offset;
- return 0;
- }
+ public boolean hasTargeters() {
+ return (targeters != null) && (targeters.size() > 0);
+ }
+ /**
+ * @return null, if there are no targeters
+ */
+ public InstructionTargeter[] getTargeters() {
+ if (!hasTargeters()) {
+ return null;
+ }
+ InstructionTargeter[] t = new InstructionTargeter[targeters.size()];
+ targeters.toArray(t);
+ return t;
+ }
- /** @return the position, i.e., the byte code offset of the contained
- * instruction. This is accurate only after
- * InstructionList.setPositions() has been called.
- */
- public int getPosition() {
- return i_position;
- }
+ /**
+ * @return a (verbose) string representation of the contained instruction.
+ */
+ public String toString(boolean verbose) {
+ return Utility.format(i_position, 4, false, ' ') + ": "
+ + instruction.toString(verbose);
+ }
+ /**
+ * @return a string representation of the contained instruction.
+ */
+ @Override
+ public String toString() {
+ return toString(true);
+ }
- /** Set the position, i.e., the byte code offset of the contained
- * instruction.
- */
- void setPosition( int pos ) {
- i_position = pos;
- }
+ /**
+ * Add an attribute to an instruction handle.
+ *
+ * @param key
+ * the key object to store/retrieve the attribute
+ * @param attr
+ * the attribute to associate with this handle
+ */
+ public void addAttribute(Object key, Object attr) {
+ if (attributes == null) {
+ attributes = new HashMap(3);
+ }
+ attributes.put(key, attr);
+ }
+ /**
+ * Delete an attribute of an instruction handle.
+ *
+ * @param key
+ * the key object to retrieve the attribute
+ */
+ public void removeAttribute(Object key) {
+ if (attributes != null) {
+ attributes.remove(key);
+ }
+ }
- /** Overridden in BranchHandle
- */
- protected void addHandle() {
- next = ih_list;
- ih_list = this;
- }
+ /**
+ * Get attribute of an instruction handle.
+ *
+ * @param key
+ * the key object to store/retrieve the attribute
+ */
+ public Object getAttribute(Object key) {
+ if (attributes != null) {
+ return attributes.get(key);
+ }
+ return null;
+ }
+ /**
+ * @return all attributes associated with this handle
+ */
+ public Collection