mdahm 2002/08/07 11:01:32
Modified: src/java/org/apache/bcel/generic BIPUSH.java BREAKPOINT.java
DCONST.java FCONST.java ICONST.java
Instruction.java JsrInstruction.java LCONST.java
LocalVariableInstruction.java NEWARRAY.java
ReferenceType.java SIPUSH.java Type.java
Added: src/java/org/apache/bcel/generic InstructionComparator.java
Log:
equals() method for instructions, semantics may be customized
Revision Changes Path
1.2 +1 -2 jakarta-bcel/src/java/org/apache/bcel/generic/BIPUSH.java
Index: BIPUSH.java
===================================================================
RCS file: /home/cvs/jakarta-bcel/src/java/org/apache/bcel/generic/BIPUSH.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- BIPUSH.java 29 Oct 2001 20:00:06 -0000 1.1
+++ BIPUSH.java 7 Aug 2002 18:01:32 -0000 1.2
@@ -113,7 +113,6 @@
return Type.BYTE;
}
-
/**
* Call corresponding visitor method(s). The order is:
* Call visitor methods of implemented interfaces first, then
1.2 +3 -4 jakarta-bcel/src/java/org/apache/bcel/generic/BREAKPOINT.java
Index: BREAKPOINT.java
===================================================================
RCS file: /home/cvs/jakarta-bcel/src/java/org/apache/bcel/generic/BREAKPOINT.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- BREAKPOINT.java 29 Oct 2001 20:00:06 -0000 1.1
+++ BREAKPOINT.java 7 Aug 2002 18:01:32 -0000 1.2
@@ -55,16 +55,15 @@
*/
/**
- * BREAKPOINT
+ * BREAKPOINT, JVM dependent, ignored by default
*
* @version $Id$
- * @author Enver Haase
+ * @author <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>
*/
public class BREAKPOINT extends Instruction {
public BREAKPOINT() {
super(org.apache.bcel.Constants.BREAKPOINT, (short)1);
}
-
/**
* Call corresponding visitor method(s). The order is:
1.3 +1 -2 jakarta-bcel/src/java/org/apache/bcel/generic/DCONST.java
Index: DCONST.java
===================================================================
RCS file: /home/cvs/jakarta-bcel/src/java/org/apache/bcel/generic/DCONST.java,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- DCONST.java 11 Mar 2002 17:19:49 -0000 1.2
+++ DCONST.java 7 Aug 2002 18:01:32 -0000 1.3
@@ -93,7 +93,6 @@
return Type.DOUBLE;
}
-
/**
* Call corresponding visitor method(s). The order is:
* Call visitor methods of implemented interfaces first, then
1.3 +1 -2 jakarta-bcel/src/java/org/apache/bcel/generic/FCONST.java
Index: FCONST.java
===================================================================
RCS file: /home/cvs/jakarta-bcel/src/java/org/apache/bcel/generic/FCONST.java,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- FCONST.java 11 Mar 2002 17:19:49 -0000 1.2
+++ FCONST.java 7 Aug 2002 18:01:32 -0000 1.3
@@ -95,7 +95,6 @@
return Type.FLOAT;
}
-
/**
* Call corresponding visitor method(s). The order is:
* Call visitor methods of implemented interfaces first, then
1.3 +1 -2 jakarta-bcel/src/java/org/apache/bcel/generic/ICONST.java
Index: ICONST.java
===================================================================
RCS file: /home/cvs/jakarta-bcel/src/java/org/apache/bcel/generic/ICONST.java,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- ICONST.java 11 Mar 2002 17:19:49 -0000 1.2
+++ ICONST.java 7 Aug 2002 18:01:32 -0000 1.3
@@ -91,7 +91,6 @@
return Type.INT;
}
-
/**
* Call corresponding visitor method(s). The order is:
* Call visitor methods of implemented interfaces first, then
1.3 +23 -2 jakarta-bcel/src/java/org/apache/bcel/generic/Instruction.java
Index: Instruction.java
===================================================================
RCS file: /home/cvs/jakarta-bcel/src/java/org/apache/bcel/generic/Instruction.java,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- Instruction.java 12 Mar 2002 09:24:01 -0000 1.2
+++ Instruction.java 7 Aug 2002 18:01:32 -0000 1.3
@@ -70,6 +70,8 @@
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.
@@ -270,7 +272,7 @@
/** Some instructions may be reused, so don't do anything by default.
*/
- void dispose() { }
+ void dispose() {}
/**
* Call corresponding visitor method(s). The order is:
@@ -281,4 +283,23 @@
* @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;
+ }
}
1.2 +13 -14 jakarta-bcel/src/java/org/apache/bcel/generic/JsrInstruction.java
Index: JsrInstruction.java
===================================================================
RCS file: /home/cvs/jakarta-bcel/src/java/org/apache/bcel/generic/JsrInstruction.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- JsrInstruction.java 29 Oct 2001 20:00:20 -0000 1.1
+++ JsrInstruction.java 7 Aug 2002 18:01:32 -0000 1.2
@@ -79,21 +79,20 @@
return new ReturnaddressType(physicalSuccessor());
}
-
- /**
- * Returns an InstructionHandle to the physical successor
- * of this JsrInstruction. <B>For this method to work,
- * this JsrInstruction object must not be shared between
- * multiple InstructionHandle objects!</B>
- * Formally, there must not be InstructionHandle objects
- * i, j where i != j and i.getInstruction() == this ==
- * j.getInstruction().
- * @return an InstructionHandle to the "next" instruction that
- * will be executed when RETurned from a subroutine.
- */
+ /**
+ * Returns an InstructionHandle to the physical successor
+ * of this JsrInstruction. <B>For this method to work,
+ * this JsrInstruction object must not be shared between
+ * multiple InstructionHandle objects!</B>
+ * Formally, there must not be InstructionHandle objects
+ * i, j where i != j and i.getInstruction() == this ==
+ * j.getInstruction().
+ * @return an InstructionHandle to the "next" instruction that
+ * will be executed when RETurned from a subroutine.
+ */
public InstructionHandle physicalSuccessor(){
InstructionHandle ih = this.target;
-
+
// Rewind!
while(ih.getPrev() != null)
ih = ih.getPrev();
1.3 +1 -2 jakarta-bcel/src/java/org/apache/bcel/generic/LCONST.java
Index: LCONST.java
===================================================================
RCS file: /home/cvs/jakarta-bcel/src/java/org/apache/bcel/generic/LCONST.java,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- LCONST.java 11 Mar 2002 17:19:49 -0000 1.2
+++ LCONST.java 7 Aug 2002 18:01:32 -0000 1.3
@@ -93,7 +93,6 @@
return Type.LONG;
}
-
/**
* Call corresponding visitor method(s). The order is:
* Call visitor methods of implemented interfaces first, then
1.2 +1 -2 jakarta-bcel/src/java/org/apache/bcel/generic/LocalVariableInstruction.java
Index: LocalVariableInstruction.java
===================================================================
RCS file: /home/cvs/jakarta-bcel/src/java/org/apache/bcel/generic/LocalVariableInstruction.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- LocalVariableInstruction.java 29 Oct 2001 20:00:23 -0000 1.1
+++ LocalVariableInstruction.java 7 Aug 2002 18:01:32 -0000 1.2
@@ -224,4 +224,3 @@
}
}
}
-
1.2 +1 -2 jakarta-bcel/src/java/org/apache/bcel/generic/NEWARRAY.java
Index: NEWARRAY.java
===================================================================
RCS file: /home/cvs/jakarta-bcel/src/java/org/apache/bcel/generic/NEWARRAY.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- NEWARRAY.java 29 Oct 2001 20:00:25 -0000 1.1
+++ NEWARRAY.java 7 Aug 2002 18:01:32 -0000 1.2
@@ -123,7 +123,6 @@
return new Class[] { org.apache.bcel.ExceptionConstants.NEGATIVE_ARRAY_SIZE_EXCEPTION
};
}
-
/**
* Call corresponding visitor method(s). The order is:
* Call visitor methods of implemented interfaces first, then
1.5 +267 -267 jakarta-bcel/src/java/org/apache/bcel/generic/ReferenceType.java
Index: ReferenceType.java
===================================================================
RCS file: /home/cvs/jakarta-bcel/src/java/org/apache/bcel/generic/ReferenceType.java,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- ReferenceType.java 2 Aug 2002 11:57:51 -0000 1.4
+++ ReferenceType.java 7 Aug 2002 18:01:32 -0000 1.5
@@ -59,291 +59,291 @@
import org.apache.bcel.classfile.JavaClass;
/**
- * Super class for objects and arrays.
+ * Super class for object and array types.
*
* @version $Id$
* @author <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>
*/
-public class ReferenceType extends Type {
- protected ReferenceType(byte t, String s) {
- super(t, s);
- }
+public abstract class ReferenceType extends Type {
+ protected ReferenceType(byte t, String s) {
+ super(t, s);
+ }
+
+ /** Class is non-abstract but not instantiable from the outside
+ */
+ ReferenceType() {
+ super(Constants.T_OBJECT, "<null object>");
+ }
+
+ /**
+ * Return true iff this type is castable to another type t as defined in
+ * the JVM specification. The case where this is Type.NULL is not
+ * defined (see the CHECKCAST definition in the JVM specification).
+ * However, because e.g. CHECKCAST doesn't throw a
+ * ClassCastException when casting a null reference to any Object,
+ * true is returned in this case.
+ */
+ public boolean isCastableTo(Type t) {
+ if (this.equals(Type.NULL))
+ return true; // If this is ever changed in isAssignmentCompatible()
+
+ return isAssignmentCompatibleWith(t);
+ /* Yes, it's true: It's the same definition.
+ * See vmspec2 AASTORE / CHECKCAST definitions.
+ */
+ }
+
+ /**
+ * Return true iff this is assignment compatible with another type t
+ * as defined in the JVM specification; see the AASTORE definition
+ * there.
+ */
+ public boolean isAssignmentCompatibleWith(Type t) {
+ if (!(t instanceof ReferenceType))
+ return false;
+
+ ReferenceType T = (ReferenceType) t;
- /** Class is non-abstract but not instantiable from the outside
+ if (this.equals(Type.NULL))
+ return true; // This is not explicitely stated, but clear. Isn't it?
+
+ /* If this is a class type then
*/
- ReferenceType() {
- super(Constants.T_OBJECT, "<null object>");
+ if ((this instanceof ObjectType) && (((ObjectType) this).referencesClass()))
{
+ /* If T is a class type, then this must be the same class as T,
+ or this must be a subclass of T;
+ */
+ if ((T instanceof ObjectType) && (((ObjectType) T).referencesClass())) {
+ if (this.equals(T))
+ return true;
+
+ if (Repository.instanceOf(((ObjectType) this).getClassName(),
+ ((ObjectType) T).getClassName()))
+ return true;
+ }
+
+ /* If T is an interface type, this must implement interface T.
+ */
+ if ((T instanceof ObjectType) && (((ObjectType) T).referencesInterface()))
{
+ if (Repository.implementationOf(((ObjectType) this).getClassName(),
+ ((ObjectType) T).getClassName()))
+ return true;
+ }
}
- /**
- * Return true iff this type is castable to another type t as defined in
- * the JVM specification. The case where this is Type.NULL is not
- * defined (see the CHECKCAST definition in the JVM specification).
- * However, because e.g. CHECKCAST doesn't throw a
- * ClassCastException when casting a null reference to any Object,
- * true is returned in this case.
+ /* If this is an interface type, then:
*/
- public boolean isCastableTo(Type t) {
- if (this.equals(Type.NULL))
- return true; // If this is ever changed in isAssignmentCompatible()
-
- return isAssignmentCompatibleWith(t);
- /* Yes, it's true: It's the same definition.
- * See vmspec2 AASTORE / CHECKCAST definitions.
- */
+ if ((this instanceof ObjectType) && (((ObjectType) this).referencesInterface()))
{
+ /* If T is a class type, then T must be Object (§2.4.7).
+ */
+ if ((T instanceof ObjectType) && (((ObjectType) T).referencesClass())) {
+ if (T.equals(Type.OBJECT)) return true;
+ }
+
+ /* If T is an interface type, then T must be the same interface
+ * as this or a superinterface of this (§2.13.2).
+ */
+ if ((T instanceof ObjectType) && (((ObjectType) T).referencesInterface()))
{
+ if (this.equals(T)) return true;
+ if (Repository.implementationOf(((ObjectType) this).getClassName(),
+ ((ObjectType) T).getClassName()))
+ return true;
+ }
}
- /**
- * Return true iff this is assignment compatible with another type t
- * as defined in the JVM specification; see the AASTORE definition
- * there.
+ /* If this is an array type, namely, the type SC[], that is, an
+ * array of components of type SC, then:
*/
- public boolean isAssignmentCompatibleWith(Type t) {
- if (!(t instanceof ReferenceType))
- return false;
-
- ReferenceType T = (ReferenceType) t;
-
- if (this.equals(Type.NULL))
- return true; // This is not explicitely stated, but clear. Isn't it?
-
- /* If this is a class type then
- */
- if ((this instanceof ObjectType) && (((ObjectType) this).referencesClass()))
{
- /* If T is a class type, then this must be the same class as T,
- or this must be a subclass of T;
- */
- if ((T instanceof ObjectType) && (((ObjectType) T).referencesClass()))
{
- if (this.equals(T))
- return true;
-
- if (Repository.instanceOf(((ObjectType) this).getClassName(),
- ((ObjectType) T).getClassName()))
- return true;
- }
-
- /* If T is an interface type, this must implement interface T.
- */
- if ((T instanceof ObjectType) && (((ObjectType) T).referencesInterface()))
{
- if (Repository.implementationOf(((ObjectType) this).getClassName(),
- ((ObjectType) T).getClassName()))
- return true;
- }
- }
-
- /* If this is an interface type, then:
- */
- if ((this instanceof ObjectType) && (((ObjectType) this).referencesInterface()))
{
- /* If T is a class type, then T must be Object (§2.4.7).
- */
- if ((T instanceof ObjectType) && (((ObjectType) T).referencesClass()))
{
- if (T.equals(Type.OBJECT)) return true;
- }
-
- /* If T is an interface type, then T must be the same interface
- * as this or a superinterface of this (§2.13.2).
- */
- if ((T instanceof ObjectType) && (((ObjectType) T).referencesInterface()))
{
- if (this.equals(T)) return true;
- if (Repository.implementationOf(((ObjectType) this).getClassName(),
- ((ObjectType) T).getClassName()))
- return true;
- }
- }
-
- /* If this is an array type, namely, the type SC[], that is, an
- * array of components of type SC, then:
- */
- if (this instanceof ArrayType) {
- /* If T is a class type, then T must be Object (§2.4.7).
- */
- if ((T instanceof ObjectType) && (((ObjectType) T).referencesClass()))
{
- if (T.equals(Type.OBJECT)) return true;
- }
-
- /* If T is an array type TC[], that is, an array of components
- * of type TC, then one of the following must be true:
- */
- if (T instanceof ArrayType) {
- /* TC and SC are the same primitive type (§2.4.1).
- */
- Type sc = ((ArrayType) this).getElementType();
- Type tc = ((ArrayType) this).getElementType();
-
- if (sc instanceof BasicType && tc instanceof BasicType &&
sc.equals(tc))
- return true;
-
- /* TC and SC are reference types (§2.4.6), and type SC is
- * assignable to TC by these runtime rules.
- */
- if (tc instanceof ReferenceType && sc instanceof ReferenceType
&&
- ((ReferenceType) sc).isAssignmentCompatibleWith((ReferenceType)
tc))
- return true;
- }
-
- /* If T is an interface type, T must be one of the interfaces implemented by
arrays (§2.15). */
- // TODO: Check if this is still valid or find a way to dynamically find out
which
- // interfaces arrays implement. However, as of the JVM specification edition
2, there
- // are at least two different pages where assignment compatibility is defined
and
- // on one of them "interfaces implemented by arrays" is exchanged with "'Cloneable'
or
- // 'java.io.Serializable'"
- if ((T instanceof ObjectType) && (((ObjectType) T).referencesInterface()))
{
- for (int ii = 0; ii < Constants.INTERFACES_IMPLEMENTED_BY_ARRAYS.length;
ii++) {
- if (T.equals(new ObjectType(Constants.INTERFACES_IMPLEMENTED_BY_ARRAYS[ii])))
return true;
- }
- }
- }
- return false; // default.
+ if (this instanceof ArrayType) {
+ /* If T is a class type, then T must be Object (§2.4.7).
+ */
+ if ((T instanceof ObjectType) && (((ObjectType) T).referencesClass())) {
+ if (T.equals(Type.OBJECT)) return true;
+ }
+
+ /* If T is an array type TC[], that is, an array of components
+ * of type TC, then one of the following must be true:
+ */
+ if (T instanceof ArrayType) {
+ /* TC and SC are the same primitive type (§2.4.1).
+ */
+ Type sc = ((ArrayType) this).getElementType();
+ Type tc = ((ArrayType) this).getElementType();
+
+ if (sc instanceof BasicType && tc instanceof BasicType && sc.equals(tc))
+ return true;
+
+ /* TC and SC are reference types (§2.4.6), and type SC is
+ * assignable to TC by these runtime rules.
+ */
+ if (tc instanceof ReferenceType && sc instanceof ReferenceType &&
+ ((ReferenceType) sc).isAssignmentCompatibleWith((ReferenceType) tc))
+ return true;
+ }
+
+ /* If T is an interface type, T must be one of the interfaces implemented by arrays
(§2.15). */
+ // TODO: Check if this is still valid or find a way to dynamically find out which
+ // interfaces arrays implement. However, as of the JVM specification edition 2, there
+ // are at least two different pages where assignment compatibility is defined and
+ // on one of them "interfaces implemented by arrays" is exchanged with "'Cloneable'
or
+ // 'java.io.Serializable'"
+ if ((T instanceof ObjectType) && (((ObjectType) T).referencesInterface()))
{
+ for (int ii = 0; ii < Constants.INTERFACES_IMPLEMENTED_BY_ARRAYS.length; ii++) {
+ if (T.equals(new ObjectType(Constants.INTERFACES_IMPLEMENTED_BY_ARRAYS[ii]))) return
true;
+ }
+ }
}
+ return false; // default.
+ }
- /**
- * This commutative operation returns the first common superclass (narrowest ReferenceType
- * referencing a class, not an interface).
- * If one of the types is a superclass of the other, the former is returned.
- * If "this" is Type.NULL, then t is returned.
- * If t is Type.NULL, then "this" is returned.
- * If "this" equals t ['this.equals(t)'] "this" is returned.
- * If "this" or t is an ArrayType, then Type.OBJECT is returned;
- * unless their dimensions match. Then an ArrayType of the same
- * number of dimensions is returned, with its basic type being the
- * first common super class of the basic types of "this" and t.
- * If "this" or t is a ReferenceType referencing an interface, then Type.OBJECT is
returned.
- * If not all of the two classes' superclasses cannot be found, "null" is returned.
- * See the JVM specification edition 2, "§4.9.2 The Bytecode Verifier".
+ /**
+ * This commutative operation returns the first common superclass (narrowest ReferenceType
+ * referencing a class, not an interface).
+ * If one of the types is a superclass of the other, the former is returned.
+ * If "this" is Type.NULL, then t is returned.
+ * If t is Type.NULL, then "this" is returned.
+ * If "this" equals t ['this.equals(t)'] "this" is returned.
+ * If "this" or t is an ArrayType, then Type.OBJECT is returned;
+ * unless their dimensions match. Then an ArrayType of the same
+ * number of dimensions is returned, with its basic type being the
+ * first common super class of the basic types of "this" and t.
+ * If "this" or t is a ReferenceType referencing an interface, then Type.OBJECT is returned.
+ * If not all of the two classes' superclasses cannot be found, "null" is returned.
+ * See the JVM specification edition 2, "§4.9.2 The Bytecode Verifier".
+ */
+ public ReferenceType getFirstCommonSuperclass(ReferenceType t) {
+ if (this.equals(Type.NULL)) return t;
+ if (t.equals(Type.NULL)) return this;
+ if (this.equals(t)) return this;
+ /*
+ * TODO: Above sounds a little arbitrary. On the other hand, there is
+ * no object referenced by Type.NULL so we can also say all the objects
+ * referenced by Type.NULL were derived from java.lang.Object.
+ * However, the Java Language's "instanceof" operator proves us wrong:
+ * "null" is not referring to an instance of java.lang.Object :)
*/
- public ReferenceType getFirstCommonSuperclass(ReferenceType t) {
- if (this.equals(Type.NULL)) return t;
- if (t.equals(Type.NULL)) return this;
- if (this.equals(t)) return this;
- /*
- * TODO: Above sounds a little arbitrary. On the other hand, there is
- * no object referenced by Type.NULL so we can also say all the objects
- * referenced by Type.NULL were derived from java.lang.Object.
- * However, the Java Language's "instanceof" operator proves us wrong:
- * "null" is not referring to an instance of java.lang.Object :)
- */
-
- /* This code is from a bug report by Konstantin Shagin <konst@cs.technion.ac.il>
*/
-
- if ((this instanceof ArrayType) && (t instanceof ArrayType)) {
- ArrayType arrType1 = (ArrayType) this;
- ArrayType arrType2 = (ArrayType) t;
- if (
- (arrType1.getDimensions() == arrType2.getDimensions()) &&
- arrType1.getBasicType() instanceof ObjectType &&
- arrType2.getBasicType() instanceof ObjectType) {
- return new ArrayType(
- ((ObjectType) arrType1.getBasicType()).getFirstCommonSuperclass((ObjectType)
arrType2.getBasicType()),
- arrType1.getDimensions()
- );
-
- }
- }
-
- if ((this instanceof ArrayType) || (t instanceof ArrayType))
- return Type.OBJECT;
- // TODO: Is there a proof of OBJECT being the direct ancestor of every ArrayType?
-
- if (((this instanceof ObjectType) && ((ObjectType) this).referencesInterface())
||
- ((t instanceof ObjectType) && ((ObjectType) t).referencesInterface()))
- return Type.OBJECT;
- // TODO: The above line is correct comparing to the vmspec2. But one could
- // make class file verification a bit stronger here by using the notion of
- // superinterfaces or even castability or assignment compatibility.
-
-
- // this and t are ObjectTypes, see above.
- ObjectType thiz = (ObjectType) this;
- ObjectType other = (ObjectType) t;
- JavaClass[] thiz_sups = Repository.getSuperClasses(thiz.getClassName());
- JavaClass[] other_sups = Repository.getSuperClasses(other.getClassName());
-
- if ((thiz_sups == null) || (other_sups == null)) {
- return null;
- }
-
- // Waaahh...
- JavaClass[] this_sups = new JavaClass[thiz_sups.length + 1];
- JavaClass[] t_sups = new JavaClass[other_sups.length + 1];
- System.arraycopy(thiz_sups, 0, this_sups, 1, thiz_sups.length);
- System.arraycopy(other_sups, 0, t_sups, 1, other_sups.length);
- this_sups[0] = Repository.lookupClass(thiz.getClassName());
- t_sups[0] = Repository.lookupClass(other.getClassName());
-
- for (int i = 0; i < t_sups.length; i++) {
- for (int j = 0; j < this_sups.length; j++) {
- if (this_sups[j].equals(t_sups[i])) return new ObjectType(this_sups[j].getClassName());
- }
- }
- // Huh? Did you ask for Type.OBJECT's superclass??
- return null;
+ /* This code is from a bug report by Konstantin Shagin <konst@cs.technion.ac.il>
*/
+
+ if ((this instanceof ArrayType) && (t instanceof ArrayType)) {
+ ArrayType arrType1 = (ArrayType) this;
+ ArrayType arrType2 = (ArrayType) t;
+ if (
+ (arrType1.getDimensions() == arrType2.getDimensions()) &&
+ arrType1.getBasicType() instanceof ObjectType &&
+ arrType2.getBasicType() instanceof ObjectType) {
+ return new ArrayType(
+ ((ObjectType) arrType1.getBasicType()).getFirstCommonSuperclass((ObjectType) arrType2.getBasicType()),
+ arrType1.getDimensions()
+ );
+
+ }
+ }
+
+ if ((this instanceof ArrayType) || (t instanceof ArrayType))
+ return Type.OBJECT;
+ // TODO: Is there a proof of OBJECT being the direct ancestor of every ArrayType?
+
+ if (((this instanceof ObjectType) && ((ObjectType) this).referencesInterface())
||
+ ((t instanceof ObjectType) && ((ObjectType) t).referencesInterface()))
+ return Type.OBJECT;
+ // TODO: The above line is correct comparing to the vmspec2. But one could
+ // make class file verification a bit stronger here by using the notion of
+ // superinterfaces or even castability or assignment compatibility.
+
+
+ // this and t are ObjectTypes, see above.
+ ObjectType thiz = (ObjectType) this;
+ ObjectType other = (ObjectType) t;
+ JavaClass[] thiz_sups = Repository.getSuperClasses(thiz.getClassName());
+ JavaClass[] other_sups = Repository.getSuperClasses(other.getClassName());
+
+ if ((thiz_sups == null) || (other_sups == null)) {
+ return null;
+ }
+
+ // Waaahh...
+ JavaClass[] this_sups = new JavaClass[thiz_sups.length + 1];
+ JavaClass[] t_sups = new JavaClass[other_sups.length + 1];
+ System.arraycopy(thiz_sups, 0, this_sups, 1, thiz_sups.length);
+ System.arraycopy(other_sups, 0, t_sups, 1, other_sups.length);
+ this_sups[0] = Repository.lookupClass(thiz.getClassName());
+ t_sups[0] = Repository.lookupClass(other.getClassName());
+
+ for (int i = 0; i < t_sups.length; i++) {
+ for (int j = 0; j < this_sups.length; j++) {
+ if (this_sups[j].equals(t_sups[i])) return new ObjectType(this_sups[j].getClassName());
+ }
}
- /**
- * This commutative operation returns the first common superclass (narrowest ReferenceType
- * referencing a class, not an interface).
- * If one of the types is a superclass of the other, the former is returned.
- * If "this" is Type.NULL, then t is returned.
- * If t is Type.NULL, then "this" is returned.
- * If "this" equals t ['this.equals(t)'] "this" is returned.
- * If "this" or t is an ArrayType, then Type.OBJECT is returned.
- * If "this" or t is a ReferenceType referencing an interface, then Type.OBJECT is
returned.
- * If not all of the two classes' superclasses cannot be found, "null" is returned.
- * See the JVM specification edition 2, "§4.9.2 The Bytecode Verifier".
- *
- * @deprecated use getFirstCommonSuperclass(ReferenceType t) which has
- * slightly changed semantics.
+ // Huh? Did you ask for Type.OBJECT's superclass??
+ return null;
+ }
+
+ /**
+ * This commutative operation returns the first common superclass (narrowest ReferenceType
+ * referencing a class, not an interface).
+ * If one of the types is a superclass of the other, the former is returned.
+ * If "this" is Type.NULL, then t is returned.
+ * If t is Type.NULL, then "this" is returned.
+ * If "this" equals t ['this.equals(t)'] "this" is returned.
+ * If "this" or t is an ArrayType, then Type.OBJECT is returned.
+ * If "this" or t is a ReferenceType referencing an interface, then Type.OBJECT is returned.
+ * If not all of the two classes' superclasses cannot be found, "null" is returned.
+ * See the JVM specification edition 2, "§4.9.2 The Bytecode Verifier".
+ *
+ * @deprecated use getFirstCommonSuperclass(ReferenceType t) which has
+ * slightly changed semantics.
+ */
+ public ReferenceType firstCommonSuperclass(ReferenceType t) {
+ if (this.equals(Type.NULL)) return t;
+ if (t.equals(Type.NULL)) return this;
+ if (this.equals(t)) return this;
+ /*
+ * TODO: Above sounds a little arbitrary. On the other hand, there is
+ * no object referenced by Type.NULL so we can also say all the objects
+ * referenced by Type.NULL were derived from java.lang.Object.
+ * However, the Java Language's "instanceof" operator proves us wrong:
+ * "null" is not referring to an instance of java.lang.Object :)
*/
- public ReferenceType firstCommonSuperclass(ReferenceType t) {
- if (this.equals(Type.NULL)) return t;
- if (t.equals(Type.NULL)) return this;
- if (this.equals(t)) return this;
- /*
- * TODO: Above sounds a little arbitrary. On the other hand, there is
- * no object referenced by Type.NULL so we can also say all the objects
- * referenced by Type.NULL were derived from java.lang.Object.
- * However, the Java Language's "instanceof" operator proves us wrong:
- * "null" is not referring to an instance of java.lang.Object :)
- */
-
- if ((this instanceof ArrayType) || (t instanceof ArrayType))
- return Type.OBJECT;
- // TODO: Is there a proof of OBJECT being the direct ancestor of every ArrayType?
-
- if (((this instanceof ObjectType) && ((ObjectType) this).referencesInterface())
||
- ((t instanceof ObjectType) && ((ObjectType) t).referencesInterface()))
- return Type.OBJECT;
- // TODO: The above line is correct comparing to the vmspec2. But one could
- // make class file verification a bit stronger here by using the notion of
- // superinterfaces or even castability or assignment compatibility.
-
-
- // this and t are ObjectTypes, see above.
- ObjectType thiz = (ObjectType) this;
- ObjectType other = (ObjectType) t;
- JavaClass[] thiz_sups = Repository.getSuperClasses(thiz.getClassName());
- JavaClass[] other_sups = Repository.getSuperClasses(other.getClassName());
-
- if ((thiz_sups == null) || (other_sups == null)) {
- return null;
- }
-
- // Waaahh...
- JavaClass[] this_sups = new JavaClass[thiz_sups.length + 1];
- JavaClass[] t_sups = new JavaClass[other_sups.length + 1];
- System.arraycopy(thiz_sups, 0, this_sups, 1, thiz_sups.length);
- System.arraycopy(other_sups, 0, t_sups, 1, other_sups.length);
- this_sups[0] = Repository.lookupClass(thiz.getClassName());
- t_sups[0] = Repository.lookupClass(other.getClassName());
-
- for (int i = 0; i < t_sups.length; i++) {
- for (int j = 0; j < this_sups.length; j++) {
- if (this_sups[j].equals(t_sups[i])) return new ObjectType(this_sups[j].getClassName());
- }
- }
- // Huh? Did you ask for Type.OBJECT's superclass??
- return null;
+ if ((this instanceof ArrayType) || (t instanceof ArrayType))
+ return Type.OBJECT;
+ // TODO: Is there a proof of OBJECT being the direct ancestor of every ArrayType?
+
+ if (((this instanceof ObjectType) && ((ObjectType) this).referencesInterface())
||
+ ((t instanceof ObjectType) && ((ObjectType) t).referencesInterface()))
+ return Type.OBJECT;
+ // TODO: The above line is correct comparing to the vmspec2. But one could
+ // make class file verification a bit stronger here by using the notion of
+ // superinterfaces or even castability or assignment compatibility.
+
+
+ // this and t are ObjectTypes, see above.
+ ObjectType thiz = (ObjectType) this;
+ ObjectType other = (ObjectType) t;
+ JavaClass[] thiz_sups = Repository.getSuperClasses(thiz.getClassName());
+ JavaClass[] other_sups = Repository.getSuperClasses(other.getClassName());
+
+ if ((thiz_sups == null) || (other_sups == null)) {
+ return null;
+ }
+
+ // Waaahh...
+ JavaClass[] this_sups = new JavaClass[thiz_sups.length + 1];
+ JavaClass[] t_sups = new JavaClass[other_sups.length + 1];
+ System.arraycopy(thiz_sups, 0, this_sups, 1, thiz_sups.length);
+ System.arraycopy(other_sups, 0, t_sups, 1, other_sups.length);
+ this_sups[0] = Repository.lookupClass(thiz.getClassName());
+ t_sups[0] = Repository.lookupClass(other.getClassName());
+
+ for (int i = 0; i < t_sups.length; i++) {
+ for (int j = 0; j < this_sups.length; j++) {
+ if (this_sups[j].equals(t_sups[i])) return new ObjectType(this_sups[j].getClassName());
+ }
}
+
+ // Huh? Did you ask for Type.OBJECT's superclass??
+ return null;
+ }
}
1.2 +1 -2 jakarta-bcel/src/java/org/apache/bcel/generic/SIPUSH.java
Index: SIPUSH.java
===================================================================
RCS file: /home/cvs/jakarta-bcel/src/java/org/apache/bcel/generic/SIPUSH.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- SIPUSH.java 29 Oct 2001 20:00:26 -0000 1.1
+++ SIPUSH.java 7 Aug 2002 18:01:32 -0000 1.2
@@ -110,7 +110,6 @@
return Type.SHORT;
}
-
/**
* Call corresponding visitor method(s). The order is:
* Call visitor methods of implemented interfaces first, then
1.8 +2 -2 jakarta-bcel/src/java/org/apache/bcel/generic/Type.java
Index: Type.java
===================================================================
RCS file: /home/cvs/jakarta-bcel/src/java/org/apache/bcel/generic/Type.java,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -r1.7 -r1.8
--- Type.java 1 Aug 2002 22:36:07 -0000 1.7
+++ Type.java 7 Aug 2002 18:01:32 -0000 1.8
@@ -85,7 +85,7 @@
public static final ObjectType STRINGBUFFER = new ObjectType("java.lang.StringBuffer");
public static final ObjectType THROWABLE = new ObjectType("java.lang.Throwable");
public static final Type[] NO_ARGS = new Type[0];
- public static final ReferenceType NULL = new ReferenceType();
+ public static final ReferenceType NULL = new ReferenceType(){};
public static final Type UNKNOWN = new Type(Constants.T_UNKNOWN,
"<unknown object>"){};
1.1 jakarta-bcel/src/java/org/apache/bcel/generic/InstructionComparator.java
Index: InstructionComparator.java
===================================================================
package org.apache.bcel.generic;
/* ====================================================================
* The Apache Software License, Version 1.1
*
* Copyright (c) 2001 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Apache" and "Apache Software Foundation" and
* "Apache BCEL" must not be used to endorse or promote products
* derived from this software without prior written permission. For
* written permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* "Apache BCEL", nor may "Apache" appear in their name, without
* prior written permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
/**
* 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.<br>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,v 1.1 2002/08/07 18:01:32 mdahm Exp $
* @author <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>
*/
public interface 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).type == ((NEWARRAY)i2).type;
}
}
return false;
}
};
public boolean equals(Instruction i1, Instruction i2);
}
--
To unsubscribe, e-mail: <mailto:bcel-dev-unsubscribe@jakarta.apache.org>
For additional commands, e-mail: <mailto:bcel-dev-help@jakarta.apache.org>
|