jakarta-bcel-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From md...@apache.org
Subject cvs commit: jakarta-bcel/src/java/org/apache/bcel/generic InstructionComparator.java 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
Date Wed, 07 Aug 2002 18:01:33 GMT
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>


Mime
View raw message