*** empty log message ***

git-svn-id: https://svn.code.sf.net/p/jode/code/trunk@113 379699f6-c40d-0410-875b-85095c16579e

jode/jode/bytecode/Opcodes.java

@@ -355,6 +355,7 @@ public abstract class Opcodes {
             }
         }
         case opc_ret:
+            stream.skip(1);
             return new int[] { 2 };
 
         case opc_jsr_w:

jode/jode/expr/InvokeOperator.java

@@ -91,8 +91,8 @@ public final class InvokeOperator extends Operator {
     public String toString(String[] operands) {
         String object = null;
         if (specialFlag) {
+            Class clazz = codeAnalyzer.method.classAnalyzer.clazz;
             if (operands[0].equals("this")) {
-                Class clazz = codeAnalyzer.method.classAnalyzer.clazz;
                 object = "";
                 while (clazz != null 
                        && !classType.equals(Type.tType(clazz))) {
@@ -101,9 +101,11 @@ public final class InvokeOperator extends Operator {
                 }
                 
                 if (clazz == null)
-                    object = "ERROR-SPECIAL";
+                    object = "SPECIAL";
-            } else
+            } else if (classType.equals(Type.tType(clazz)))
-                object = "ERROR-SPECIAL";
+                object = operands[0];
+            else
+                object = "SPECIAL "+operands[0];
         }
             
         object = (object != null) ? object

jode/jode/flow/VariableSet.java

@@ -29,20 +29,98 @@ import jode.LocalInfo;
  * Note that a variable set can contain LocalInfos that use the same
  * slot, but are different.
  */
-public class VariableSet extends java.util.Vector {
+public class VariableSet implements Cloneable {
+    LocalInfo[] locals;
+    int count;
+
     /**
      * Creates a new empty variable set
      */
     public VariableSet() {
-        super(0, 0);
+        locals = null;
+        count = 0;
+    }
+
+    /**
+     * Creates a new pre initialized variable set
+     */
+    public VariableSet(LocalInfo[] locals) {
+        count = locals.length;
+        this.locals = locals;
+    }
+
+    public final void grow(int size) {
+        if (locals != null) {
+            size += count;
+            if (size > locals.length) {
+                int nextSize = locals.length * 2;
+//                 System.err.println("wanted: "+size+" next: "+nextSize);
+                LocalInfo[] newLocals
+                    = new LocalInfo[nextSize > size ? nextSize : size];
+                System.arraycopy(locals, 0, newLocals, 0, count);
+                locals = newLocals;
+            }
+        } else if (size > 0)
+            locals = new LocalInfo[size];
     }
 
     /**
-     * Adds a local variable to the variable set.
+     * Adds a local info to this variable set.  It doesn't check for
-     * @param li The local variable of type LocalInfo.
+     * duplicates.
      */
     public void addElement(LocalInfo li) {
-        super.addElement((Object)li);
+        grow(1);
+        locals[count++] = li;
+    }
+
+    /**
+     * Checks if the variable set contains the given local info.
+     */
+    public boolean contains(LocalInfo li) {
+        li = li.getLocalInfo();
+        for (int i=0; i<count;i++)
+            if (locals[i].getLocalInfo() == li)
+                return true;
+        return false;
+    }
+
+    /**
+     * Removes a local info from this variable set.  
+     */
+    public void removeElement(LocalInfo li) {
+        li = li.getLocalInfo();
+        for (int i=0; i<count;i++)
+            if (locals[i].getLocalInfo() == li)
+                locals[i] = locals[--count];
+    }
+
+    /**
+     * Removes everything from this variable set.  
+     */
+    public void removeAllElements() {
+        locals = null;
+        count = 0;
+    }
+
+    public java.util.Enumeration elements() {
+        return new ArrayEnum(count, locals);
+    }
+
+    public boolean isEmpty() {
+        return count == 0;
+    }
+
+    public Object clone() {
+        try {
+            VariableSet other = (VariableSet) super.clone();
+            if (count > 0) {
+                other.locals = new LocalInfo[count];
+                System.arraycopy(locals, 0, other.locals, 0, count);
+            }
+            return other;
+        } catch (CloneNotSupportedException ex) {
+            throw new jode.AssertError("Clone?");
+        }
     }
 
     /**
@@ -50,22 +128,30 @@ public class VariableSet extends java.util.Vector {
      * in both variable sets, all corresponding LocalInfos are merged.
      * The variable sets are not changed (use union for this).
      * @return The merged variables.
-     * @param vs  the other variable set.
+     * @param vs the other variable set.  */
-     */
     public VariableSet merge(VariableSet vs) {
         VariableSet merged = new VariableSet();
-        for (int i=0; i<elementCount; i++) {
+        merged.grow(Math.min(count,vs.count));
-            LocalInfo li1 = ((LocalInfo) elementData[i]).getLocalInfo();
+    big_loop:
+        for (int i=0; i<count; i++) {
+            LocalInfo li1 = locals[i];
+            int slot = li1.getSlot();
             boolean didMerge = false;
-            for (int j=0; j<vs.elementCount; j++) {
+            for (int k=0; k< merged.count; k++) {
-                LocalInfo li2 = ((LocalInfo) vs.elementData[j]).getLocalInfo();
+                if (slot == merged.locals[k].getSlot()) {
-                if (li1.getSlot() == li2.getSlot()) {
+                    /* This slot was already merged. */
-                    li1.combineWith(li2);
+                    li1.combineWith(merged.locals[k]);
+                    continue big_loop;
+                }
+            }
+            for (int j=0; j<vs.count; j++) {
+                if (li1.getSlot() == vs.locals[j].getSlot()) {
+                    li1.combineWith(vs.locals[j]);
                     didMerge = true;
                 }
             }
             if (didMerge)
-                merged.addElement(li1);
+                merged.locals[merged.count++] = li1;
         }
         return merged;
     }
@@ -77,20 +163,25 @@ public class VariableSet extends java.util.Vector {
      */
     public VariableSet intersect(VariableSet vs) {
         VariableSet intersection = new VariableSet();
-        for (int i=0; i<elementCount; i++) {
+        intersection.grow(Math.min(count, vs.count));
-            LocalInfo li1 = ((LocalInfo) elementData[i]).getLocalInfo();
+    big_loop:
-            for (int j=0; j<vs.elementCount; j++) {
+        for (int i=0; i<count; i++) {
-                LocalInfo li2 = ((LocalInfo) vs.elementData[j]).getLocalInfo();
+            LocalInfo li = locals[i];
-                if (li1.getSlot() == li2.getSlot()) {
+            int slot = li.getSlot();
-                    if (!intersection.contains(li1))
+            for (int j=0; j<vs.count; j++) {
-                        intersection.addElement(li1);
+                if (slot == vs.locals[j].getSlot()) {
-                    if (!intersection.contains(li2))
+                    for (int k=0; k<intersection.count; k++) {
-                        intersection.addElement(li2);
+                        if (slot == intersection.locals[k].getSlot())
+                            continue big_loop;
+                    }
+                    intersection.locals[intersection.count++] 
+                        = li.getLocalInfo();
+                    continue big_loop;
                 }
             }
         }
         return intersection;
-    }           
+    }
 
     /**
      * Intersects the current VariableSet with another and returns the
@@ -99,15 +190,15 @@ public class VariableSet extends java.util.Vector {
      */
     public VariableSet intersectExact(VariableSet vs) {
         VariableSet intersection = new VariableSet();
-        for (int i=0; i<elementCount; i++) {
+        intersection.grow(Math.min(count, vs.count));
-            LocalInfo li1 = ((LocalInfo) elementData[i]).getLocalInfo();
+    big_loop:
-            for (int j=0; j<vs.elementCount; j++) {
+        for (int i=0; i<count; i++) {
-                LocalInfo li2 = ((LocalInfo) vs.elementData[j]).getLocalInfo();
+            LocalInfo li1 = locals[i].getLocalInfo();
-                if (li1.getLocalInfo() == li2.getLocalInfo()) {
+            for (int j=0; j<vs.count; j++) {
+                if (li1 == vs.locals[j].getLocalInfo()) {
                     if (!intersection.contains(li1))
-                        intersection.addElement(li1);
+                        intersection.locals[intersection.count++] = li1;
-                    if (!intersection.contains(li2))
+                    continue big_loop;
-                        intersection.addElement(li2);
                 }
             }
         }
@@ -118,18 +209,18 @@ public class VariableSet extends java.util.Vector {
      * Union the other variable set to the current.
      */
     public void unionExact(VariableSet vs) {
-        int oldSize = elementCount;
+        grow(vs.count);
-    iloop:
+    big_loop:
-        for (int i=0; i< vs.elementCount; i++) {
+        for (int i=0; i< vs.count; i++) {
-            LocalInfo li2 = ((LocalInfo) vs.elementData[i]).getLocalInfo();
+            LocalInfo li2 = (vs.locals[i]).getLocalInfo();
-            /* check if this particular local info was already in the set */
+            /* check if this particular local info is already in the set */
-            for (int j=0; j< oldSize; j++) {
+            for (int j=0; j< count; j++) {
-                LocalInfo li1 = ((LocalInfo) elementData[j]).getLocalInfo();
+                LocalInfo li1 = (locals[j]).getLocalInfo();
                 if (li1 == li2)
-                    /* Yes it was, take next variable */
+                    /* Yes it is, take next variable */
-                    continue iloop;
+                    continue big_loop;
             }
-            addElement(li2);
+            locals[count++] = li2;
         }
     }
 
@@ -138,18 +229,18 @@ public class VariableSet extends java.util.Vector {
      * is already in the current set.  
      */
     public void add(VariableSet vs) {
-        int oldSize = elementCount;
+        grow(vs.count);
-    iloop:
+    big_loop:
-        for (int i=0; i< vs.elementCount; i++) {
+        for (int i=0; i< vs.count; i++) {
-            LocalInfo li2 = (LocalInfo) vs.elementData[i];
+            LocalInfo li2 = vs.locals[i];
-            /* check if this slot was already overwritten by this block */
+            int slot2 = li2.getSlot();
-            for (int j=0; j< oldSize; j++) {
+            /* check if this slot is already in the current set */
-                LocalInfo li1 = (LocalInfo) elementData[j];
+            for (int j=0; j< count; j++) {
-                if (li1.getSlot() == li2.getSlot())
+                if (locals[j].getSlot() == slot2)
-                    /* Yes it was, take next variable */
+                    /* Yes it is, take next variable */
-                    continue iloop;
+                    continue big_loop;
             }
-            addElement(li2.getLocalInfo());
+            locals[count++] = li2.getLocalInfo();
         }
     }
 
@@ -160,17 +251,19 @@ public class VariableSet extends java.util.Vector {
      * @param kill The kill set.
      */
     public void mergeGenKill(VariableSet gen, VariableSet kill) {
-    iloop:
+        grow(gen.count);
-        for (int i=0; i< gen.elementCount; i++) {
+    big_loop:
-            LocalInfo li2 = ((LocalInfo) gen.elementData[i]).getLocalInfo();
+        for (int i=0; i< gen.count; i++) {
-            /* check if this slot was already overwritten (kill set) */
+            LocalInfo li2 = gen.locals[i];
-            for (int j=0; j< kill.elementCount; j++) {
+            int slot = li2.getSlot();
-                LocalInfo li1 = (LocalInfo) kill.elementData[j];
+            /* check if this slot is in the kill set) */
-                if (li2.getSlot() == li1.getSlot())
+            for (int j=0; j< kill.count; j++) {
-                    /* Yes it was, take next variable */
+                LocalInfo li1 = kill.locals[j];
-                    continue iloop;
+                if (slot == kill.locals[j].getSlot())
+                    /* Yes it is, take next variable */
+                    continue big_loop;
             }
-            addElement(li2);
+            locals[count++] = li2.getLocalInfo();
         }
     }
 
@@ -181,25 +274,19 @@ public class VariableSet extends java.util.Vector {
      * @param vs The other variable set.
      */
     public void subtract(VariableSet vs) {
-        /* We count from top to bottom to have easier reorganization.
+    big_loop:
-         * Note, that the variables have not to be in any particular
+        for (int i=0; i < count;) {
-         * order.  */
+            LocalInfo li1 = locals[i];
-        int newCount = elementCount;
+            int slot = li1.getSlot();
-        for (int i=newCount-1; i>=0; i--) {
+            for (int j=0; j<vs.count; j++) {
-            LocalInfo li1 = (LocalInfo) elementData[i];
+                if (slot == vs.locals[j].getSlot()) {
-            for (int j=0; j<vs.elementCount; j++) {
-                LocalInfo li2 = (LocalInfo) vs.elementData[j];
-                if (li1.getSlot() == li2.getSlot()) {
                     /* remove the element from this variable list. */
-                    newCount--;
+                    locals[i] = locals[--count].getLocalInfo();
-                    elementData[i] = elementData[newCount];
+                    continue big_loop;
-                    /* break the j-loop */
-                    break;
                 }
             }
+            i++;
         }
-        /* Now set the new size */
-        setSize(newCount);
     }
 
     /**
@@ -209,28 +296,17 @@ public class VariableSet extends java.util.Vector {
      * @param vs The other variable set.
      */
     public void subtractExact(VariableSet vs) {
-        /* We count from top to bottom to have easier reorganization.
+    big_loop:
-         * Note, that the variables have not to be in any particular
+        for (int i=0; i < count;) {
-         * order.  */
+            LocalInfo li1 = locals[i].getLocalInfo();
-        int newCount = elementCount;
+            for (int j=0; j<vs.count; j++) {
-        for (int i=newCount-1; i>=0; i--) {
+                if (li1 == vs.locals[j].getLocalInfo()) {
-            LocalInfo li1 = (LocalInfo) elementData[i];
-            for (int j=0; j<vs.elementCount; j++) {
-                LocalInfo li2 = (LocalInfo) vs.elementData[j];
-                if (li1.getLocalInfo() == li2.getLocalInfo()) {
                     /* remove the element from this variable list. */
-                    newCount--;
+                    locals[i] = locals[--count].getLocalInfo();
-                    elementData[i] = elementData[newCount];
+                    continue big_loop;
-                    /* break the j-loop */
-                    break;
                 }
             }
+            i++;
         }
-        /* Now set the new size */
-        setSize(newCount);
     }
 }
-
-
-
-

jode/jode/type/Type.java

@@ -158,7 +158,7 @@ public class Type {
                 :  clazz == Void.TYPE      ? tVoid 
                 :  tError;
         }
-        return tClass(clazz.getName());
+        return new ClassInterfacesType(clazz);
     }
 
     public static final Type tClass(String clazzname) {
@@ -234,7 +234,7 @@ public class Type {
     /**
      * @return the type code of the type.
      */
-    public int getTypeCode() {
+    public final int getTypeCode() {
         return typecode;
     }
 

jode/jode/util/SimpleDictionary.java

@@ -33,24 +33,12 @@ public class SimpleDictionary extends Dictionary {
         return count == 0;
     }
 
-    public Enumeration getArrayEnum(final Object[] array, final int size) {
-        return new Enumeration() {
-            int index = 0;
-            public boolean hasMoreElements() {
-                return index < size;
-            }
-            public Object nextElement() {
-                return array[index++];
-            }
-        };
-    }
-
     public Enumeration keys() {
-        return getArrayEnum(keyObjects, count);
+        return new ArrayEnum(count, keyObjects);
     }
 
     public Enumeration elements() {
-        return getArrayEnum(elementObjects, count);
+        return new ArrayEnum(count, elementObjects);
     }
     
     public Object get(Object key) {