|
Class Summary |
| AALoad |
This class maps the AALOAD bytecode instruction which loads a reference from an
array. |
| AAStore |
This class maps the AASTORE bytecode instruction which stores a reference to an
array. |
| AConst_Null |
This class maps the AACONST_NULL bytecode instruction which pushes null onto the
operant stack. |
| ALoad |
This class maps the ALOAD bytecode instruction which loads a reference from a
local variable. |
| ALoad_0 |
This class maps the ALOAD_0 bytecode instruction which loads a reference from a
local variable stored at the position 0 of the local variable array of the current frame. |
| ALoad_1 |
This class maps the ALOAD_1 bytecode instruction which loads a reference from a
local variable stored at the position 1 of the local variable array of the current frame. |
| ALoad_2 |
This class maps the ALOAD_2 bytecode instruction which loads a reference from a
local variable stored at the position 2 of the local variable array of the current frame. |
| ALoad_3 |
This class maps the ALOAD_3 bytecode instruction which loads a reference from a
local variable stored at the position 3 of the local variable array of the current frame. |
| ANewArray |
This class maps the ANEWARRAY bytecode instruction. |
| AReturn |
This class maps the ARETURN bytecode instruction which returns a reference from a
method |
| ArrayLength |
This class maps the ARRAYLENGTH bytecode instruction which returns the length of
an array. |
| AStore |
This class maps the ASTORE bytecode instruction which stores a reference into a
local variable |
| AStore_0 |
This class maps the ASTORE bytecode instruction which store a reference into a
local variable. 0 is the index in the local variable array of the current frame |
| AStore_1 |
This class maps the ASTORE bytecode instruction which store a reference into a
local variable. 1 is the index in the local variable array of the current frame |
| AStore_2 |
This class maps the ASTORE_2 bytecode instruction which store a reference into a
local variable. 2 is the index in the local variable array of the current frame |
| AStore_3 |
This class maps the ASTORE_3 bytecode instruction which store a reference into a
local variable. 3 is the index in the local variable array of the current frame |
| AThrow |
This class maps the ATHROW bytecode instruction which is used to throw an
exception or an error |
| BALoad |
This class maps the BALOAD bytecode instruction which loads a byte
or a boolean from an array. |
| BAStore |
This class maps the BASTORE bytecode instruction which stores a byte
or a boolean to an array. |
| BiPush |
This class maps the BIPUSH bytecode instruction which pushes a byte
onto the stack. |
| CALoad |
This class maps the CALOAD bytecode instruction which loads a char
from an array. |
| CAStore |
This class maps the CASTORE bytecode instruction which stores a char
to an array. |
| CheckCast |
This class maps the CHECKCAST bytecode instruction which checks whether the object
referenced by the reference on the top of the stack can be casted to the type represented by the
constant pool table entry at index indexbyte1<<8|indexbyte2. |
| D2f |
This class maps the D2F bytecode instruction which converts a double
to float. |
| D2i |
This class maps the D2I bytecode instruction which converts a double
to integer. |
| D2l |
This class maps the D2L bytecode instruction which converts a double
to long. |
| DAdd |
This class maps the DADD bytecode instruction which adds two operands of type
double stored on the top of the stack. |
| DALoad |
This class maps the DALOAD bytecode instruction which loads a double
from an array. |
| DAStore |
This class maps the DASTORE bytecode instruction which stores a
double to an array. |
| DCmpg |
This class maps the DCMPG bytecode instruction which compares two
doubles took from the top of the stack. |
| DCmpl |
This class maps the DCMPG bytecode instruction which compares two
doubles took from the top of the stack. |
| DConst_0 |
This class maps the DCONST_0 bytecode instruction which pushes the
double constant 0.0 on to the operand stack. |
| DConst_1 |
This class maps the DCONST_1 bytecode instruction which pushes the
double constant 1.0 on to the operand stack. |
| DDiv |
This class maps the DDIV bytecode instruction which divides the two
doubles popped out from the operand stack and pushes back the result. |
| DLoad |
This class maps the DLOAD bytecode instruction which loads a double
from the index specified as parameter (operand). |
| DLoad_0 |
This class maps the DLOAD_0 bytecode instruction which loads a double
from the local variable array of the current frame at index 0. |
| DLoad_1 |
This class maps the DLOAD_1 bytecode instruction which loads a double
from the local variable array of the current frame at index 1. |
| DLoad_2 |
This class maps the DLOAD_2 bytecode instruction which loads a double
from the local variable array of the current frame at index 2. |
| DLoad_3 |
This class maps the DLOAD_3 bytecode instruction which loads a double
from the local variable array of the current frame at index 3. |
| DMul |
This class maps the DMUL bytecode instruction which multiplies two
doubles popped from the operand stack, and pushes the result onto the operand
stack. |
| DNeg |
This class maps the DNEG bytecode instruction which negates a double. |
| DRem |
This class maps the DREM bytecode instruction which computes the reminder of the
truncationg division of the two doubles popped from the operand stack. |
| DReturn |
This class maps the DRETURN bytecode instruction which returns a
double popping it from the operand stack. |
| DStore |
This class maps the DSTORE bytecode instruction which stores a double
popped from the operand stack into a variable whose index is specified as operand. |
| DStore_0 |
This class maps the DSTORE_0 bytecode instruction which stores a
double popped from the operand stack into the index 0 of the local variable array. |
| DStore_1 |
This class maps the DSTORE_1 bytecode instruction which stores a
double popped from the operand stack into the index 1 of the local variable array. |
| DStore_2 |
This class maps the DSTORE_2 bytecode instruction which stores a
double popped from the operand stack into the index 2 of the local variable array. |
| DStore_3 |
This class maps the DSTORE_3 bytecode instruction which stores a
double popped from the operand stack into the index 3 of the local variable array. |
| DSub |
This class maps the DSUB bytecode instruction which subtracts the first
double popped from the operand stack from the second one, and pushes the result
onto the operand stack. |
| Dup |
This class maps the DUP bytecode instruction which duplicates the value found at
the top of the operand stack, and pushes the copy of the top of it: as a result at the top of the
operans stack there will be two equal doubles. |
| Dup_X1 |
This class maps the DUP_X1 bytecode instruction which duplicates the top value on
the operand stack and insert the duplicated value two values down in the operand stack. |
| Dup_X2 |
This class maps the DUP_X2 bytecode instruction which duplicates the top value on
the operand stack and insert the duplicated value two or three values down in the operand stack. |
| Dup2 |
This class maps the DUP2 bytecode instruction which duplicates the top one or two
values on the operand stack and push the duplicated value or values back onto the operand stack
in the original order. |
| Dup2_X1 |
This class maps the DUP2_X1 bytecode instruction which duplicates the top one or
two values on the operand stack and insert the duplicated values, in the original order, one
value beneath the original value or values in the operand stack. |
| Dup2_X2 |
This class maps the DUP2_X2 bytecode instruction which duplicates the top one or
two values on the operand stack and insert the duplicated values, in the original order, into the
operand stack. |
| F2d |
This class maps the F2D bytecode instruction which converts a float
popped from the operand stack into a double and places it on the top of the
operand stack. |
| F2i |
This class maps the F2I bytecode instruction which converts a float
popped from the operand stack into an integer and places it on the top of the
operand stack. |
| F2l |
This class maps the F2L bytecode instruction which converts a float
popped from the operand stack into a long and places it on the top of the operand
stack. |
| FAdd |
This class maps the FADD bytecode instruction which adds two float
values. |
| FALoad |
This class maps the FALOAD bytecode instruction which loads a float
from an array. |
| FAStore |
This class maps the FASTORE bytecode instruction which stores a float
to an array. |
| FCmpg |
This class maps the FCMPG bytecode instruction which preforms a comparison between
two float values. |
| FCmpl |
This class maps the FCMPL bytecode instruction which preforms a comparison between
two float values. |
| FConst_0 |
This class maps the FCONST_0 bytecode instruction which pushes the constant
long 0 onto the operand stack. |
| FConst_1 |
This class maps the FCONST_1 bytecode instruction which pushes the constant
long 1 onto the operand stack. |
| FConst_2 |
This class maps the FCONST_2 bytecode instruction which pushes the constant
long 2 onto the operand stack. |
| FDiv |
This class maps the FDIV bytecode instruction which divides two floats
popped from the top two positions of the operand stack and pushes back the result. |
| FLoad |
This class maps the FLOAD bytecode instruction which loads a float
value from a local variable whose index is provided as parameter. |
| FLoad_0 |
This class maps the FLOAD_0 bytecode instruction which loads a float
value from the position 0 of the local variable array of the current frame. |
| FLoad_1 |
This class maps the FLOAD_1 bytecode instruction which loads a float
value from the position 1 of the local variable array of the current frame. |
| FLoad_2 |
This class maps the FLOAD_2 bytecode instruction which loads a float
value from the position 2 of the local variable array of the current frame. |
| FLoad_3 |
This class maps the FLOAD_3 bytecode instruction which loads a float
value from the position 3 of the local variable array of the current frame. |
| FMul |
This class maps the FMUL bytecode instruction which multiplies two
floats popped from the operand stack. |
| FNeg |
This class maps the FNEG bytecode instruction which negates the
float value popped from the top of the operans stack. |
| FRem |
This class maps the FREM bytecode instruction which computes the reminder of the
division of the first element taken from the operand stack by the second one. |
| FReturn |
This class maps the FRETURN bytecode instruction which is needed in order to
return a float value from a method. |
| FStore |
This class maps the FSTORE bytecode instruction which stores a float
value popped from the operand stack into a local variable whose index has to be provided as
parameter to the FSTORE instruction. |
| FStore_0 |
This class maps the FSTORE_0 bytecode instruction which stores a
float value popped from the operand stack into the local variable array of the
current frame at index 0. |
| FStore_1 |
This class maps the FSTORE_1 bytecode instruction which stores a
float value popped from the operand stack into the local variable array of the
current frame at index 1. |
| FStore_2 |
This class maps the FSTORE_2 bytecode instruction which stores a
float value popped from the operand stack into the local variable array of the
current frame at index 2. |
| FStore_3 |
This class maps the FSTORE_3 bytecode instruction which stores a
float value popped from the operand stack into the local variable array of the
current frame at index 3. |
| FSub |
This class maps the FSUB bytecode instruction which subtracts the first value
popped from the operand stack from the second one, and pushes the result back onto the operand
stack. |
| GetField |
This class maps the GETFIELD bytecode instruction which fetches field from object. |
| GetStatic |
This class maps the GETSTATIC bytecode instruction which gets static field from
class. |
| Goto |
This class maps the GOTO bytecode instruction which branches always. |
| Goto_W |
This class maps the GOTO_W bytecode instruction which branches always (wide
index). |
| I2b |
This class maps the I2B bytecode instruction which converts an int
popped from the operand stack, to a byte. |
| I2c |
This class maps the I2C bytecode instruction which converts an int
popped from the operand stack, to a char. |
| I2d |
This class maps the I2D bytecode instruction which converts an int
popped from the operand stack to a double. |
| I2f |
This class maps the I2F bytecode instruction which converts an int
popped from the operand stack to a float. |
| I2l |
This class maps the I2L bytecode instruction which converts an int
popped from the operand stack to a long. |
| I2s |
This class maps the I2S bytecode instruction which converts an int
popped from the operand stack, to a short. |
| IAdd |
This class maps the IADD bytecode instruction which adds two ints
took from the operand stack. |
| IALoad |
This class maps the IALOAD bytecode instruction which loads an int
from the position, specified by the first entry of the operand stack, of the array referenced by
the second entry of the operand stack. |
| IAnd |
This class maps the IAND bytecode instruction which performs a bitwise and
operation of the first two int popped from the operand stack. |
| IAStore |
This class maps the IASTORE bytecode instruction which stores an int
into the array referenced by the second entry of the operand stack a the index given by the first
entry of the operand stack. |
| IConst_0 |
This class maps the ICONST_0 bytecode instruction which pushes the costant 0 onto
the operand stack. |
| IConst_1 |
This class maps the ICONST_1 bytecode instruction which pushes the costant 1 onto
the operand stack. |
| IConst_2 |
This class maps the ICONST_2 bytecode instruction which pushes the costant 2 onto
the operand stack. |
| IConst_3 |
This class maps the ICONST_3 bytecode instruction which pushes the costant 3 onto
the operand stack. |
| IConst_4 |
This class maps the ICONST_4 bytecode instruction which pushes the costant 4 onto
the operand stack. |
| IConst_5 |
This class maps the ICONST_5 bytecode instruction which pushes the costant 5 onto
the operand stack. |
| IConst_M1 |
This class maps the ICONST_M1 bytecode instruction which pushes the costant -1
onto the operand stack. |
| IDiv |
This class maps the IDIV bytecode instruction which divides the second entry of
the operand stack by the first one, and pushes the result back on top of the operand stack. |
| If_ACmpEq |
This class maps the IFACMPEQ bytecode instruction which branches to the offset
obtained starting from the two required operands, if and only if the first two values popped from
the operand stack equal. |
| If_ACmpNe |
This class maps the IFACMPLNE bytecode instruction which branches to the offset
obtained starting from the two required operands, if and only if the first two values popped from
the operand stack don't equal. |
| IF_ICmpeq |
This class maps the IF_ICMPEQ bytecode instruction which compares the first two
ints popped from the operand stack. |
| IF_ICmpge |
This class maps the IF_ICMPGE bytecode instruction which compares the first two
ints popped from the operand stack. |
| IF_ICmpgt |
This class maps the IF_ICMPGT bytecode instruction which compares the first two
ints popped from the operand stack. |
| IF_ICmple |
This class maps the IF_ICMPLE bytecode instruction which compares the first two
ints popped from the operand stack. |
| IF_ICmplt |
This class maps the IF_ICMPLT bytecode instruction which compares the first two
ints popped from the operand stack. |
| IF_ICmpne |
This class maps the IF_ICMPNE bytecode instruction which compares the first two
ints popped from the operand stack. |
| Ifeq |
This class maps the IFEQ bytecode instruction which branches to the offset
obtained starting from the two required operands, if and only if the value popped from the
operand stack equals 0. |
| Ifge |
This class maps the IFGE bytecode instruction which branches to the offset
obtained starting from the two required operands, if and only if the value popped from the
operand stack is greater than or equals 0. |
| Ifgt |
This class maps the IFGT bytecode instruction which branches to the offset
obtained starting from the two required operands, if and only if the value popped from the
operand stack is greater than 0. |
| Ifle |
This class maps the IFLE bytecode instruction which branches to the offset
obtained starting from the two required operands, if and only if the value popped from the
operand stack is less than or equals 0. |
| Iflt |
This class maps the IFLT bytecode instruction which branches to the offset
obtained starting from the two required operands, if and only if the value popped from the
operand stack is less than 0. |
| Ifne |
This class maps the IFNE bytecode instruction which branches to the offset
obtained starting from the two required operands, if and only if the value popped from the
operand stack does not equal 0. |
| IfNoNull |
This class maps the IFNONNULL bytecode instruction which branches to the specified
offset if and only if the value of type reference popped from the operand stack is
not null. |
| IfNull |
This class maps the IFNULL bytecode instruction which behaves exactly like the
ifnonnull instruction, but the jump happens if and only if the reference popped
from the operand stack is null rether then non null. |
| IInc |
This class maps the IINC bytecode instruction which increments the
int referenced by the first IINC parameter (this is an index into
the local variable array of the current frame) by a constant given as second paramenter of the
bytecode instruction. |
| ILoad |
This class maps the ILOAD bytecode instruction which loads an int
from the local variable array of the current frame, at the index specified as parameter of the
instruction. |
| ILoad_0 |
This class maps the ILOAD_0 bytecode instruction which loads an int
from the index 0 of the local variable array of the current frame. |
| ILoad_1 |
This class maps the ILOAD_1 bytecode instruction which loads an int
from the index 1 of the local variable array of the current frame. |
| ILoad_2 |
This class maps the ILOAD_2 bytecode instruction which loads an int
from the index 2 of the local variable array of the current frame. |
| ILoad_3 |
This class maps the ILOAD_3 bytecode instruction which loads an int
from the index 3 of the local variable array of the current frame. |
| IMul |
This class maps the IMUL bytecode instruction which multiplies the first two
ints popped from the operand stack and pushes back the result. |
| INeg |
This class maps the INEG bytecode instruction which performs the arithmetical
negation of the int popped from the operand stack, and pushes back the result. |
| InstanceOf |
This class maps the INSTANCEPF bytecode instruction which determines if the object
references by the address popped from the operand stack is of the type given by the entry of the
runtime constantpool addressed by the two bytes required as parameter for this instruction. |
| InstructionAncestor |
This class is the ancestor of all the concrete instruction classes, and provides all these
methods common to every instruction. |
| InstructionAncestorRefsCpt |
This class is the ancestor of all the concrete instruction classes referring the constant pool
table. |
| InstructionFactory |
This factory class has to be used for instantiating instruction classes. |
| InstructionRefsCpt16 |
This class is the ancestor of all the concrete instruction classes referring the constant pool
table with 16 bits index. |
| InstructionRefsCpt8 |
This class is the ancestor of all the concrete instruction classes referring the constant pool
table with 8 bits index. |
| InvokeInterface |
This class maps the INVOKEINTERFACE bytecode instruction which invokes an
interface method. |
| InvokeSpecial |
This class maps the INVOKESPECIAL bytecode instruction which invokes instance
initialization, private and super class methods. |
| InvokeStatic |
This class maps the INVOKESTATIC bytecode instruction which invokes static
methods. |
| InvokeVirtual |
This class maps the INVOKEVIRTUAL bytecode instruction which invokes instance
methods. |
| IOr |
This class maps the IOR bytecode instruction which performs the boolean or of the
first two ints popped from the operand stack. |
| IRem |
This class maps the IREM bytecode instruction which calculates the reminder of the
division of the second entry of the operand stack by the first one. |
| IReturn |
This class maps the IRETURN bytecode instruction which is used to return an
int from a method. |
| IShl |
This class maps the ISHL bytecode instruction which shifts left the second entry
of the operand stack by s bit positions, where s is the value of the low 5 bits of the first
entry of the operand stack. |
| IShr |
This class maps the ISHR bytecode instruction which shifts right the second entry
of the operand stack by s bit positions, where s is the value of the low 5 bits of the first
entry of the operand stack. |
| IStore |
This class maps the ISTORE bytecode instruction which stores an int
popped from the operand stack into a local variable whose address points to an entry of the local
variable array of the current frame. |
| IStore_0 |
This class maps the ISTORE_0 bytecode instruction which stores an int
value popped from the operand stack into the local variable array of the current frame at index
0. |
| IStore_1 |
This class maps the ISTORE_1 bytecode instruction which stores an int
value popped from the operand stack into the local variable array of the current frame at index
1. |
| IStore_2 |
This class maps the ISTORE_2 bytecode instruction which stores an int
value popped from the operand stack into the local variable array of the current frame at index
2. |
| IStore_3 |
This class maps the ISTORE_3 bytecode instruction which stores an int
value popped from the operand stack into the local variable array of the current frame at index
3. |
| ISub |
This class maps the ISUB bytecode instruction which subtracts the first value
popped from the operand stack from the second one, and pushes the result back onto the operand
stack. |
| Iushr |
This class maps the IUSHR bytecode instruction. |
| IXOr |
This class maps the IXOR bytecode instruction which performs the boolean xor over
the first two values popped from the operand stack. |
| Jsr |
This class maps the JSR bytecode instruction which jumps to subroutine. |
| Jsr_W |
This class maps the JSR_W bytecode instruction which jumps to subroutine (wide
index). |
| L2d |
This class maps the L2D bytecode instruction which converts a long
to a double. |
| L2f |
This class maps the L2F bytecode instruction which converts a long
to a float. |
| L2i |
This class maps the L2I bytecode instruction which converts a long
to an int. |
| LAdd |
This class maps the LADD bytecode instruction which adds two longs
took from the operand stack. |
| LALoad |
This class maps the LALOAD bytecode instruction which loads a long
from the position specified by the first entry of the operand stack of the array referenced by
the second entry of the operand stack. |
| LAnd |
This class maps the LAND bytecode instruction which performs a bitwise and
operation of the first two longs popped from the operand stack. |
| LAStore |
This class maps the LASTORE bytecode instruction which stores a long
to an array. |
| Lcmp |
This class maps the LCMP bytecode instruction which compares the first two
longs popped from thr operand stack. |
| LConst_0 |
This class maps the LCONST_0 bytecode instruction which pushes a 0
long constant onto the operand stack. |
| LConst_1 |
This class maps the LCONST_0 bytecode instruction which pushes a 1
long constant onto the operand stack. |
| Ldc |
This class maps the LDC bytecode instruction which pushes into the operand stack a
value taken from the runtime constant pool of the current class at the index specified by the
only one argument of the LDC instruction. |
| Ldc_W |
This class maps the LDC_W bytecode instruction which pushes into the operand stack
a value taken from the runtime constant pool of the current class at the index specified by the
two arguments of the LDC instruction. |
| Ldc2_W |
This class maps the LDC_2W bytecode instruction which pushes into the operand
stack a long or double taken from the runtime constant pool of the
current class at the index specified by the two arguments of the LDC instruction. |
| LDiv |
This class maps the LDIV bytecode instruction which divides the second entry of
the operand stack by the first one, and pushes the result back on top of the operand stack. |
| LLoad |
This class maps the LLOAD bytecode instruction which loads a long
value from a local variable whose index is provided as parameter. |
| LLoad_0 |
This class maps the LLOAD_0 bytecode instruction which loads a long
value from the position 0 of the local variable array of the current frame. |
| LLoad_1 |
This class maps the LLOAD_1 bytecode instruction which loads a long
value from the position 1 of the local variable array of the current frame. |
| LLoad_2 |
This class maps the LLOAD_2 bytecode instruction which loads a long
value from the position 2 of the local variable array of the current frame. |
| LLoad_3 |
This class maps the LLOAD_3 bytecode instruction which loads a long
value from the position 3 of the local variable array of the current frame. |
| LMul |
This class maps the LMUL bytecode instruction which multiplies the first two
longs popped from the operand stack and pushes back the result. |
| LNeg |
This class maps the LNEG bytecode instruction which performs the arithmetical
negation of the long popped from the operand stack, and pushes back the result. |
| LookupSwitch |
This class maps the LOOKUPSWITCH bytecode instruction. |
| LOr |
This class maps the LOR bytecode instruction which performs the boolean or of the
first two longs popped from the operand stack. |
| LRem |
This class maps the LREM bytecode instruction which calculates the reminder of the
division of the second entry of the operand stack by the first one. |
| LReturn |
This class maps the LRETURN bytecode instruction which is used to return an
int from a method. |
| LShl |
This class maps the LSHL bytecode instruction which shifts left the second entry
of the operand stack by s bit positions, where s is the value of the low 5 bits of the first
entry of the operand stack. |
| LShr |
This class maps the LSHR bytecode instruction which shifts right the second entry
of the operand stack by s bit positions, where s is the value of the low 5 bits of the first
entry of the operand stack. |
| LStore |
This class maps the LSTORE bytecode instruction which stores a long
popped from the operand stack into a local variable whose address points to an entry of the local
variable array of the current frame. |
| LStore_0 |
This class maps the LSTORE_0 bytecode instruction which stores an
long value popped from the operand stack into the local variable array of the
current frame at index 0. |
| LStore_1 |
This class maps the LSTORE_1 bytecode instruction which stores an
long value popped from the operand stack into the local variable array of the
current frame at index 1. |
| LStore_2 |
This class maps the LSTORE_2 bytecode instruction which stores an
long value popped from the operand stack into the local variable array of the
current frame at index 2. |
| LStore_3 |
This class maps the LSTORE_3 bytecode instruction which stores an
long value popped from the operand stack into the local variable array of the
current frame at index 3. |
| LSub |
This class maps the LSUB bytecode instruction which subtracts the first value
popped from the operand stack from the second one, and pushes the result back onto the operand
stack. |
| Lushr |
This class maps the LUSHR bytecode instruction. |
| LXOr |
This class maps the LXOR bytecode instruction which performs the boolean xor over
the first two values popped from the operand stack. |
| MonitorEnter |
This class maps the MONITORENTER bytecode instruction which enters monitor for
object. |
| MonitorExit |
This class maps the MONITOREXIT bytecode instruction which exit monitor for
object. |
| MultiANewArray |
This class maps the MULTIANEWARRAY bytecode instruction which creates new
multidimensional array. |
| New |
This class maps the NEW bytecode instruction which is used to instantiate a new
object. |
| NewArray |
This class maps the NEW bytecode instruction which creates a new array whose
dimension is given by the first value popped from the operand stack. |
| Nop |
This class maps the NOP bytecode instruction which does nothing. |
| Pop |
This class maps the POP bytecode instruction which pop the top value from the
operand stack. |
| Pop2 |
This class maps the POP2 bytecode instruction which pop the top one or two values
from the operand stack. |
| PutField |
This class maps the PUTFIELD bytecode instruction which set field in object. |
| PutStatic |
This class maps the PUTSTATIC bytecode instruction which set static field in
class. |
| Ret |
This class maps the RET bytecode instruction which returns from a subruotine. |
| Return |
This class maps the RETURN bytecode instruction which returns void
from a method. |
| SALoad |
This class maps the SALOAD bytecode instruction which loads short from array. |
| SAStore |
This class maps the SASTORE bytecode instruction which stores into short array. |
| SiPush |
This class maps the SIPUSH bytecode instruction which pushes short. |
| Swap |
This class maps the SWAP bytecode instruction which swap the top two values on the
operand stack. |
| TableSwitch |
This class maps the TABLESWITVH bytecode instruction which accesses jump table by
index and jump. |
| Wide |
This class maps the WIDE bytecode instruction which extends local variable index
by additional bytes. |