Uses of Class
jellyj.classfile.classgen.Instruction

Packages that use Instruction
jellyj.classfile.classgen 
jellyj.util 

Uses of Instruction in jellyj.classfile.classgen
 

Subclasses of Instruction in jellyj.classfile.classgen
class AALOAD
          AALOAD - Load reference from array Stack ..., arrayref, index -> value
class AASTORE
          AASTORE - Store into reference array Stack: ..., arrayref, index, value -> ...
class ACONST_NULL
          ACONST_NULL - Push null Stack: ...
class ARETURN
          ARETURN - Return reference from method Stack: ..., objectref ->
class ARRAYLENGTH
          ARRAYLENGTH - Get length of array Stack: ..., arrayref -> ..., length
class ATHROW
          ATHROW - Throw exception Stack: ..., objectref -> objectref
class BALOAD
          BALOAD - Load byte or boolean from array Stack: ..., arrayref, index -> ..., value
class BASTORE
          BASTORE - Store into byte or boolean array Stack: ..., arrayref, index, value -> ...
class BIPUSH
          BIPUSH - Push byte Stack: ...
class BranchInstruction
          Abstract super class for branching instructions like GOTO, IFEQ, etc..
class CALOAD
          CALOAD - Load char from array Stack: ..., arrayref, index -> ..., value
class CASTORE
          CASTORE - Store into char array Stack: ..., arrayref, index, value -> ...
class CPInstruction
          Abstract super class for instructions that use an index into the constant pool such as LDC, INVOKEVIRTUAL, etc.
class D2F
          D2F - Convert double to float Stack: ..., value.word1, value.word2 -> ..., result
class D2I
          D2I - Convert double to int Stack: ..., value.word1, value.word2 -> ..., result
class D2L
          D2L - Convert double to long Stack: ..., value.word1, value.word2 -> ..., result.word1, result.word2
class DADD
          DADD - Add doubles Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result.word1, result1.word2
class DALOAD
          DALOAD - Load double from array Stack: ..., arrayref, index -> ..., result.word1, result.word2
class DASTORE
          DASTORE - Store into double array Stack: ..., arrayref, index, value.word1, value.word2 -> ...
class DCMPG
          DCMPG - Compare doubles: value1 > value2 Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result
class DCMPL
          DCMPL - Compare doubles: value1 < value2 Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result
class DCONST
          DCONST - Push 0.0 or 1.0, other values cause an exception Stack: ...
class DDIV
          DDIV - Divide doubles Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result.word1, result.word2
class DMUL
          DMUL - Multiply doubles Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result.word1, result.word2
class DNEG
          DNEG - Negate double Stack: ..., value.word1, value.word2 -> ..., result.word1, result.word2
class DREM
          DREM - Remainder of doubles Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result.word1, result.word2
class DRETURN
          DRETURN - Return double from method Stack: ..., value.word1, value.word2 ->
class DSUB
          DSUB - Substract doubles Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result.word1, result.word2
class DUP
          DUP - Duplicate top operand stack word Stack: ..., word -> ..., word, word
class DUP_X1
          DUP_X1 - Duplicate top operand stack word and put two down Stack: ..., word2, word1 -> ..., word1, word2, word1
class DUP_X2
          DUP_X2 - Duplicate top operand stack word and put three down Stack: ..., word3, word2, word1 -> ..., word1, word3, word2, word1
class DUP2
          DUP2 - Duplicate two top operand stack words Stack: ..., word2, word1 -> ..., word2, word1, word2, word1
class DUP2_X1
          DUP2_X1 - Duplicate two top operand stack words and put three down Stack: ..., word3, word2, word1 -> ..., word2, word1, word3, word2, word1
class DUP2_X2
          DUP2_X2 - Duplicate two top operand stack words and put four down Stack: ..., word4, word3, word2, word1 -> ..., word2, word1, word4, word3, word2, word1
class F2D
          F2D - Convert float to double Stack: ..., value -> ..., result.word1, result.word2
class F2I
          F2I - Convert float to int Stack: ..., value -> ..., result
class F2L
          F2L - Convert float to long Stack: ..., value -> ..., result.word1, result.word2
class FADD
          FADD - Add floats Stack: ..., value1, value2 -> result
class FALOAD
          FALOAD - Load float from array Stack: ..., arrayref, index -> ..., value
class FASTORE
          FASTORE - Store into float array Stack: ..., arrayref, index, value -> ...
class FCMPG
          FCMPG - Compare floats: value1 > value2 Stack: ..., value1, value2 -> ..., result
class FCMPL
          FCMPL - Compare floats: value1 < value2 Stack: ..., value1, value2 -> ..., result
class FCONST
          FCONST - Push 0.0, 1.0 or 2.0, other values cause an exception Stack: ...
class FDIV
          FDIV - Divide floats Stack: ..., value1, value2 -> result
class FMUL
          FMUL - Multiply floats Stack: ..., value1, value2 -> result
class FNEG
          FNEG - Negate float Stack: ..., value -> ..., result
class FREM
          FREM - Remainder of floats Stack: ..., value1, value2 -> result
class FRETURN
          FRETURN - Return float from method Stack: ..., value ->
class FSUB
          FSUB - Substract floats Stack: ..., value1, value2 -> result
class I2B
          I2B - Convert int to byte Stack: ..., value -> ..., result
class I2C
          I2C - Convert int to char Stack: ..., value -> ..., result
class I2D
          I2D - Convert int to double Stack: ..., value -> ..., result.word1, result.word2
class I2F
          I2F - Convert int to float Stack: ..., value -> ..., result
class I2L
          I2L - Convert int to long Stack: ..., value -> ..., result.word1, result.word2
class I2S
          I2S - Convert int to short Stack: ..., value -> ..., result
class IADD
          IADD - Add ints Stack: ..., value1, value2 -> result
class IALOAD
          IALOAD - Load int from array Stack: ..., arrayref, index -> ..., value
class IAND
          IAND - Bitwise AND int Stack: ..., value1, value2 -> ..., result
class IASTORE
          IASTORE - Store into int array Stack: ..., arrayref, index, value -> ...
class ICONST
          ICONST - Push value between -1, ..., 5, other values cause an exception Stack: ...
class IDIV
          IDIV - Divide ints Stack: ..., value1, value2 -> result
class IINC
          IINC - Increment local variable by constant
class IMPDEP1
          IMPDEP1 - Implementation dependent
class IMPDEP2
          IMPDEP2 - Implementation dependent
class IMUL
          IMUL - Multiply ints Stack: ..., value1, value2 -> result
class INEG
          INEG - Negate int Stack: ..., value -> ..., result
class IOR
          IOR - Bitwise OR int Stack: ..., value1, value2 -> ..., result
class IREM
          IREM - Remainder of int Stack: ..., value1, value2 -> result
class IRETURN
          IRETURN - Return int from method Stack: ..., value ->
class ISHL
          ISHL - Arithmetic shift left int Stack: ..., value1, value2 -> ..., result
class ISHR
          ISHR - Arithmetic shift right int Stack: ..., value1, value2 -> ..., result
class ISUB
          ISUB - Substract ints Stack: ..., value1, value2 -> result
class IUSHR
          IUSHR - Logical shift right int Stack: ..., value1, value2 -> ..., result
class IXOR
          IXOR - Bitwise XOR int Stack: ..., value1, value2 -> ..., result
class L2D
          L2D - Convert long to double Stack: ..., value.word1, value.word2 -> ..., result.word1, result.word2
class L2F
          L2F - Convert long to float Stack: ..., value.word1, value.word2 -> ..., result
class L2I
          L2I - Convert long to int Stack: ..., value.word1, value.word2 -> ..., result
class LADD
          LADD - Add longs Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result.word1, result.word2
class LALOAD
          LALOAD - Load long from array Stack: ..., arrayref, index -> ..., value1, value2
class LAND
          LAND - Bitwise AND longs Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result.word1, result.word2
class LASTORE
          LASTORE - Store into long array Stack: ..., arrayref, index, value.word1, value.word2 -> ...
class LCMP
          LCMP - Compare longs: Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result <= -1, 0, 1>
class LCONST
          LCONST - Push 0 or 1, other values cause an exception Stack: ...
class LDIV
          LDIV - Divide longs Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result.word1, result.word2
class LMUL
          LMUL - Multiply longs Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result.word1, result.word2
class LNEG
          LNEG - Negate long Stack: ..., value.word1, value.word2 -> ..., result.word1, result.word2
class LocalVariableInstruction
          Abstract super class for instructions dealing with local variables.
class LOR
          LOR - Bitwise OR long Stack: ..., value1, value2 -> ..., result
class LREM
          LREM - Remainder of long Stack: ..., value1, value2 -> result
class LRETURN
          LRETURN - Return long from method Stack: ..., value.word1, value.word2 ->
class LSHL
          LSHL - Arithmetic shift left long Stack: ..., value1, value2 -> ..., result
class LSHR
          LSHR - Arithmetic shift right long Stack: ..., value1, value2 -> ..., result
class LSUB
          LSUB - Substract longs Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result.word1, result.word2
class LUSHR
          LUSHR - Logical shift right long Stack: ..., value1, value2 -> ..., result
class LXOR
          LXOR - Bitwise XOR long Stack: ..., value1.word1, value1.word2, value2.word1, value2.word2 -> ..., result
class MONITORENTER
          MONITORENTER - Enter monitor for object Stack: ..., objectref -> ...
class MONITOREXIT
          MONITOREXIT - Exit monitor for object Stack: ..., objectref -> ...
class NEWARRAY
          NEWARRAY - Create new array of basic type (int, short, ...) Stack: ..., type -> ..., arrayref type mus be one of T_INT, T_SHORT, ...
class NOP
          NOP - Do nothing
class POP
          POP - Pop top operand stack word Stack: ..., word -> ...
class POP2
          POP2 - Pop two top operand stack words Stack: ..., word2, word1 -> ...
class RET
          RET - Return from subroutine Stack: ..., -> ..., address
class RETURN
          RETURN - Return from void method Stack: ...
class SALOAD
          SALOAD - Load short from array Stack: ..., arrayref, index -> ..., value
class SASTORE
          SASTORE - Store into short array Stack: ..., arrayref, index, value -> ...
class SIPUSH
          SIPUSH - Push short Stack: ...
class SWAP
          SWAP - Swa top operand stack word Stack: ..., word2, word1 -> ..., word1, word2
 

Fields in jellyj.classfile.classgen declared as Instruction
(package private) InstructionInstructionHandle.instruction
          
 

Constructors in jellyj.classfile.classgen with parameters of type Instruction
InstructionHandle.InstructionHandle(Instruction i)
          
InstructionList.InstructionList(Instruction i)
          Initialize list with (nonnull) instruction.
 

Methods in jellyj.classfile.classgen that return Instruction
(package private) InstructionInstruction.copy()
          Use with caution, since `BranchInstruction's have a `target' reference which is not copied correctly (only basic types are).
final static InstructionInstruction.readInstruction(ByteSequence bytes)
          Read an instruction from (byte code) input stream and return the appropiate object.
final InstructionInstructionHandle.getInstruction()
          
final InstructionPUSH.getInstruction()
          
final InstructionSWITCH.getInstruction()
          
 

Methods in jellyj.classfile.classgen with parameters of type Instruction
final InstructionHandleInstructionList.append(Instruction i, CompoundInstruction c)
          Append a compound instruction, after instruction i.
final InstructionHandleInstructionList.append(Instruction i, Instruction j)
          Append a single instruction j after another instruction i, which must be in this list of course!
final InstructionHandleInstructionList.append(Instruction i, InstructionList il)
          Append another list after instruction i contained in this list.
final InstructionHandleInstructionList.append(Instruction i)
          Append an instruction to the end of this list.
final voidInstructionList.delete(Instruction from, Instruction to)
          Remove instructions from instruction `from' to instruction `to' contained in this list.
final voidInstructionList.delete(Instruction i)
          Remove instruction from this list.
final InstructionHandleInstructionList.insert(Instruction i, CompoundInstruction c)
          Insert a compound instruction before instruction i.
InstructionHandleInstructionList.insert(Instruction i, Instruction j)
          Insert a single instruction j before another instruction i, which must be in this list of course!
final InstructionHandleInstructionList.insert(Instruction i, InstructionList il)
          Insert another list before Instruction i contained in this list.
final InstructionHandleInstructionList.insert(Instruction i)
          Insert an instruction at start of this list.
 

Uses of Instruction in jellyj.util
 

Methods in jellyj.util that return Instruction
InstructionArrayType.APPENDSTB(ConstantPoolGen cpg)
          
InstructionBooleanType.ALOAD()
          
InstructionBooleanType.AND()
          
InstructionBooleanType.ASTORE()
          
InstructionBooleanType.IFEQ(boolean tozero)
          
InstructionBooleanType.IFNE(boolean tozero)
          
InstructionBooleanType.LOAD(int slot)
          
InstructionBooleanType.NEWARRAY(int index)
          
InstructionBooleanType.OR()
          
InstructionBooleanType.PUSH(ConstantPoolGen cpg, BigDecimal value)
          
InstructionBooleanType.RETURN()
          
InstructionBooleanType.STORE(int slot)
          
InstructionBooleanType.XOR()
          
InstructionByteType.ALOAD()
          
InstructionByteType.APPENDSTB(ConstantPoolGen cpg)
          
InstructionByteType.ASTORE()
          
InstructionByteType.NEWARRAY(int index)
          
InstructionCharType.ALOAD()
          
InstructionCharType.ASTORE()
          
InstructionCharType.NEWARRAY(int index)
          
InstructionClassType.APPENDSTB(ConstantPoolGen cpg)
          
InstructionClassType.IFEQ(boolean tozero)
          
InstructionClassType.IFNE(boolean tozero)
          
InstructionDoubleType.ADD()
          
InstructionDoubleType.ALOAD()
          
InstructionDoubleType.ASTORE()
          
InstructionDoubleType.CMP(boolean less)
          
InstructionDoubleType.DIV()
          
InstructionDoubleType.DUP()
          
InstructionDoubleType.DUPX1()
          
InstructionDoubleType.DUPX2()
          
InstructionDoubleType.LOAD(int slot)
          
InstructionDoubleType.MUL()
          
InstructionDoubleType.NEG()
          
InstructionDoubleType.NEWARRAY(int index)
          
InstructionDoubleType.POP()
          
InstructionDoubleType.PUSH(ConstantPoolGen cpg, BigDecimal value)
          
InstructionDoubleType.REM()
          
InstructionDoubleType.RETURN()
          
InstructionDoubleType.STORE(int slot)
          
InstructionDoubleType.SUB()
          
InstructionFloatType.ADD()
          
InstructionFloatType.ALOAD()
          
InstructionFloatType.ASTORE()
          
InstructionFloatType.DIV()
          
InstructionFloatType.LOAD(int slot)
          
InstructionFloatType.MUL()
          
InstructionFloatType.NEG()
          
InstructionFloatType.NEWARRAY(int index)
          
InstructionFloatType.PUSH(ConstantPoolGen cpg, BigDecimal value)
          
InstructionFloatType.REM()
          
InstructionFloatType.RETURN()
          
InstructionFloatType.STORE(int slot)
          
InstructionFloatType.SUB()
          
InstructionIntegralType.ADD()
          
InstructionIntegralType.AND()
          
InstructionIntegralType.DIV()
          
InstructionIntegralType.LOAD(int slot)
          
InstructionIntegralType.MUL()
          
InstructionIntegralType.NEG()
          
InstructionIntegralType.OR()
          
InstructionIntegralType.PUSH(ConstantPoolGen cpg, BigDecimal value)
          
InstructionIntegralType.REM()
          
InstructionIntegralType.RETURN()
          
InstructionIntegralType.STORE(int slot)
          
InstructionIntegralType.SUB()
          
InstructionIntegralType.XOR()
          
InstructionIntType.ALOAD()
          
InstructionIntType.ASTORE()
          
InstructionIntType.IFEQ(boolean tozero)
          
InstructionIntType.IFGE(boolean tozero)
          
InstructionIntType.IFGT(boolean tozero)
          
InstructionIntType.IFLE(boolean tozero)
          
InstructionIntType.IFLT(boolean tozero)
          
InstructionIntType.IFNE(boolean tozero)
          
InstructionIntType.NEWARRAY(int index)
          
InstructionIntType.SHL()
          
InstructionIntType.SHR()
          
InstructionIntType.USHR()
          
InstructionLongType.ADD()
          
InstructionLongType.ALOAD()
          
InstructionLongType.AND()
          
InstructionLongType.ASTORE()
          
InstructionLongType.CMP(boolean less)
          
InstructionLongType.DIV()
          
InstructionLongType.DUP()
          
InstructionLongType.DUPX1()
          
InstructionLongType.DUPX2()
          
InstructionLongType.IFGT(boolean tozero)
          
InstructionLongType.LOAD(int slot)
          
InstructionLongType.MUL()
          
InstructionLongType.NEG()
          
InstructionLongType.NEWARRAY(int index)
          
InstructionLongType.OR()
          
InstructionLongType.POP()
          
InstructionLongType.PUSH(ConstantPoolGen cpg, BigDecimal value)
          
InstructionLongType.REM()
          
InstructionLongType.RETURN()
          
InstructionLongType.SHL()
          
InstructionLongType.SHR()
          
InstructionLongType.STORE(int slot)
          
InstructionLongType.SUB()
          
InstructionLongType.USHR()
          
InstructionLongType.XOR()
          
InstructionNullType.APPENDSTB(ConstantPoolGen cpg)
          
InstructionNullType.IFEQ(boolean tozero)
          
InstructionNullType.IFNE(boolean tozero)
          
InstructionPrimitiveType.APPENDSTB(ConstantPoolGen cpg)
          
InstructionPrimitiveType.DUP()
          
InstructionPrimitiveType.DUPX1()
          
InstructionPrimitiveType.DUPX2()
          
InstructionPrimitiveType.POP()
          
InstructionReferenceType.ALOAD()
          
InstructionReferenceType.ASTORE()
          
InstructionReferenceType.DUP()
          
InstructionReferenceType.DUPX1()
          
InstructionReferenceType.DUPX2()
          
InstructionReferenceType.LOAD(int slot)
          
InstructionReferenceType.NEWARRAY(int index)
          
InstructionReferenceType.POP()
          
InstructionReferenceType.RETURN()
          
InstructionReferenceType.STORE(int slot)
          
InstructionShortType.ALOAD()
          
InstructionShortType.APPENDSTB(ConstantPoolGen cpg)
          
InstructionShortType.ASTORE()
          
InstructionShortType.NEWARRAY(int index)
          
InstructionType.ADD()
          
InstructionType.ALOAD()
          
InstructionType.AND()
          
InstructionType.APPENDSTB(ConstantPoolGen cpg)
          
InstructionType.ASTORE()
          
InstructionType.CMP(boolean less)
          
InstructionType.DIV()
          
InstructionType.DUP()
          
InstructionType.DUPX1()
          
InstructionType.DUPX2()
          
InstructionType.IFEQ(boolean tozero)
          
InstructionType.IFGE(boolean tozero)
          
InstructionType.IFGT(boolean tozero)
          
InstructionType.IFLE(boolean tozero)
          
InstructionType.IFLT(boolean tozero)
          
InstructionType.IFNE(boolean tozero)
          
InstructionType.LOAD(int slot)
          
InstructionType.MUL()
          
InstructionType.NEG()
          
InstructionType.NEWARRAY(int index)
          
InstructionType.OR()
          
InstructionType.POP()
          
InstructionType.PUSH(ConstantPoolGen cpg, BigDecimal value)
          
InstructionType.REM()
          
InstructionType.RETURN()
          
InstructionType.SHL()
          
InstructionType.SHR()
          
InstructionType.STORE(int slot)
          
InstructionType.SUB()
          
InstructionType.USHR()
          
InstructionType.XOR()
          
InstructionVoidType.LOAD(int slot)
          
InstructionVoidType.POP()
          
InstructionVoidType.RETURN()
          
InstructionVoidType.STORE(int slot)