sometsome 3.10.46 → 3.10.50.33

data/lib/proguard4.7/src/proguard/evaluation/BranchUnit.java

@@ -1,63 +0,0 @@
-/*
- * ProGuard -- shrinking, optimization, obfuscation, and preverification
- *             of Java bytecode.
- *
- * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation; either version 2 of the License, or (at your option)
- * any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-package proguard.evaluation;
-
-import proguard.classfile.Clazz;
-import proguard.classfile.attribute.CodeAttribute;
-
-/**
- * This InstructionVisitor evaluates the instructions that it visits.
- *
- * @author Eric Lafortune
- */
-public interface BranchUnit
-{
-    /**
-     * Sets the new instruction offset.
-     */
-    public void branch(Clazz         clazz,
-                       CodeAttribute codeAttribute,
-                       int           offset,
-                       int           branchTarget);
-
-
-    /**
-     * Sets the new instruction offset, depending on the certainty of the
-     * conditional branch.
-     */
-    public void branchConditionally(Clazz         clazz,
-                                    CodeAttribute codeAttribute,
-                                    int           offset,
-                                    int           branchTarget,
-                                    int           conditional);
-
-
-    /**
-     * Returns from the method with the given value.
-     */
-    public void returnFromMethod();
-
-
-    /**
-     * Handles the throwing of an exception.
-     */
-    public void throwException();
-}

data/lib/proguard4.7/src/proguard/evaluation/ClassConstantValueFactory.java

@@ -1,53 +0,0 @@
-/*
- * ProGuard -- shrinking, optimization, obfuscation, and preverification
- *             of Java bytecode.
- *
- * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation; either version 2 of the License, or (at your option)
- * any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-package proguard.evaluation;
-
-import proguard.classfile.*;
-import proguard.classfile.constant.*;
-import proguard.classfile.constant.visitor.ConstantVisitor;
-import proguard.classfile.util.SimplifiedVisitor;
-import proguard.evaluation.value.*;
-
-/**
- * This class creates java.lang.Class ReferenceValue instances that correspond
- * to specified constant pool entries.
- *
- * @author Eric Lafortune
- */
-public class ClassConstantValueFactory
-extends      ConstantValueFactory
-{
-    public ClassConstantValueFactory(ValueFactory valueFactory)
-    {
-        super(valueFactory);
-    }
-
-
-    // Implementations for ConstantVisitor.
-
-    public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
-    {
-        // Create a Class reference instead of a reference to the class.
-        value = valueFactory.createReferenceValue(ClassConstants.INTERNAL_NAME_JAVA_LANG_CLASS,
-                                                  classConstant.javaLangClassClass,
-                                                  false);
-    }
-}

data/lib/proguard4.7/src/proguard/evaluation/ConstantValueFactory.java

@@ -1,113 +0,0 @@
-/*
- * ProGuard -- shrinking, optimization, obfuscation, and preverification
- *             of Java bytecode.
- *
- * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation; either version 2 of the License, or (at your option)
- * any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-package proguard.evaluation;
-
-import proguard.classfile.*;
-import proguard.classfile.constant.*;
-import proguard.classfile.constant.visitor.ConstantVisitor;
-import proguard.classfile.util.SimplifiedVisitor;
-import proguard.evaluation.value.*;
-
-/**
- * This class creates Value instance that correspond to specified constant pool
- * entries.
- *
- * @author Eric Lafortune
- */
-public class ConstantValueFactory
-extends      SimplifiedVisitor
-implements   ConstantVisitor
-{
-    protected final ValueFactory valueFactory;
-
-    // Field acting as a parameter for the ConstantVisitor methods.
-    protected Value value;
-
-
-    public ConstantValueFactory(ValueFactory valueFactory)
-    {
-        this.valueFactory = valueFactory;
-    }
-
-
-    /**
-     * Returns the Value of the constant pool element at the given index.
-     */
-    public Value constantValue(Clazz clazz,
-                               int   constantIndex)
-    {
-        // Visit the constant pool entry to get its return value.
-        clazz.constantPoolEntryAccept(constantIndex, this);
-
-        return value;
-    }
-
-
-    // Implementations for ConstantVisitor.
-
-    public void visitIntegerConstant(Clazz clazz, IntegerConstant integerConstant)
-    {
-        value = valueFactory.createIntegerValue(integerConstant.getValue());
-    }
-
-    public void visitLongConstant(Clazz clazz, LongConstant longConstant)
-    {
-        value = valueFactory.createLongValue(longConstant.getValue());
-    }
-
-    public void visitFloatConstant(Clazz clazz, FloatConstant floatConstant)
-    {
-        value = valueFactory.createFloatValue(floatConstant.getValue());
-    }
-
-    public void visitDoubleConstant(Clazz clazz, DoubleConstant doubleConstant)
-    {
-        value = valueFactory.createDoubleValue(doubleConstant.getValue());
-    }
-
-    public void visitStringConstant(Clazz clazz, StringConstant stringConstant)
-    {
-        value = valueFactory.createReferenceValue(ClassConstants.INTERNAL_NAME_JAVA_LANG_STRING,
-                                                  stringConstant.javaLangStringClass,
-                                                  false);
-    }
-
-    public void visitMethodHandleConstant(Clazz clazz, MethodHandleConstant methodHandleConstant)
-    {
-        value = valueFactory.createReferenceValue(ClassConstants.INTERNAL_NAME_JAVA_LANG_INVOKE_METHOD_HANDLE,
-                                                  methodHandleConstant.javaLangInvokeMethodHandleClass,
-                                                  false);
-    }
-
-    public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
-    {
-        value = valueFactory.createReferenceValue(classConstant.getName(clazz),
-                                                  classConstant.referencedClass,
-                                                  false);
-    }
-
-    public void visitMethodTypeConstant(Clazz clazz, MethodTypeConstant methodTypeConstant)
-    {
-        value = valueFactory.createReferenceValue(ClassConstants.INTERNAL_NAME_JAVA_LANG_INVOKE_METHOD_TYPE,
-                                                  methodTypeConstant.javaLangInvokeMethodTypeClass,
-                                                  false);
-    }
-}

data/lib/proguard4.7/src/proguard/evaluation/InvocationUnit.java

@@ -1,62 +0,0 @@
-/*
- * ProGuard -- shrinking, optimization, obfuscation, and preverification
- *             of Java bytecode.
- *
- * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation; either version 2 of the License, or (at your option)
- * any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-package proguard.evaluation;
-
-import proguard.classfile.*;
-import proguard.classfile.attribute.CodeAttribute;
-import proguard.classfile.instruction.ConstantInstruction;
-import proguard.evaluation.value.Value;
-
-/**
- * This interface sets up the variables for entering a method,
- * and it updates the stack for the invocation of a class member.
- *
- * @author Eric Lafortune
- */
-public interface InvocationUnit
-{
-    /**
-     * Sets up the given variables for entering the given method.
-     */
-    public void enterMethod(Clazz     clazz,
-                            Method    method,
-                            Variables variables);
-
-
-    /**
-     * Exits the given method with the given return value.
-     */
-    public void exitMethod(Clazz  clazz,
-                           Method method,
-                           Value  returnValue);
-
-
-    /**
-     * Updates the given stack corresponding to the execution of the given
-     * field or method reference instruction.
-     */
-    public void invokeMember(Clazz               clazz,
-                             Method              method,
-                             CodeAttribute       codeAttribute,
-                             int                 offset,
-                             ConstantInstruction constantInstruction,
-                             Stack               stack);
-}

data/lib/proguard4.7/src/proguard/evaluation/Processor.java

@@ -1,908 +0,0 @@
-/*
- * ProGuard -- shrinking, optimization, obfuscation, and preverification
- *             of Java bytecode.
- *
- * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation; either version 2 of the License, or (at your option)
- * any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-package proguard.evaluation;
-
-import proguard.classfile.*;
-import proguard.classfile.attribute.CodeAttribute;
-import proguard.classfile.instruction.*;
-import proguard.classfile.instruction.visitor.InstructionVisitor;
-import proguard.evaluation.value.*;
-
-/**
- * This InstructionVisitor executes the instructions that it visits on a given
- * local variable frame and stack.
- *
- * @author Eric Lafortune
- */
-public class Processor
-implements   InstructionVisitor
-{
-    private final Variables      variables;
-    private final Stack          stack;
-    private final ValueFactory   valueFactory;
-    private final BranchUnit     branchUnit;
-    private final InvocationUnit invocationUnit;
-
-    private final ConstantValueFactory      constantValueFactory;
-    private final ClassConstantValueFactory classConstantValueFactory;
-
-
-    /**
-     * Creates a new processor that operates on the given environment.
-     * @param variables      the local variable frame.
-     * @param stack          the local stack.
-     * @param branchUnit     the class that can affect the program counter.
-     * @param invocationUnit the class that can access other program members.
-     */
-    public Processor(Variables      variables,
-                     Stack          stack,
-                     ValueFactory   valueFactory,
-                     BranchUnit     branchUnit,
-                     InvocationUnit invocationUnit)
-    {
-        this.variables      = variables;
-        this.stack          = stack;
-        this.valueFactory   = valueFactory;
-        this.branchUnit     = branchUnit;
-        this.invocationUnit = invocationUnit;
-
-        constantValueFactory      = new ConstantValueFactory(valueFactory);
-        classConstantValueFactory = new ClassConstantValueFactory(valueFactory);
-    }
-
-
-    // Implementations for InstructionVisitor.
-
-    public void visitSimpleInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, SimpleInstruction simpleInstruction)
-    {
-        switch (simpleInstruction.opcode)
-        {
-            case InstructionConstants.OP_NOP:
-                break;
-
-            case InstructionConstants.OP_ACONST_NULL:
-                stack.push(valueFactory.createReferenceValueNull());
-                break;
-
-            case InstructionConstants.OP_ICONST_M1:
-            case InstructionConstants.OP_ICONST_0:
-            case InstructionConstants.OP_ICONST_1:
-            case InstructionConstants.OP_ICONST_2:
-            case InstructionConstants.OP_ICONST_3:
-            case InstructionConstants.OP_ICONST_4:
-            case InstructionConstants.OP_ICONST_5:
-            case InstructionConstants.OP_BIPUSH:
-            case InstructionConstants.OP_SIPUSH:
-                stack.push(valueFactory.createIntegerValue(simpleInstruction.constant));
-                break;
-
-            case InstructionConstants.OP_LCONST_0:
-            case InstructionConstants.OP_LCONST_1:
-                stack.push(valueFactory.createLongValue(simpleInstruction.constant));
-                break;
-
-            case InstructionConstants.OP_FCONST_0:
-            case InstructionConstants.OP_FCONST_1:
-            case InstructionConstants.OP_FCONST_2:
-                stack.push(valueFactory.createFloatValue((float)simpleInstruction.constant));
-                break;
-
-            case InstructionConstants.OP_DCONST_0:
-            case InstructionConstants.OP_DCONST_1:
-                stack.push(valueFactory.createDoubleValue((double)simpleInstruction.constant));
-                break;
-
-            case InstructionConstants.OP_IALOAD:
-            case InstructionConstants.OP_BALOAD:
-            case InstructionConstants.OP_CALOAD:
-            case InstructionConstants.OP_SALOAD:
-                stack.ipop();
-                stack.apop();
-                stack.push(valueFactory.createIntegerValue());
-                break;
-
-            case InstructionConstants.OP_LALOAD:
-                stack.ipop();
-                stack.apop();
-                stack.push(valueFactory.createLongValue());
-                break;
-
-            case InstructionConstants.OP_FALOAD:
-                stack.ipop();
-                stack.apop();
-                stack.push(valueFactory.createFloatValue());
-                break;
-
-            case InstructionConstants.OP_DALOAD:
-                stack.ipop();
-                stack.apop();
-                stack.push(valueFactory.createDoubleValue());
-                break;
-
-            case InstructionConstants.OP_AALOAD:
-            {
-                IntegerValue   arrayIndex     = stack.ipop();
-                ReferenceValue arrayReference = stack.apop();
-                stack.push(arrayReference.arrayLoad(arrayIndex, valueFactory));
-                break;
-            }
-
-            case InstructionConstants.OP_IASTORE:
-            case InstructionConstants.OP_BASTORE:
-            case InstructionConstants.OP_CASTORE:
-            case InstructionConstants.OP_SASTORE:
-                stack.ipop();
-                stack.ipop();
-                stack.apop();
-                break;
-
-            case InstructionConstants.OP_LASTORE:
-                stack.lpop();
-                stack.ipop();
-                stack.apop();
-                break;
-
-            case InstructionConstants.OP_FASTORE:
-                stack.fpop();
-                stack.ipop();
-                stack.apop();
-                break;
-
-            case InstructionConstants.OP_DASTORE:
-                stack.dpop();
-                stack.ipop();
-                stack.apop();
-                break;
-
-            case InstructionConstants.OP_AASTORE:
-                stack.apop();
-                stack.ipop();
-                stack.apop();
-                break;
-
-            case InstructionConstants.OP_POP:
-                stack.pop1();
-                break;
-
-            case InstructionConstants.OP_POP2:
-                stack.pop2();
-                break;
-
-            case InstructionConstants.OP_DUP:
-                stack.dup();
-                break;
-
-            case InstructionConstants.OP_DUP_X1:
-                stack.dup_x1();
-                break;
-
-            case InstructionConstants.OP_DUP_X2:
-                stack.dup_x2();
-                break;
-
-            case InstructionConstants.OP_DUP2:
-                stack.dup2();
-                break;
-
-            case InstructionConstants.OP_DUP2_X1:
-                stack.dup2_x1();
-                break;
-
-            case InstructionConstants.OP_DUP2_X2:
-                stack.dup2_x2();
-                break;
-
-            case InstructionConstants.OP_SWAP:
-                stack.swap();
-                break;
-
-            case InstructionConstants.OP_IADD:
-                stack.push(stack.ipop().add(stack.ipop()));
-                break;
-
-            case InstructionConstants.OP_LADD:
-                stack.push(stack.lpop().add(stack.lpop()));
-                break;
-
-            case InstructionConstants.OP_FADD:
-                stack.push(stack.fpop().add(stack.fpop()));
-                break;
-
-            case InstructionConstants.OP_DADD:
-                stack.push(stack.dpop().add(stack.dpop()));
-                break;
-
-            case InstructionConstants.OP_ISUB:
-                stack.push(stack.ipop().subtractFrom(stack.ipop()));
-                break;
-
-            case InstructionConstants.OP_LSUB:
-                stack.push(stack.lpop().subtractFrom(stack.lpop()));
-                break;
-
-            case InstructionConstants.OP_FSUB:
-                stack.push(stack.fpop().subtractFrom(stack.fpop()));
-                break;
-
-            case InstructionConstants.OP_DSUB:
-                stack.push(stack.dpop().subtractFrom(stack.dpop()));
-                break;
-
-            case InstructionConstants.OP_IMUL:
-                stack.push(stack.ipop().multiply(stack.ipop()));
-                break;
-
-            case InstructionConstants.OP_LMUL:
-                stack.push(stack.lpop().multiply(stack.lpop()));
-                break;
-
-            case InstructionConstants.OP_FMUL:
-                stack.push(stack.fpop().multiply(stack.fpop()));
-                break;
-
-            case InstructionConstants.OP_DMUL:
-                stack.push(stack.dpop().multiply(stack.dpop()));
-                break;
-
-            case InstructionConstants.OP_IDIV:
-                try
-                {
-                    stack.push(stack.ipop().divideOf(stack.ipop()));
-                }
-                catch (ArithmeticException ex)
-                {
-                    stack.push(valueFactory.createIntegerValue());
-                    // TODO: Forward ArithmeticExceptions.
-                    //stack.clear();
-                    //stack.push(valueFactory.createReference(false));
-                    //branchUnit.throwException();
-                }
-                break;
-
-            case InstructionConstants.OP_LDIV:
-                try
-                {
-                    stack.push(stack.lpop().divideOf(stack.lpop()));
-                }
-                catch (ArithmeticException ex)
-                {
-                    stack.push(valueFactory.createLongValue());
-                    // TODO: Forward ArithmeticExceptions.
-                    //stack.clear();
-                    //stack.push(valueFactory.createReference(false));
-                    //branchUnit.throwException();
-                }
-                break;
-
-            case InstructionConstants.OP_FDIV:
-                stack.push(stack.fpop().divideOf(stack.fpop()));
-                break;
-
-            case InstructionConstants.OP_DDIV:
-                stack.push(stack.dpop().divideOf(stack.dpop()));
-                break;
-
-            case InstructionConstants.OP_IREM:
-                try
-                {
-                    stack.push(stack.ipop().remainderOf(stack.ipop()));
-                }
-                catch (ArithmeticException ex)
-                {
-                    stack.push(valueFactory.createIntegerValue());
-                    // TODO: Forward ArithmeticExceptions.
-                    //stack.clear();
-                    //stack.push(valueFactory.createReference(false));
-                    //branchUnit.throwException();
-                }
-                break;
-
-            case InstructionConstants.OP_LREM:
-                try
-                {
-                    stack.push(stack.lpop().remainderOf(stack.lpop()));
-                }
-                catch (ArithmeticException ex)
-                {
-                    stack.push(valueFactory.createLongValue());
-                    // TODO: Forward ArithmeticExceptions.
-                    //stack.clear();
-                    //stack.push(valueFactory.createReference(false));
-                    //branchUnit.throwException();
-                }
-                break;
-
-            case InstructionConstants.OP_FREM:
-                stack.push(stack.fpop().remainderOf(stack.fpop()));
-                break;
-
-            case InstructionConstants.OP_DREM:
-                stack.push(stack.dpop().remainderOf(stack.dpop()));
-                break;
-
-            case InstructionConstants.OP_INEG:
-                stack.push(stack.ipop().negate());
-                break;
-
-            case InstructionConstants.OP_LNEG:
-                stack.push(stack.lpop().negate());
-                break;
-
-            case InstructionConstants.OP_FNEG:
-                stack.push(stack.fpop().negate());
-                break;
-
-            case InstructionConstants.OP_DNEG:
-                stack.push(stack.dpop().negate());
-                break;
-
-            case InstructionConstants.OP_ISHL:
-                stack.push(stack.ipop().shiftLeftOf(stack.ipop()));
-                break;
-
-            case InstructionConstants.OP_LSHL:
-                stack.push(stack.ipop().shiftLeftOf(stack.lpop()));
-                break;
-
-            case InstructionConstants.OP_ISHR:
-                stack.push(stack.ipop().shiftRightOf(stack.ipop()));
-                break;
-
-            case InstructionConstants.OP_LSHR:
-                stack.push(stack.ipop().shiftRightOf(stack.lpop()));
-                break;
-
-            case InstructionConstants.OP_IUSHR:
-                stack.push(stack.ipop().unsignedShiftRightOf(stack.ipop()));
-                break;
-
-            case InstructionConstants.OP_LUSHR:
-                stack.push(stack.ipop().unsignedShiftRightOf(stack.lpop()));
-                break;
-
-            case InstructionConstants.OP_IAND:
-                stack.push(stack.ipop().and(stack.ipop()));
-                break;
-
-            case InstructionConstants.OP_LAND:
-                stack.push(stack.lpop().and(stack.lpop()));
-                break;
-
-            case InstructionConstants.OP_IOR:
-                stack.push(stack.ipop().or(stack.ipop()));
-                break;
-
-            case InstructionConstants.OP_LOR:
-                stack.push(stack.lpop().or(stack.lpop()));
-                break;
-
-            case InstructionConstants.OP_IXOR:
-                stack.push(stack.ipop().xor(stack.ipop()));
-                break;
-
-            case InstructionConstants.OP_LXOR:
-                stack.push(stack.lpop().xor(stack.lpop()));
-                break;
-
-            case InstructionConstants.OP_I2L:
-                stack.push(stack.ipop().convertToLong());
-                break;
-
-            case InstructionConstants.OP_I2F:
-                stack.push(stack.ipop().convertToFloat());
-                break;
-
-            case InstructionConstants.OP_I2D:
-                stack.push(stack.ipop().convertToDouble());
-                break;
-
-            case InstructionConstants.OP_L2I:
-                stack.push(stack.lpop().convertToInteger());
-                break;
-
-            case InstructionConstants.OP_L2F:
-                stack.push(stack.lpop().convertToFloat());
-                break;
-
-            case InstructionConstants.OP_L2D:
-                stack.push(stack.lpop().convertToDouble());
-                break;
-
-            case InstructionConstants.OP_F2I:
-                stack.push(stack.fpop().convertToInteger());
-                break;
-
-            case InstructionConstants.OP_F2L:
-                stack.push(stack.fpop().convertToLong());
-                break;
-
-            case InstructionConstants.OP_F2D:
-                stack.push(stack.fpop().convertToDouble());
-                break;
-
-            case InstructionConstants.OP_D2I:
-                stack.push(stack.dpop().convertToInteger());
-                break;
-
-            case InstructionConstants.OP_D2L:
-                stack.push(stack.dpop().convertToLong());
-                break;
-
-            case InstructionConstants.OP_D2F:
-                stack.push(stack.dpop().convertToFloat());
-                break;
-
-            case InstructionConstants.OP_I2B:
-                stack.push(stack.ipop().convertToByte());
-                break;
-
-            case InstructionConstants.OP_I2C:
-                stack.push(stack.ipop().convertToCharacter());
-                break;
-
-            case InstructionConstants.OP_I2S:
-                stack.push(stack.ipop().convertToShort());
-                break;
-
-            case InstructionConstants.OP_LCMP:
-//                stack.push(stack.lpop().compareReverse(stack.lpop()));
-
-                LongValue longValue1 = stack.lpop();
-                LongValue longValue2 = stack.lpop();
-                stack.push(longValue2.compare(longValue1));
-                break;
-
-            case InstructionConstants.OP_FCMPL:
-                FloatValue floatValue1 = stack.fpop();
-                FloatValue floatValue2 = stack.fpop();
-                stack.push(floatValue2.compare(floatValue1));
-                break;
-
-            case InstructionConstants.OP_FCMPG:
-                stack.push(stack.fpop().compareReverse(stack.fpop()));
-                break;
-
-            case InstructionConstants.OP_DCMPL:
-                DoubleValue doubleValue1 = stack.dpop();
-                DoubleValue doubleValue2 = stack.dpop();
-                stack.push(doubleValue2.compare(doubleValue1));
-                break;
-
-            case InstructionConstants.OP_DCMPG:
-                stack.push(stack.dpop().compareReverse(stack.dpop()));
-                break;
-
-            case InstructionConstants.OP_IRETURN:
-                invocationUnit.exitMethod(clazz, method, stack.ipop());
-                branchUnit.returnFromMethod();
-                break;
-
-            case InstructionConstants.OP_LRETURN:
-                invocationUnit.exitMethod(clazz, method, stack.lpop());
-                branchUnit.returnFromMethod();
-                break;
-
-            case InstructionConstants.OP_FRETURN:
-                invocationUnit.exitMethod(clazz, method, stack.fpop());
-                branchUnit.returnFromMethod();
-                break;
-
-            case InstructionConstants.OP_DRETURN:
-                invocationUnit.exitMethod(clazz, method, stack.dpop());
-                branchUnit.returnFromMethod();
-                break;
-
-            case InstructionConstants.OP_ARETURN:
-                invocationUnit.exitMethod(clazz, method, stack.apop());
-                branchUnit.returnFromMethod();
-                break;
-
-            case InstructionConstants.OP_RETURN:
-                branchUnit.returnFromMethod();
-                break;
-
-            case InstructionConstants.OP_NEWARRAY:
-                IntegerValue arrayLength = stack.ipop();
-                stack.push(valueFactory.createArrayReferenceValue(String.valueOf(InstructionUtil.internalTypeFromArrayType((byte)simpleInstruction.constant)),
-                                                                  null,
-                                                                  arrayLength));
-                break;
-
-            case InstructionConstants.OP_ARRAYLENGTH:
-                stack.apop();
-                stack.push(valueFactory.createIntegerValue());
-                break;
-
-            case InstructionConstants.OP_ATHROW:
-                ReferenceValue exceptionReferenceValue = stack.apop();
-                stack.clear();
-                stack.push(exceptionReferenceValue);
-                branchUnit.throwException();
-                break;
-
-            case InstructionConstants.OP_MONITORENTER:
-            case InstructionConstants.OP_MONITOREXIT:
-                stack.apop();
-                break;
-
-            default:
-                throw new IllegalArgumentException("Unknown simple instruction ["+simpleInstruction.opcode+"]");
-        }
-    }
-
-
-    public void visitConstantInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, ConstantInstruction constantInstruction)
-    {
-        int constantIndex = constantInstruction.constantIndex;
-
-        switch (constantInstruction.opcode)
-        {
-            case InstructionConstants.OP_LDC:
-            case InstructionConstants.OP_LDC_W:
-            case InstructionConstants.OP_LDC2_W:
-                stack.push(classConstantValueFactory.constantValue(clazz, constantIndex));
-                break;
-
-            case InstructionConstants.OP_GETSTATIC:
-            case InstructionConstants.OP_PUTSTATIC:
-            case InstructionConstants.OP_GETFIELD:
-            case InstructionConstants.OP_PUTFIELD:
-            case InstructionConstants.OP_INVOKEVIRTUAL:
-            case InstructionConstants.OP_INVOKESPECIAL:
-            case InstructionConstants.OP_INVOKESTATIC:
-            case InstructionConstants.OP_INVOKEINTERFACE:
-            case InstructionConstants.OP_INVOKEDYNAMIC:
-                invocationUnit.invokeMember(clazz, method, codeAttribute, offset, constantInstruction, stack);
-                break;
-
-            case InstructionConstants.OP_NEW:
-                stack.push(constantValueFactory.constantValue(clazz, constantIndex).referenceValue());
-                break;
-
-            case InstructionConstants.OP_ANEWARRAY:
-            {
-                ReferenceValue referenceValue = constantValueFactory.constantValue(clazz, constantIndex).referenceValue();
-
-                stack.push(valueFactory.createArrayReferenceValue(referenceValue.internalType(),
-                                                                  referenceValue.getReferencedClass(),
-                                                                  stack.ipop()));
-                break;
-            }
-
-            case InstructionConstants.OP_CHECKCAST:
-                // TODO: Check cast.
-                ReferenceValue castValue = stack.apop();
-                ReferenceValue castResultValue =
-                    castValue.isNull() == Value.ALWAYS ? castValue :
-                    castValue.isNull() == Value.NEVER  ? constantValueFactory.constantValue(clazz, constantIndex).referenceValue() :
-                                                         constantValueFactory.constantValue(clazz, constantIndex).referenceValue().generalize(valueFactory.createReferenceValueNull());
-                stack.push(castResultValue);
-                break;
-
-            case InstructionConstants.OP_INSTANCEOF:
-            {
-                ReferenceValue referenceValue = constantValueFactory.constantValue(clazz, constantIndex).referenceValue();
-
-                int instanceOf = stack.apop().instanceOf(referenceValue.getType(),
-                                                         referenceValue.getReferencedClass());
-
-                stack.push(instanceOf == Value.NEVER  ? valueFactory.createIntegerValue(0) :
-                           instanceOf == Value.ALWAYS ? valueFactory.createIntegerValue(1) :
-                                                        valueFactory.createIntegerValue());
-                break;
-            }
-
-            case InstructionConstants.OP_MULTIANEWARRAY:
-            {
-                int dimensionCount = constantInstruction.constant;
-                for (int dimension = 0; dimension < dimensionCount; dimension++)
-                {
-                    // TODO: Use array lengths.
-                    IntegerValue arrayLength = stack.ipop();
-                }
-
-                stack.push(constantValueFactory.constantValue(clazz, constantIndex).referenceValue());
-                break;
-            }
-
-            default:
-                throw new IllegalArgumentException("Unknown constant pool instruction ["+constantInstruction.opcode+"]");
-        }
-    }
-
-
-    public void visitVariableInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, VariableInstruction variableInstruction)
-    {
-        int variableIndex = variableInstruction.variableIndex;
-
-        switch (variableInstruction.opcode)
-        {
-            case InstructionConstants.OP_ILOAD:
-            case InstructionConstants.OP_ILOAD_0:
-            case InstructionConstants.OP_ILOAD_1:
-            case InstructionConstants.OP_ILOAD_2:
-            case InstructionConstants.OP_ILOAD_3:
-                stack.push(variables.iload(variableIndex));
-                break;
-
-            case InstructionConstants.OP_LLOAD:
-            case InstructionConstants.OP_LLOAD_0:
-            case InstructionConstants.OP_LLOAD_1:
-            case InstructionConstants.OP_LLOAD_2:
-            case InstructionConstants.OP_LLOAD_3:
-                stack.push(variables.lload(variableIndex));
-                break;
-
-            case InstructionConstants.OP_FLOAD:
-            case InstructionConstants.OP_FLOAD_0:
-            case InstructionConstants.OP_FLOAD_1:
-            case InstructionConstants.OP_FLOAD_2:
-            case InstructionConstants.OP_FLOAD_3:
-                stack.push(variables.fload(variableIndex));
-                break;
-
-            case InstructionConstants.OP_DLOAD:
-            case InstructionConstants.OP_DLOAD_0:
-            case InstructionConstants.OP_DLOAD_1:
-            case InstructionConstants.OP_DLOAD_2:
-            case InstructionConstants.OP_DLOAD_3:
-                stack.push(variables.dload(variableIndex));
-                break;
-
-            case InstructionConstants.OP_ALOAD:
-            case InstructionConstants.OP_ALOAD_0:
-            case InstructionConstants.OP_ALOAD_1:
-            case InstructionConstants.OP_ALOAD_2:
-            case InstructionConstants.OP_ALOAD_3:
-                stack.push(variables.aload(variableIndex));
-                break;
-
-            case InstructionConstants.OP_ISTORE:
-            case InstructionConstants.OP_ISTORE_0:
-            case InstructionConstants.OP_ISTORE_1:
-            case InstructionConstants.OP_ISTORE_2:
-            case InstructionConstants.OP_ISTORE_3:
-                variables.store(variableIndex, stack.ipop());
-                break;
-
-            case InstructionConstants.OP_LSTORE:
-            case InstructionConstants.OP_LSTORE_0:
-            case InstructionConstants.OP_LSTORE_1:
-            case InstructionConstants.OP_LSTORE_2:
-            case InstructionConstants.OP_LSTORE_3:
-                variables.store(variableIndex, stack.lpop());
-                break;
-
-            case InstructionConstants.OP_FSTORE:
-            case InstructionConstants.OP_FSTORE_0:
-            case InstructionConstants.OP_FSTORE_1:
-            case InstructionConstants.OP_FSTORE_2:
-            case InstructionConstants.OP_FSTORE_3:
-                variables.store(variableIndex, stack.fpop());
-                break;
-
-            case InstructionConstants.OP_DSTORE:
-            case InstructionConstants.OP_DSTORE_0:
-            case InstructionConstants.OP_DSTORE_1:
-            case InstructionConstants.OP_DSTORE_2:
-            case InstructionConstants.OP_DSTORE_3:
-                variables.store(variableIndex, stack.dpop());
-                break;
-
-            case InstructionConstants.OP_ASTORE:
-            case InstructionConstants.OP_ASTORE_0:
-            case InstructionConstants.OP_ASTORE_1:
-            case InstructionConstants.OP_ASTORE_2:
-            case InstructionConstants.OP_ASTORE_3:
-                // The operand on the stack can be a reference or a return
-                // address, so we'll relax the pop operation.
-                //variables.store(variableIndex, stack.apop());
-                variables.store(variableIndex, stack.pop());
-                break;
-
-            case InstructionConstants.OP_IINC:
-                variables.store(variableIndex,
-                                variables.iload(variableIndex).add(
-                                valueFactory.createIntegerValue(variableInstruction.constant)));
-                break;
-
-            case InstructionConstants.OP_RET:
-                // The return address should be in the last offset of the
-                // given instruction offset variable (even though there may
-                // be other offsets).
-                InstructionOffsetValue instructionOffsetValue = variables.oload(variableIndex);
-                branchUnit.branch(clazz,
-                                  codeAttribute,
-                                  offset,
-                                  instructionOffsetValue.instructionOffset(instructionOffsetValue.instructionOffsetCount()-1));
-                break;
-
-            default:
-                throw new IllegalArgumentException("Unknown variable instruction ["+variableInstruction.opcode+"]");
-        }
-    }
-
-
-    public void visitBranchInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, BranchInstruction branchInstruction)
-    {
-        int branchTarget = offset + branchInstruction.branchOffset;
-
-        switch (branchInstruction.opcode)
-        {
-            case InstructionConstants.OP_IFEQ:
-                branchUnit.branchConditionally(clazz, codeAttribute, offset, branchTarget,
-                    stack.ipop().equal(valueFactory.createIntegerValue(0)));
-                break;
-
-            case InstructionConstants.OP_IFNE:
-                branchUnit.branchConditionally(clazz, codeAttribute, offset, branchTarget,
-                    stack.ipop().notEqual(valueFactory.createIntegerValue(0)));
-                break;
-
-            case InstructionConstants.OP_IFLT:
-                branchUnit.branchConditionally(clazz, codeAttribute, offset, branchTarget,
-                    stack.ipop().lessThan(valueFactory.createIntegerValue(0)));
-                break;
-
-            case InstructionConstants.OP_IFGE:
-                branchUnit.branchConditionally(clazz, codeAttribute, offset, branchTarget,
-                    stack.ipop().greaterThanOrEqual(valueFactory.createIntegerValue(0)));
-                break;
-
-            case InstructionConstants.OP_IFGT:
-                branchUnit.branchConditionally(clazz, codeAttribute, offset, branchTarget,
-                    stack.ipop().greaterThan(valueFactory.createIntegerValue(0)));
-                break;
-
-            case InstructionConstants.OP_IFLE:
-                branchUnit.branchConditionally(clazz, codeAttribute, offset, branchTarget,
-                    stack.ipop().lessThanOrEqual(valueFactory.createIntegerValue(0)));
-                break;
-
-
-            case InstructionConstants.OP_IFICMPEQ:
-                branchUnit.branchConditionally(clazz, codeAttribute, offset, branchTarget,
-                    stack.ipop().equal(stack.ipop()));
-                break;
-
-            case InstructionConstants.OP_IFICMPNE:
-                branchUnit.branchConditionally(clazz, codeAttribute, offset, branchTarget,
-                    stack.ipop().notEqual(stack.ipop()));
-                break;
-
-            case InstructionConstants.OP_IFICMPLT:
-                // Note that the stack entries are popped in reverse order.
-                branchUnit.branchConditionally(clazz, codeAttribute, offset, branchTarget,
-                    stack.ipop().greaterThan(stack.ipop()));
-                break;
-
-            case InstructionConstants.OP_IFICMPGE:
-                // Note that the stack entries are popped in reverse order.
-                branchUnit.branchConditionally(clazz, codeAttribute, offset, branchTarget,
-                    stack.ipop().lessThanOrEqual(stack.ipop()));
-                break;
-
-            case InstructionConstants.OP_IFICMPGT:
-                // Note that the stack entries are popped in reverse order.
-                branchUnit.branchConditionally(clazz, codeAttribute, offset, branchTarget,
-                    stack.ipop().lessThan(stack.ipop()));
-                break;
-
-            case InstructionConstants.OP_IFICMPLE:
-                // Note that the stack entries are popped in reverse order.
-                branchUnit.branchConditionally(clazz, codeAttribute, offset, branchTarget,
-                    stack.ipop().greaterThanOrEqual(stack.ipop()));
-                break;
-
-            case InstructionConstants.OP_IFACMPEQ:
-                branchUnit.branchConditionally(clazz, codeAttribute, offset, branchTarget,
-                    stack.apop().equal(stack.apop()));
-                break;
-
-            case InstructionConstants.OP_IFACMPNE:
-                branchUnit.branchConditionally(clazz, codeAttribute, offset, branchTarget,
-                    stack.apop().notEqual(stack.apop()));
-                break;
-
-            case InstructionConstants.OP_GOTO:
-            case InstructionConstants.OP_GOTO_W:
-                branchUnit.branch(clazz, codeAttribute, offset, branchTarget);
-                break;
-
-
-            case InstructionConstants.OP_JSR:
-            case InstructionConstants.OP_JSR_W:
-                stack.push(new InstructionOffsetValue(offset +
-                                                      branchInstruction.length(offset)));
-                branchUnit.branch(clazz, codeAttribute, offset, branchTarget);
-                break;
-
-            case InstructionConstants.OP_IFNULL:
-                branchUnit.branchConditionally(clazz, codeAttribute, offset, branchTarget,
-                    stack.apop().isNull());
-                break;
-
-            case InstructionConstants.OP_IFNONNULL:
-                branchUnit.branchConditionally(clazz, codeAttribute, offset, branchTarget,
-                    stack.apop().isNotNull());
-                break;
-
-            default:
-                throw new IllegalArgumentException("Unknown branch instruction ["+branchInstruction.opcode+"]");
-        }
-    }
-
-
-    public void visitTableSwitchInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, TableSwitchInstruction tableSwitchInstruction)
-    {
-        IntegerValue indexValue = stack.ipop();
-
-        // If there is no definite branch in any of the cases below,
-        // branch to the default offset.
-        branchUnit.branch(clazz, codeAttribute,
-                          offset,
-                          offset + tableSwitchInstruction.defaultOffset);
-
-        for (int index = 0; index < tableSwitchInstruction.jumpOffsets.length; index++)
-        {
-            int conditional = indexValue.equal(valueFactory.createIntegerValue(
-                tableSwitchInstruction.lowCase + index));
-            branchUnit.branchConditionally(clazz, codeAttribute,
-                                           offset,
-                                           offset + tableSwitchInstruction.jumpOffsets[index],
-                                           conditional);
-
-            // If this branch is always taken, we can skip the rest.
-            if (conditional == Value.ALWAYS)
-            {
-                break;
-            }
-        }
-    }
-
-
-    public void visitLookUpSwitchInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, LookUpSwitchInstruction lookUpSwitchInstruction)
-    {
-        IntegerValue indexValue = stack.ipop();
-
-        // If there is no definite branch in any of the cases below,
-        // branch to the default offset.
-        branchUnit.branch(clazz, codeAttribute,
-                          offset,
-                          offset + lookUpSwitchInstruction.defaultOffset);
-
-        for (int index = 0; index < lookUpSwitchInstruction.jumpOffsets.length; index++)
-        {
-            int conditional = indexValue.equal(valueFactory.createIntegerValue(
-                lookUpSwitchInstruction.cases[index]));
-            branchUnit.branchConditionally(clazz, codeAttribute,
-                                           offset,
-                                           offset + lookUpSwitchInstruction.jumpOffsets[index],
-                                           conditional);
-
-            // If this branch is always taken, we can skip the rest.
-            if (conditional == Value.ALWAYS)
-            {
-                break;
-            }
-        }
-    }
-}