sometsome 3.10.49 → 3.10.50.36

data/lib/proguard4.7/src/proguard/classfile/util/ExternalTypeEnumeration.java

@@ -1,106 +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.classfile.util;
-
-import proguard.classfile.ClassConstants;
-
-
-/**
- * An <code>ExternalTypeEnumeration</code> provides an enumeration of all
- * types listed in a given external descriptor string. The method name can
- * be retrieved separately.
- * <p>
- * A <code>ExternalTypeEnumeration</code> object can be reused for processing
- * different subsequent descriptors, by means of the <code>setDescriptor</code>
- * method.
- *
- * @author Eric Lafortune
- */
-public class ExternalTypeEnumeration
-{
-    private String descriptor;
-    private int    index;
-
-
-    public ExternalTypeEnumeration(String descriptor)
-    {
-        setDescriptor(descriptor);
-    }
-
-
-    ExternalTypeEnumeration()
-    {
-    }
-
-
-    void setDescriptor(String descriptor)
-    {
-        this.descriptor = descriptor;
-
-        reset();
-    }
-
-
-    public void reset()
-    {
-        index = descriptor.indexOf(ClassConstants.EXTERNAL_METHOD_ARGUMENTS_OPEN) + 1;
-
-        if (index < 1)
-        {
-            throw new IllegalArgumentException("Missing opening parenthesis in descriptor ["+descriptor+"]");
-        }
-    }
-
-
-    public boolean hasMoreTypes()
-    {
-        return index < descriptor.length() - 1;
-    }
-
-
-    public String nextType()
-    {
-        int startIndex = index;
-
-        // Find the next separating comma.
-        index = descriptor.indexOf(ClassConstants.EXTERNAL_METHOD_ARGUMENTS_SEPARATOR,
-                                   startIndex);
-
-        // Otherwise find the closing parenthesis.
-        if (index < 0)
-        {
-            index = descriptor.indexOf(ClassConstants.EXTERNAL_METHOD_ARGUMENTS_CLOSE,
-                                       startIndex);
-            if (index < 0)
-            {
-                throw new IllegalArgumentException("Missing closing parenthesis in descriptor ["+descriptor+"]");
-            }
-        }
-
-        return descriptor.substring(startIndex, index++).trim();
-    }
-
-
-    public String methodName()
-    {
-        return descriptor.substring(0, descriptor.indexOf(ClassConstants.EXTERNAL_METHOD_ARGUMENTS_OPEN)).trim();
-    }
-}

data/lib/proguard4.7/src/proguard/classfile/util/InstructionSequenceMatcher.java

@@ -1,754 +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.classfile.util;
-
-import proguard.classfile.*;
-import proguard.classfile.attribute.CodeAttribute;
-import proguard.classfile.constant.*;
-import proguard.classfile.constant.visitor.ConstantVisitor;
-import proguard.classfile.instruction.*;
-import proguard.classfile.instruction.visitor.InstructionVisitor;
-
-import java.util.Arrays;
-
-/**
- * This InstructionVisitor checks whether a given pattern instruction sequence
- * occurs in the instructions that are visited. The arguments of the
- * instruction sequence can be wildcards that are matched.
- *
- * @author Eric Lafortune
- */
-public class InstructionSequenceMatcher
-extends      SimplifiedVisitor
-implements   InstructionVisitor,
-             ConstantVisitor
-{
-    /*
-    public  static       boolean DEBUG      = true;
-    public  static       boolean DEBUG_MORE = true;
-    /*/
-    private static final boolean DEBUG      = false;
-    private static final boolean DEBUG_MORE = false;
-    //*/
-
-    public static final int X = 0x40000000;
-    public static final int Y = 0x40000001;
-    public static final int Z = 0x40000002;
-
-    public static final int A = 0x40000003;
-    public static final int B = 0x40000004;
-    public static final int C = 0x40000005;
-    public static final int D = 0x40000006;
-
-
-    private final Constant[]    patternConstants;
-    private final Instruction[] patternInstructions;
-
-    private boolean      matching;
-    private int          patternInstructionIndex;
-    private final int[]  matchedInstructionOffsets;
-    private int          matchedArgumentFlags;
-    private final int[]  matchedArguments = new int[7];
-    private final long[] matchedConstantFlags;
-    private final int[]  matchedConstantIndices;
-    private int          constantFlags;
-    private int          previousConstantFlags;
-
-    // Fields acting as a parameter and a return value for visitor methods.
-    private Constant patternConstant;
-    private boolean  matchingConstant;
-
-
-    /**
-     * Creates a new InstructionSequenceMatcher.
-     * @param patternConstants        any constants referenced by the pattern
-     *                                instruction.
-     * @param patternInstructions     the pattern instruction sequence.
-     */
-    public InstructionSequenceMatcher(Constant[]    patternConstants,
-                                      Instruction[] patternInstructions)
-    {
-        this.patternConstants    = patternConstants;
-        this.patternInstructions = patternInstructions;
-
-        matchedInstructionOffsets = new int[patternInstructions.length];
-        matchedConstantFlags      = new long[(patternConstants.length + 63) / 64];
-        matchedConstantIndices    = new int[patternConstants.length];
-    }
-
-
-    /**
-     * Starts matching from the first instruction again next time.
-     */
-    public void reset()
-    {
-        patternInstructionIndex = 0;
-        matchedArgumentFlags    = 0;
-
-        Arrays.fill(matchedConstantFlags, 0L);
-
-        previousConstantFlags = constantFlags;
-        constantFlags         = 0;
-    }
-
-
-    /**
-     * Returns whether the complete pattern sequence has been matched.
-     */
-    public boolean isMatching()
-    {
-        return matching;
-    }
-
-
-    /**
-     * Returns the number of instructions in the pattern sequence.
-     */
-    public int instructionCount()
-    {
-        return patternInstructions.length;
-    }
-
-
-    /**
-     * Returns the matched instruction offset of the specified pattern
-     * instruction.
-     */
-    public int matchedInstructionOffset(int index)
-    {
-        return matchedInstructionOffsets[index];
-    }
-
-
-    /**
-     * Returns whether the specified wildcard argument was a constant from
-     * the constant pool in the most recent match.
-     */
-    public boolean wasConstant(int argument)
-    {
-        return (previousConstantFlags & (1 << (argument - X))) != 0;
-    }
-
-
-    /**
-     * Returns the value of the specified matched argument (wildcard or not).
-     */
-    public int matchedArgument(int argument)
-    {
-        int argumentIndex = argument - X;
-        return argumentIndex < 0 ?
-            argument :
-            matchedArguments[argumentIndex];
-    }
-
-
-    /**
-     * Returns the values of the specified matched arguments (wildcard or not).
-     */
-    public int[] matchedArguments(int[] arguments)
-    {
-        int[] matchedArguments = new int[arguments.length];
-
-        for (int index = 0; index < arguments.length; index++)
-        {
-            matchedArguments[index] = matchedArgument(arguments[index]);
-        }
-
-        return matchedArguments;
-    }
-
-
-    /**
-     * Returns the index of the specified matched constant (wildcard or not).
-     */
-    public int matchedConstantIndex(int constantIndex)
-    {
-        int argumentIndex = constantIndex - X;
-        return argumentIndex < 0 ?
-            matchedConstantIndices[constantIndex] :
-            matchedArguments[argumentIndex];
-    }
-
-
-    /**
-     * Returns the value of the specified matched branch offset (wildcard or
-     * not).
-     */
-    public int matchedBranchOffset(int offset, int branchOffset)
-    {
-        int argumentIndex = branchOffset - X;
-        return argumentIndex < 0 ?
-            branchOffset :
-            matchedArguments[argumentIndex] - offset;
-    }
-
-
-    /**
-     * Returns the values of the specified matched jump offsets (wildcard or
-     * not).
-     */
-    public int[] matchedJumpOffsets(int offset, int[] jumpOffsets)
-    {
-        int[] matchedJumpOffsets = new int[jumpOffsets.length];
-
-        for (int index = 0; index < jumpOffsets.length; index++)
-        {
-            matchedJumpOffsets[index] = matchedBranchOffset(offset,
-                                                            jumpOffsets[index]);
-        }
-
-        return matchedJumpOffsets;
-    }
-
-
-    // Implementations for InstructionVisitor.
-
-    public void visitSimpleInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, SimpleInstruction simpleInstruction)
-    {
-        Instruction patternInstruction = patternInstructions[patternInstructionIndex];
-
-        // Check if the instruction matches the next instruction in the sequence.
-        boolean condition =
-            matchingOpcodes(simpleInstruction, patternInstruction) &&
-            matchingArguments(simpleInstruction.constant,
-                              ((SimpleInstruction)patternInstruction).constant);
-
-        // Check if the instruction sequence is matching now.
-        checkMatch(condition,
-                   clazz,
-                   method,
-                   codeAttribute,
-                   offset,
-                   simpleInstruction);
-    }
-
-
-    public void visitVariableInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, VariableInstruction variableInstruction)
-    {
-        Instruction patternInstruction = patternInstructions[patternInstructionIndex];
-
-        // Check if the instruction matches the next instruction in the sequence.
-        boolean condition =
-            matchingOpcodes(variableInstruction, patternInstruction) &&
-            matchingArguments(variableInstruction.variableIndex,
-                              ((VariableInstruction)patternInstruction).variableIndex) &&
-            matchingArguments(variableInstruction.constant,
-                              ((VariableInstruction)patternInstruction).constant);
-
-        // Check if the instruction sequence is matching now.
-        checkMatch(condition,
-                   clazz,
-                   method,
-                   codeAttribute,
-                   offset,
-                   variableInstruction);
-    }
-
-
-    public void visitConstantInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, ConstantInstruction constantInstruction)
-    {
-        Instruction patternInstruction = patternInstructions[patternInstructionIndex];
-
-        // Check if the instruction matches the next instruction in the sequence.
-        boolean condition =
-            matchingOpcodes(constantInstruction, patternInstruction) &&
-            matchingConstantIndices(clazz,
-                                    constantInstruction.constantIndex,
-                                    ((ConstantInstruction)patternInstruction).constantIndex) &&
-            matchingArguments(constantInstruction.constant,
-                              ((ConstantInstruction)patternInstruction).constant);
-
-        // Check if the instruction sequence is matching now.
-        checkMatch(condition,
-                   clazz,
-                   method,
-                   codeAttribute,
-                   offset,
-                   constantInstruction);
-    }
-
-
-    public void visitBranchInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, BranchInstruction branchInstruction)
-    {
-        Instruction patternInstruction = patternInstructions[patternInstructionIndex];
-
-        // Check if the instruction matches the next instruction in the from
-        // sequence.
-        boolean condition =
-            matchingOpcodes(branchInstruction, patternInstruction) &&
-            matchingBranchOffsets(offset,
-                                  branchInstruction.branchOffset,
-                                  ((BranchInstruction)patternInstruction).branchOffset);
-
-        // Check if the instruction sequence is matching now.
-        checkMatch(condition,
-                   clazz,
-                   method,
-                   codeAttribute,
-                   offset,
-                   branchInstruction);
-    }
-
-
-    public void visitTableSwitchInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, TableSwitchInstruction tableSwitchInstruction)
-    {
-        Instruction patternInstruction = patternInstructions[patternInstructionIndex];
-
-        // Check if the instruction matches the next instruction in the sequence.
-        boolean condition =
-            matchingOpcodes(tableSwitchInstruction, patternInstruction) &&
-            matchingBranchOffsets(offset,
-                                  tableSwitchInstruction.defaultOffset,
-                                  ((TableSwitchInstruction)patternInstruction).defaultOffset) &&
-            matchingArguments(tableSwitchInstruction.lowCase,
-                              ((TableSwitchInstruction)patternInstruction).lowCase)  &&
-            matchingArguments(tableSwitchInstruction.highCase,
-                              ((TableSwitchInstruction)patternInstruction).highCase) &&
-            matchingJumpOffsets(offset,
-                                tableSwitchInstruction.jumpOffsets,
-                                ((TableSwitchInstruction)patternInstruction).jumpOffsets);
-
-        // Check if the instruction sequence is matching now.
-        checkMatch(condition,
-                   clazz,
-                   method,
-                   codeAttribute,
-                   offset,
-                   tableSwitchInstruction);
-    }
-
-
-    public void visitLookUpSwitchInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, LookUpSwitchInstruction lookUpSwitchInstruction)
-    {
-        Instruction patternInstruction = patternInstructions[patternInstructionIndex];
-
-        // Check if the instruction matches the next instruction in the sequence.
-        boolean condition =
-            matchingOpcodes(lookUpSwitchInstruction, patternInstruction) &&
-            matchingBranchOffsets(offset,
-                                  lookUpSwitchInstruction.defaultOffset,
-                                  ((LookUpSwitchInstruction)patternInstruction).defaultOffset) &&
-            matchingArguments(lookUpSwitchInstruction.cases,
-                              ((LookUpSwitchInstruction)patternInstruction).cases) &&
-            matchingJumpOffsets(offset,
-                                lookUpSwitchInstruction.jumpOffsets,
-                                ((LookUpSwitchInstruction)patternInstruction).jumpOffsets);
-
-        // Check if the instruction sequence is matching now.
-        checkMatch(condition,
-                   clazz,
-                   method,
-                   codeAttribute,
-                   offset,
-                   lookUpSwitchInstruction);
-    }
-
-
-    // Implementations for ConstantVisitor.
-
-    public void visitIntegerConstant(Clazz clazz, IntegerConstant integerConstant)
-    {
-        IntegerConstant integerPatternConstant = (IntegerConstant)patternConstant;
-
-        // Compare the integer values.
-        matchingConstant = integerConstant.getValue() ==
-                           integerPatternConstant.getValue();
-    }
-
-
-    public void visitLongConstant(Clazz clazz, LongConstant longConstant)
-    {
-        LongConstant longPatternConstant = (LongConstant)patternConstant;
-
-        // Compare the long values.
-        matchingConstant = longConstant.getValue() ==
-                           longPatternConstant.getValue();
-    }
-
-
-    public void visitFloatConstant(Clazz clazz, FloatConstant floatConstant)
-    {
-        FloatConstant floatPatternConstant = (FloatConstant)patternConstant;
-
-        // Compare the float values.
-        matchingConstant = floatConstant.getValue() ==
-                           floatPatternConstant.getValue();
-    }
-
-
-    public void visitDoubleConstant(Clazz clazz, DoubleConstant doubleConstant)
-    {
-        DoubleConstant doublePatternConstant = (DoubleConstant)patternConstant;
-
-        // Compare the double values.
-        matchingConstant = doubleConstant.getValue() ==
-                           doublePatternConstant.getValue();
-    }
-
-
-    public void visitStringConstant(Clazz clazz, StringConstant stringConstant)
-    {
-        StringConstant stringPatternConstant = (StringConstant)patternConstant;
-
-        // Check the UTF-8 constant.
-        matchingConstant =
-            matchingConstantIndices(clazz,
-                                    stringConstant.u2stringIndex,
-                                    stringPatternConstant.u2stringIndex);
-    }
-
-
-    public void visitUtf8Constant(Clazz clazz, Utf8Constant utf8Constant)
-    {
-        Utf8Constant utf8PatternConstant = (Utf8Constant)patternConstant;
-
-        // Compare the actual strings.
-        matchingConstant = utf8Constant.getString().equals(
-                           utf8PatternConstant.getString());
-    }
-
-
-    public void visitInvokeDynamicConstant(Clazz clazz, InvokeDynamicConstant invokeDynamicConstant)
-    {
-        InvokeDynamicConstant invokeDynamicPatternConstant = (InvokeDynamicConstant)patternConstant;
-
-        // Check the bootstrap method and the name and type.
-        matchingConstant =
-            matchingConstantIndices(clazz,
-                                    invokeDynamicConstant.getBootstrapMethodAttributeIndex(),
-                                    invokeDynamicPatternConstant.getBootstrapMethodAttributeIndex()) &&
-            matchingConstantIndices(clazz,
-                                    invokeDynamicConstant.getNameAndTypeIndex(),
-                                    invokeDynamicPatternConstant.getNameAndTypeIndex());
-    }
-
-
-    public void visitMethodHandleConstant(Clazz clazz, MethodHandleConstant methodHandleConstant)
-    {
-        MethodHandleConstant methodHandlePatternConstant = (MethodHandleConstant)patternConstant;
-
-        // Check the handle type and the name and type.
-        matchingConstant =
-            matchingArguments(methodHandleConstant.getReferenceKind(),
-                              methodHandlePatternConstant.getReferenceKind()) &&
-            matchingConstantIndices(clazz,
-                                    methodHandleConstant.getReferenceIndex(),
-                                    methodHandlePatternConstant.getReferenceIndex());
-    }
-
-
-    public void visitAnyRefConstant(Clazz clazz, RefConstant refConstant)
-    {
-        RefConstant refPatternConstant = (RefConstant)patternConstant;
-
-        // Check the class and the name and type.
-        matchingConstant =
-            matchingConstantIndices(clazz,
-                                    refConstant.getClassIndex(),
-                                    refPatternConstant.getClassIndex()) &&
-            matchingConstantIndices(clazz,
-                                    refConstant.getNameAndTypeIndex(),
-                                    refPatternConstant.getNameAndTypeIndex());
-    }
-
-
-    public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
-    {
-        ClassConstant classPatternConstant = (ClassConstant)patternConstant;
-
-        // Check the class name.
-        matchingConstant =
-            matchingConstantIndices(clazz,
-                                    classConstant.u2nameIndex,
-                                    classPatternConstant.u2nameIndex);
-    }
-
-
-    public void visitMethodTypeConstant(Clazz clazz, MethodTypeConstant methodTypeConstant)
-    {
-        MethodTypeConstant typePatternConstant = (MethodTypeConstant)patternConstant;
-
-        // Check the descriptor.
-        matchingConstant =
-            matchingConstantIndices(clazz,
-                                    methodTypeConstant.u2descriptorIndex,
-                                    typePatternConstant.u2descriptorIndex);
-    }
-
-
-    public void visitNameAndTypeConstant(Clazz clazz, NameAndTypeConstant nameAndTypeConstant)
-    {
-        NameAndTypeConstant typePatternConstant = (NameAndTypeConstant)patternConstant;
-
-        // Check the name and the descriptor.
-        matchingConstant =
-            matchingConstantIndices(clazz,
-                                    nameAndTypeConstant.u2nameIndex,
-                                    typePatternConstant.u2nameIndex) &&
-            matchingConstantIndices(clazz,
-                                    nameAndTypeConstant.u2descriptorIndex,
-                                    typePatternConstant.u2descriptorIndex);
-    }
-
-
-    // Small utility methods.
-
-    private boolean matchingOpcodes(Instruction instruction1,
-                                    Instruction instruction2)
-    {
-        // Check the opcode.
-        return instruction1.opcode            == instruction2.opcode ||
-               instruction1.canonicalOpcode() == instruction2.opcode;
-    }
-
-
-    private boolean matchingArguments(int argument1,
-                                      int argument2)
-    {
-        int argumentIndex = argument2 - X;
-        if (argumentIndex < 0)
-        {
-            // Check the literal argument.
-            return argument1 == argument2;
-        }
-        else if (!isMatchingArgumentIndex(argumentIndex))
-        {
-            // Store the wildcard argument.
-            setMatchingArgument(argumentIndex, argument1);
-
-            return true;
-        }
-        else
-        {
-            // Check the previously stored wildcard argument.
-            return matchedArguments[argumentIndex] == argument1;
-        }
-    }
-
-
-    /**
-     * Marks the specified argument (by index) as matching the specified
-     * argument value.
-     */
-    private void setMatchingArgument(int argumentIndex,
-                                     int argument)
-    {
-        matchedArguments[argumentIndex] = argument;
-        matchedArgumentFlags |= 1 << argumentIndex;
-    }
-
-
-    /**
-     * Returns whether the specified wildcard argument (by index) has been
-     * matched.
-     */
-    private boolean isMatchingArgumentIndex(int argumentIndex)
-    {
-        return (matchedArgumentFlags & (1 << argumentIndex)) != 0;
-    }
-
-
-    private boolean matchingArguments(int[] arguments1,
-                                      int[] arguments2)
-    {
-        if (arguments1.length != arguments2.length)
-        {
-            return false;
-        }
-
-        for (int index = 0; index < arguments1.length; index++)
-        {
-            if (!matchingArguments(arguments1[index], arguments2[index]))
-            {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-
-    private boolean matchingConstantIndices(Clazz clazz,
-                                            int   constantIndex1,
-                                            int   constantIndex2)
-    {
-        if (constantIndex2 >= X)
-        {
-            // Remember that we are trying to match a constant.
-            constantFlags |= 1 << (constantIndex2 - X);
-
-            // Check the constant index.
-            return matchingArguments(constantIndex1, constantIndex2);
-        }
-        else if (!isMatchingConstantIndex(constantIndex2))
-        {
-            // Check the actual constant.
-            matchingConstant = false;
-            patternConstant  = patternConstants[constantIndex2];
-
-            if (clazz.getTag(constantIndex1) == patternConstant.getTag())
-            {
-                clazz.constantPoolEntryAccept(constantIndex1, this);
-
-                if (matchingConstant)
-                {
-                    // Store the constant index.
-                    setMatchingConstant(constantIndex2, constantIndex1);
-                }
-            }
-
-            return matchingConstant;
-        }
-        else
-        {
-            // Check a previously stored constant index.
-            return matchedConstantIndices[constantIndex2] == constantIndex1;
-        }
-    }
-
-
-    /**
-     * Marks the specified constant (by index) as matching the specified
-     * constant index value.
-     */
-    private void setMatchingConstant(int constantIndex,
-                                     int constantIndex1)
-    {
-        matchedConstantIndices[constantIndex] = constantIndex1;
-        matchedConstantFlags[constantIndex / 64] |= 1L << constantIndex;
-    }
-
-
-    /**
-     * Returns whether the specified wildcard constant has been matched.
-     */
-    private boolean isMatchingConstantIndex(int constantIndex)
-    {
-        return (matchedConstantFlags[constantIndex / 64] & (1L << constantIndex)) != 0;
-    }
-
-
-    private boolean matchingBranchOffsets(int offset,
-                                          int branchOffset1,
-                                          int branchOffset2)
-    {
-        int argumentIndex = branchOffset2 - X;
-        if (argumentIndex < 0)
-        {
-            // Check the literal argument.
-            return branchOffset1 == branchOffset2;
-        }
-        else if (!isMatchingArgumentIndex(argumentIndex))
-        {
-            // Store a wildcard argument.
-            setMatchingArgument(argumentIndex, offset + branchOffset1);
-
-            return true;
-        }
-        else
-        {
-            // Check the previously stored wildcard argument.
-            return matchedArguments[argumentIndex] == offset + branchOffset1;
-        }
-    }
-
-
-    private boolean matchingJumpOffsets(int   offset,
-                                        int[] jumpOffsets1,
-                                        int[] jumpOffsets2)
-    {
-        if (jumpOffsets1.length != jumpOffsets2.length)
-        {
-            return false;
-        }
-
-        for (int index = 0; index < jumpOffsets1.length; index++)
-        {
-            if (!matchingBranchOffsets(offset,
-                                       jumpOffsets1[index],
-                                       jumpOffsets2[index]))
-            {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-
-    private void checkMatch(boolean       condition,
-                            Clazz         clazz,
-                            Method        method,
-                            CodeAttribute codeAttribute,
-                            int           offset,
-                            Instruction   instruction)
-    {
-        if (DEBUG_MORE)
-        {
-            System.out.println("InstructionSequenceMatcher: ["+clazz.getName()+"."+method.getName(clazz)+method.getDescriptor(clazz)+"]: "+patternInstructions[patternInstructionIndex].toString(patternInstructionIndex)+(condition?"\t== ":"\t   ")+instruction.toString(offset));
-        }
-
-        // Did the instruction match?
-        if (condition)
-        {
-            // Remember the offset of the matching instruction.
-            matchedInstructionOffsets[patternInstructionIndex] = offset;
-
-            // Try to match the next instruction next time.
-            patternInstructionIndex++;
-
-            // Did we match all instructions in the sequence?
-            matching = patternInstructionIndex == patternInstructions.length;
-
-            if (matching)
-            {
-                if (DEBUG)
-                {
-                    System.out.println("InstructionSequenceMatcher: ["+clazz.getName()+"."+method.getName(clazz)+method.getDescriptor(clazz)+"]");
-                    for (int index = 0; index < patternInstructionIndex; index++)
-                    {
-                        System.out.println("    "+InstructionFactory.create(codeAttribute.code, matchedInstructionOffsets[index]).toString(matchedInstructionOffsets[index]));
-                    }
-                }
-
-                // Start matching from the first instruction again next time.
-                reset();
-            }
-        }
-        else
-        {
-            // The instruction didn't match.
-            matching = false;
-
-            // Is this a failed second instruction?
-            boolean retry = patternInstructionIndex == 1;
-
-            // Start matching from the first instruction next time.
-            reset();
-
-            // Retry a failed second instruction as a first instruction.
-            if (retry)
-            {
-                instruction.accept(clazz, method, codeAttribute, offset, this);
-            }
-        }
-    }
-}