Public

<init>

visitLabel

visitSwitchInsn

Adds a successor to the #currentBlock ast.

addSuccessor

Checks if the visit of the current frame #frame is finished, and if yes, write
it in the StackMapTab

endFrame

Returns the size of the bytecode of this method.

getSize

Ends the current basic ast. This method must be used in the case where the
current basic ast does no

noSuccessor

Puts the bytecode of this method in the given byte vector.

startFrame

Visits a frame that has been computed from scratch.

visitFrame

Compress and writes the current frame #frame in the StackMapTable attribute.

writeFrame

writeFrameType

Writes some types of the current frame #frame into the StackMapTableAttribute.
This method converts 

writeFrameTypes

Adds a successor to #currentBasicBlock in the control flow graph.

addSuccessorToCurrentBasicBlock

Returns whether the attributes of this method can be copied from the attributes
of the given method 

canCopyMethodAttributes

Collects the attributes of this method into the given set of attribute
prototypes.

collectAttributePrototypes

Computes all the stack map frames of the method, from scratch.

computeAllFrames

Computes the maximum stack size of the method.

computeMaxStackAndLocal

Returns the size of the method_info JVMS structure generated by this
MethodWriter. Also add the name

computeMethodInfoSize

Ends the current basic block. This method must be used in the case where the
current basic block doe

endCurrentBasicBlockWithNoSuccessor

Charset

Finding current android device location

The BufferedImage subclass describes an java.awt.Image with an accessible buffer
of image data. All 

java.awt.image.BufferedImage

java.awt.image.Kernel

This class represents an in-memory collection of keys and certificates. It
manages two types of entr

java.security.KeyStore

A linear collection that supports element insertion and removal at both ends.
The name deque is shor

java.util.Deque

A TimeUnit represents time durations at a given unit of granularity and provides
utility methods to 

java.util.concurrent.TimeUnit

A sequence of elements supporting sequential and parallel aggregate operations.
The following exampl

java.util.stream.Stream

scheduleAtFixedRate

addToBackStack

getApplicationContext

/**
     * Constructs a new {@link MethodWriter}.
     *
     * @param cw            the class writer in which the method must be added.
     * @param access        the method's access flags (see {@link Opcodes}).
     * @param name          the method's name.
     * @param desc          the method's descriptor (see {@link Type}).
     * @param signature     the method's signature. May be <tt>null</tt>.
     * @param exceptions    the internal names of the method's exceptions. May be
     *                      <tt>null</tt>.
     * @param computeMaxs   <tt>true</tt> if the maximum stack size and number
     *                      of local variables must be automatically computed.
     * @param computeFrames <tt>true</tt> if the stack map tables must be
     *                      recomputed from scratch.
     */

// creates and visits the label for the first basic ast

/**
     * Constructs a new {@link MethodWriter}.
     * 
     * @param cw
     *            the class writer in which the method must be added.
     * @param access
     *            the method's access flags (see {@link Opcodes}).
     * @param name
     *            the method's name.
     * @param desc
     *            the method's descriptor (see {@link Type}).
     * @param signature
     *            the method's signature. May be <tt>null</tt>.
     * @param exceptions
     *            the internal names of the method's exceptions. May be
     *            <tt>null</tt>.
     * @param compute
     *            Indicates what must be automatically computed (see #compute).
     */

// creates and visits the label for the first basic block

/**
   * Constructs a new {@link MethodWriter}.
   *
   * @param symbolTable where the constants used in this AnnotationWriter must be stored.
   * @param access the method's access flags (see {@link Opcodes}).
   * @param name the method's name.
   * @param descriptor the method's descriptor (see {@link Type}).
   * @param signature the method's signature. May be {@literal null}.
   * @param exceptions the internal names of the method's exceptions. May be {@literal null}.
   * @param compute indicates what must be computed (see #compute).
   */

// Create and visit the label for the first basic block.

// Add the instruction to the bytecode of the method.

// If needed, update the maximum stack size and number of locals, and stack map frames.

// If there are exception handler blocks, each instruction within a handler range is, in

// theory, a basic block (since execution can jump from this instruction to the exception

// handler). As a consequence, the local variable types at the beginning of the handler

// block should be the merge of the local variable types at all the instructions within the

// handler range. However, instead of creating a basic block for each instruction, we can

// get the same result in a more efficient way. Namely, by starting a new basic block after

// each xSTORE instruction, which is what we do here.

// Label currentBlock = this.currentBlock;

// no stack change, but end of current ast (no successor)

// (see {@link #findSubroutineSuccessors})

// adds the instruction to the bytecode of the method

// no stack change, but end of current block (no successor)

// 'label' is the target of a jump instruction

// adds 'label' as a successor of this basic ast

// creates a Label for the next basic ast

/*
                     * note that, by construction in this method, a JSR ast
                     * has at least two successors in the control flow graph:
                     * the first one leads the next instruction after the JSR,
                     * while the second one leads to the JSR target.
                     */

// updates current stack size (max stack size unchanged

// because stack size variation always negative in this

/*
             * case of a backward jump with an offset < -32768. In this case we
             * automatically replace GOTO with GOTO_W, JSR with JSR_W and IFxxx
             * <l> with IFNOTxxx <l'> GOTO_W <l>, where IFNOTxxx is the
             * "opposite" opcode of IFxxx (i.e., IFNE for IFEQ) and where <l'>
             * designates the instruction just after the GOTO_W.
             */

// if the IF instruction is transformed into IFNOT GOTO_W the

// next instruction becomes the target of the IFNOT instruction

/*
             * case of a backward jump with an offset >= -32768, or of a forward
             * jump with, of course, an unknown offset. In these cases we store
             * the offset in 2 bytes (which will be increased in
             * resizeInstructions, if needed).
             */

// if the jump instruction is not a GOTO, the next instruction

// is also a successor of this instruction. Calling visitLabel

// adds the label of this next instruction as a successor of the

// current ast, and starts a new basic ast

// Compute the 'base' opcode, i.e. GOTO or JSR if opcode is GOTO_W or JSR_W, otherwise opcode.

// Case of a backward jump with an offset < -32768. In this case we automatically replace GOTO

// with GOTO_W, JSR with JSR_W and IFxxx <l> with IFNOTxxx <L> GOTO_W <l> L:..., where

// IFNOTxxx is the "opposite" opcode of IFxxx (e.g. IFNE for IFEQ) and where <L> designates

// the instruction just after the GOTO_W.

// Put the "opposite" opcode of baseOpcode. This can be done by flipping the least

// significant bit for IFNULL and IFNONNULL, and similarly for IFEQ ... IF_ACMPEQ (with a

// pre and post offset by 1). The jump offset is 8 bytes (3 for IFNOTxxx, 5 for GOTO_W).

// Here we could put a GOTO_W in theory, but if ASM specific instructions are used in this

// method or another one, and if the class has frames, we will need to insert a frame after

// this GOTO_W during the additional ClassReader -> ClassWriter round trip to remove the ASM

// specific instructions. To not miss this additional frame, we need to use an ASM_GOTO_W

// here, which has the unfortunate effect of forcing this additional round trip (which in

// some case would not have been really necessary, but we can't know this at this point).

// The instruction after the GOTO_W becomes the target of the IFNOT instruction.

// Case of a GOTO_W or JSR_W specified by the user (normally ClassReader when used to remove

// ASM specific instructions). In this case we keep the original instruction.

// Case of a jump with an offset >= -32768, or of a jump with an unknown offset. In these

// cases we store the offset in 2 bytes (which will be increased via a ClassReader ->

// ClassWriter round trip if it turns out that 2 bytes are not sufficient).

// Record the fact that 'label' is the target of a jump instruction.

// Add 'label' as a successor of the current basic block.

// The next instruction starts a new basic block (except for GOTO: by default the code

// following a goto is unreachable - unless there is an explicit label for it - and we

// should not compute stack frame types for its instructions).

// No need to update maxRelativeStackSize (the stack size delta is always negative).

// Record the fact that 'label' designates a subroutine, if not already done.

// Note that, by construction in this method, a block which calls a subroutine has at

// least two successors in the control flow graph: the first one (added below) leads to

// the instruction after the JSR, while the second one (added here) leads to the JSR

// target. Note that the first successor is virtual (it does not correspond to a possible

// execution path): it is only used to compute the successors of the basic blocks ending

// with a ret, in {@link Label#addSubroutineRetSuccessors}.

// The instruction after the JSR starts a new basic block.

// If the next instruction starts a new basic block, call visitLabel to add the label of this

// instruction as a successor of the current block, and to start a new basic block.

// adds 'label' as a successor of this basic block

// creates a Label for the next basic block

/*
                     * note that, by construction in this method, a JSR block
                     * has at least two successors in the control flow graph:
                     * the first one leads the next instruction after the JSR,
                     * while the second one leads to the JSR target.
                     */

/*
             * case of a backward jump with an offset < -32768. In this case we
             * automatically replace GOTO with GOTO_W, JSR with JSR_W and IFxxx
             * <l> with IFNOTxxx <L> GOTO_W <l> L:..., where IFNOTxxx is the
             * "opposite" opcode of IFxxx (i.e., IFNE for IFEQ) and where <L>
             * designates the instruction just after the GOTO_W.
             */

// ASM pseudo GOTO_W insn, see ClassReader. We don't use a real

// GOTO_W because we might need to insert a frame just after (as

// the target of the IFNOTxxx jump instruction).

/*
             * case of a GOTO_W or JSR_W specified by the user (normally
             * ClassReader when used to resize instructions). In this case we
             * keep the original instruction.
             */

/*
             * case of a backward jump with an offset >= -32768, or of a forward
             * jump with, of course, an unknown offset. In these cases we store
             * the offset in 2 bytes (which will be increased in
             * resizeInstructions, if needed).
             */

// current block, and starts a new basic block

How to use visitLabelmethodin org.mvel2.asm.MethodWriter

Best Java code snippets using org.mvel2.asm.MethodWriter.visitLabel (Showing top 9 results out of 315)

How to use
visitLabel
method
in
org.mvel2.asm.MethodWriter