proguard.classfile.instruction.visitor.InstructionVisitor Java Examples

/**
 * Creates an array of InstructionSequenceReplacer instances.
 * @param patternConstants        any constants referenced by the pattern
 *                                instruction.
 * @param instructionSequences    the instruction sequences to be replaced,
 *                                with subsequently the sequence pair index,
 *                                the from/to index (0 or 1), and the
 *                                instruction index in the sequence.
 * @param branchTargetFinder      a branch target finder that has been
 *                                initialized to indicate branch targets
 *                                in the visited code.
 * @param codeAttributeEditor     a code editor that can be used for
 *                                accumulating changes to the code.
 * @param extraInstructionVisitor an optional extra visitor for all deleted
 *                                load instructions.
 */
private static InstructionVisitor[] createInstructionSequenceReplacers(Constant[]          patternConstants,
                                                                       Instruction[][][]   instructionSequences,
                                                                       BranchTargetFinder  branchTargetFinder,
                                                                       CodeAttributeEditor codeAttributeEditor,
                                                                       InstructionVisitor extraInstructionVisitor)
{
    InstructionVisitor[] instructionSequenceReplacers =
        new InstructionSequenceReplacer[instructionSequences.length];

    for (int index = 0; index < instructionSequenceReplacers.length; index++)
    {
        Instruction[][] instructionSequencePair = instructionSequences[index];
        instructionSequenceReplacers[index] =
            new InstructionSequenceReplacer(patternConstants,
                                            instructionSequencePair[PATTERN_INDEX],
                                            instructionSequencePair[REPLACEMENT_INDEX],
                                            branchTargetFinder,
                                            codeAttributeEditor,
                                            extraInstructionVisitor);
    }

    return instructionSequenceReplacers;
}
 

public void accept(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, InstructionVisitor instructionVisitor)
{
    if (instructionVisitor != CodeAttributeEditor.this)
    {
        throw new UnsupportedOperationException("Unexpected visitor ["+instructionVisitor+"]");
    }

    for (int index = 0; index < instructions.length; index++)
    {
        Instruction instruction = instructions[index];

        instruction.accept(clazz, method, codeAttribute, offset, CodeAttributeEditor.this);

        offset += instruction.length(offset);
    }
}
 

public ConfigurationLoggingInstructionSequenceReplacer(InstructionSequenceMatcher instructionSequenceMatcher,
                                                       Constant[]                 patternConstants,
                                                       Instruction[]              patternInstructions,
                                                       Constant[]                 replacementConstants,
                                                       Instruction[]              replacementInstructions,
                                                       BranchTargetFinder         branchTargetFinder,
                                                       CodeAttributeEditor        codeAttributeEditor,
                                                       InstructionVisitor         extraInstructionVisitor    )
{
    super(instructionSequenceMatcher,
          patternConstants,
          patternInstructions,
          replacementConstants,
          replacementInstructions,
          branchTargetFinder,
          codeAttributeEditor,
          extraInstructionVisitor    );
}
 

public ConfigurationLoggingInstructionSequenceReplacer(Constant[]          patternConstants,
                                                       Instruction[]       patternInstructions,
                                                       Constant[]          replacementConstants,
                                                       Instruction[]       replacementInstructions,
                                                       BranchTargetFinder  branchTargetFinder,
                                                       CodeAttributeEditor codeAttributeEditor,
                                                       InstructionVisitor  extraInstructionVisitor )
{
    super(patternConstants,
          patternInstructions,
          replacementConstants,
          replacementInstructions,
          branchTargetFinder,
          codeAttributeEditor,
          extraInstructionVisitor );
}
 

public void accept(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, InstructionVisitor instructionVisitor)
{
    if (instructionVisitor != CodeAttributeEditor.this)
    {
        throw new UnsupportedOperationException("Unexpected visitor ["+instructionVisitor+"]");
    }

    for (int index = 0; index < instructions.length; index++)
    {
        Instruction instruction = instructions[index];

        instruction.accept(clazz, method, codeAttribute, offset, CodeAttributeEditor.this);

        offset += instruction.length(offset);
    }
}
 

/**
 * Creates a new InstructionSequenceReplacer.
 * @param patternConstants        any constants referenced by the pattern
 *                                instruction.
 * @param branchTargetFinder      a branch target finder that has been
 *                                initialized to indicate branch targets
 *                                in the visited code.
 * @param codeAttributeEditor     a code editor that can be used for
 *                                accumulating changes to the code.
 * @param extraInstructionVisitor an optional extra visitor for all deleted
 *                                load instructions.
 */
public InstructionSequenceReplacer(Constant[]          patternConstants,
                                   Instruction[]       patternInstructions,
                                   Instruction[]       replacementInstructions,
                                   BranchTargetFinder  branchTargetFinder,
                                   CodeAttributeEditor codeAttributeEditor,
                                   InstructionVisitor  extraInstructionVisitor)
{
    this.instructionSequenceMatcher = new InstructionSequenceMatcher(patternConstants, patternInstructions);
    this.patternConstants           = patternConstants;
    this.replacementInstructions    = replacementInstructions;
    this.branchTargetFinder         = branchTargetFinder;
    this.codeAttributeEditor        = codeAttributeEditor;
    this.extraInstructionVisitor    = extraInstructionVisitor;
}
 

/**
 * Creates a new InstructionSequenceReplacer.
 * @param patternConstants        any constants referenced by the pattern
 *                                instruction.
 * @param branchTargetFinder      a branch target finder that has been
 *                                initialized to indicate branch targets
 *                                in the visited code.
 * @param codeAttributeEditor     a code editor that can be used for
 *                                accumulating changes to the code.
 * @param extraInstructionVisitor an optional extra visitor for all deleted
 *                                load instructions.
 */
public InstructionSequenceReplacer(Constant[]          patternConstants,
                                   Instruction[]       patternInstructions,
                                   Instruction[]       replacementInstructions,
                                   BranchTargetFinder  branchTargetFinder,
                                   CodeAttributeEditor codeAttributeEditor,
                                   InstructionVisitor extraInstructionVisitor)
{
    this.instructionSequenceMatcher = new InstructionSequenceMatcher(patternConstants, patternInstructions);
    this.replacementInstructions    = replacementInstructions;
    this.branchTargetFinder         = branchTargetFinder;
    this.codeAttributeEditor        = codeAttributeEditor;
    this.extraInstructionVisitor    = extraInstructionVisitor;
}
 

/**
 * Applies the given instruction visitor to all instructions in the
 * specified range of offsets.
 */
public void instructionsAccept(Clazz clazz, Method method, int startOffset, int endOffset, InstructionVisitor instructionVisitor)
{
    int offset = startOffset;

    while (offset < endOffset)
    {
        // Note that the instruction is only volatile.
        Instruction instruction = InstructionFactory.create(code, offset);
        int instructionLength = instruction.length(offset);
        instruction.accept(clazz, method, this, offset, instructionVisitor);
        offset += instructionLength;
    }
}
 

/**
 * Create a new AbstractAPIConverter instance.
 */
AbstractAPIConverter(ClassPool          programClassPool,
                     ClassPool          libraryClassPool,
                     WarningPrinter     warningPrinter,
                     ClassVisitor       modifiedClassVisitor,
                     InstructionVisitor extraInstructionVisitor)
{
    this.programClassPool        = programClassPool;
    this.libraryClassPool        = libraryClassPool;
    this.warningPrinter          = warningPrinter;
    this.modifiedClassVisitor    = modifiedClassVisitor;
    this.extraInstructionVisitor = extraInstructionVisitor;
}
 

/**
 * Create a new JSR310Converter instance.
 */
public JSR310Converter(ClassPool          programClassPool,
                       ClassPool          libraryClassPool,
                       WarningPrinter     warningPrinter,
                       ClassVisitor       modifiedClassVisitor,
                       InstructionVisitor extraInstructionVisitor)
{
    super(programClassPool,
          libraryClassPool,
          warningPrinter,
          modifiedClassVisitor,
          extraInstructionVisitor);

    TypeReplacement[] typeReplacements = new TypeReplacement[]
    {
        // java.time package has been added in Java 8
        replace("java/time/**", "org/threeten/bp/<1>"),
    };

    MethodReplacement[] methodReplacements = new MethodReplacement[]
    {
        // all classes in java.time.** are converted to
        // org.threeeten.bp.**.
        replace("java/time/**",        "**",  "**",
                "org/threeten/bp/<1>", "<1>", "<1>"),
    };

    setTypeReplacements(typeReplacements);
    setMethodReplacements(methodReplacements);
}
 

/**
 * Creates a new InstructionSequenceReplacer.
 * @param patternConstants        any constants referenced by the pattern
 *                                instruction.
 * @param branchTargetFinder      a branch target finder that has been
 *                                initialized to indicate branch targets
 *                                in the visited code.
 * @param codeAttributeEditor     a code editor that can be used for
 *                                accumulating changes to the code.
 * @param extraInstructionVisitor an optional extra visitor for all deleted
 *                                load instructions.
 */
public InstructionSequenceReplacer(Constant[]          patternConstants,
                                   Instruction[]       patternInstructions,
                                   Instruction[]       replacementInstructions,
                                   BranchTargetFinder  branchTargetFinder,
                                   CodeAttributeEditor codeAttributeEditor,
                                   InstructionVisitor  extraInstructionVisitor)
{
    this.instructionSequenceMatcher = new InstructionSequenceMatcher(patternConstants, patternInstructions);
    this.patternConstants           = patternConstants;
    this.replacementInstructions    = replacementInstructions;
    this.branchTargetFinder         = branchTargetFinder;
    this.codeAttributeEditor        = codeAttributeEditor;
    this.extraInstructionVisitor    = extraInstructionVisitor;
}
 

/**
 * Applies the given instruction visitor to all instructions in the
 * specified range of offsets.
 */
public void instructionsAccept(Clazz clazz, Method method, int startOffset, int endOffset, InstructionVisitor instructionVisitor)
{
    int offset = startOffset;

    while (offset < endOffset)
    {
        // Note that the instruction is only volatile.
        Instruction instruction = InstructionFactory.create(code, offset);
        int instructionLength = instruction.length(offset);
        instruction.accept(clazz, method, this, offset, instructionVisitor);
        offset += instructionLength;
    }
}
 

public void accept(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, InstructionVisitor instructionVisitor)
{
    instructionVisitor.visitLookUpSwitchInstruction(clazz, method, codeAttribute, offset, this);
}
 

public void accept(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, InstructionVisitor instructionVisitor)
{
    instructionVisitor.visitBranchInstruction(clazz, method, codeAttribute, offset, this);
}
 

public void accept(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, InstructionVisitor instructionVisitor)
{
    instructionVisitor.visitTableSwitchInstruction(clazz, method, codeAttribute, offset, this);
}
 

public void accept(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, InstructionVisitor instructionVisitor)
{
    instructionVisitor.visitSimpleInstruction(clazz, method, codeAttribute, offset, this);
}
 

public void accept(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, InstructionVisitor instructionVisitor)
{
    instructionVisitor.visitConstantInstruction(clazz, method, codeAttribute, offset, this);
}
 

public void accept(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, InstructionVisitor instructionVisitor)
{
    instructionVisitor.visitVariableInstruction(clazz, method, codeAttribute, offset, this);
}
 

/**
 * Returns a filtering version of the given instruction visitor that only
 * visits necessary instructions.
 */
public InstructionVisitor necessaryInstructionFilter(InstructionVisitor instructionVisitor)
{
    return necessaryInstructionFilter(true, instructionVisitor);
}
 

/**
 * Applies the given instruction visitor to all instructions.
 */
public void instructionsAccept(Clazz clazz, Method method, InstructionVisitor instructionVisitor)
{
    instructionsAccept(clazz, method, 0, u4codeLength, instructionVisitor);
}
 

/**
 * Applies the given instruction visitor to the instruction at the specified
 * offset.
 */
public void instructionAccept(Clazz clazz, Method method, int offset, InstructionVisitor instructionVisitor)
{
    Instruction instruction = InstructionFactory.create(code, offset);
    instruction.accept(clazz, method, this, offset, instructionVisitor);
}
 

/**
 * Returns a filtering version of the given instruction visitor that only
 * visits traced or untraced instructions.
 */
public InstructionVisitor tracedInstructionFilter(boolean            traced,
                                                  InstructionVisitor instructionVisitor)
{
    return partialEvaluator.tracedInstructionFilter(traced, instructionVisitor);
}
 

public void accept(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, InstructionVisitor instructionVisitor)
{
    instructionVisitor.visitVariableInstruction(clazz, method, codeAttribute, offset, this);
}
 

public void accept(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, InstructionVisitor instructionVisitor)
{
    instructionVisitor.visitConstantInstruction(clazz, method, codeAttribute, offset, this);
}
 

public void accept(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, InstructionVisitor instructionVisitor)
{
    instructionVisitor.visitLookUpSwitchInstruction(clazz, method, codeAttribute, offset, this);
}
 

public void accept(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, InstructionVisitor instructionVisitor)
{
    instructionVisitor.visitTableSwitchInstruction(clazz, method, codeAttribute, offset, this);
}
 

public void accept(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, InstructionVisitor instructionVisitor)
{
    instructionVisitor.visitSimpleInstruction(clazz, method, codeAttribute, offset, this);
}
 

public void accept(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, InstructionVisitor instructionVisitor)
{
    instructionVisitor.visitBranchInstruction(clazz, method, codeAttribute, offset, this);
}
 

public void accept(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, InstructionVisitor instructionVisitor)
{
    instructionVisitor.visitVariableInstruction(clazz, method, codeAttribute, offset, this);
}
 

public void accept(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, InstructionVisitor instructionVisitor)
{
    instructionVisitor.visitConstantInstruction(clazz, method, codeAttribute, offset, this);
}