## Uses of Interface
org.apache.bcel.generic.TypedInstruction

Packages that use TypedInstruction
org.apache.bcel.generic: This package contains the "generic" part of the Byte Code Engineering Library, i.e., classes to dynamically modify class objects and byte code instructions.

Uses of TypedInstruction in org.apache.bcel.generic

Subinterfaces of TypedInstruction in org.apache.bcel.generic
`interface` `ConstantPushInstruction` Denotes a push instruction that produces a literal on the stack such as SIPUSH, BIPUSH, ICONST, etc.

Classes in org.apache.bcel.generic that implement TypedInstruction
`class` `AALOAD` AALOAD - Load reference from array
`class` `AASTORE` AASTORE - Store into reference array
`class` `ACONST_NULL` ACONST_NULL - Push null reference
`class` `ALOAD` ALOAD - Load reference from local variable
`class` `ANEWARRAY` ANEWARRAY - Create new array of references
`class` `ARETURN` ARETURN - Return reference from method
`class` `ArithmeticInstruction` Super class for the family of arithmetic instructions.
`class` `ArrayInstruction` Super class for instructions dealing with array access such as IALOAD.
`class` `ASTORE` ASTORE - Store reference into local variable
`class` `BALOAD` BALOAD - Load byte or boolean from array
`class` `BASTORE` BASTORE - Store into byte or boolean array
`class` `BIPUSH` BIPUSH - Push byte on stack
`class` `CALOAD` CALOAD - Load char from array
`class` `CASTORE` CASTORE - Store into char array
`class` `CHECKCAST` CHECKCAST - Check whether object is of given type
`class` `ConversionInstruction` Super class for the x2y family of instructions.
`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
`class` `D2I` D2I - Convert double to int
`class` `D2L` D2L - Convert double to long
`class` `DADD` DADD - Add doubles
`class` `DALOAD` DALOAD - Load double from array
`class` `DASTORE` DASTORE - Store into double array
`class` `DCMPG` DCMPG - Compare doubles: value1 > value2
`class` `DCMPL` DCMPL - Compare doubles: value1 < value2
`class` `DCONST` DCONST - Push 0.0 or 1.0, other values cause an exception
`class` `DDIV` DDIV - Divide doubles
`class` `DLOAD` DLOAD - Load double from local variable
`class` `DMUL` DMUL - Multiply doubles
`class` `DNEG` DNEG - Negate double
`class` `DREM` DREM - Remainder of doubles
`class` `DRETURN` DRETURN - Return double from method
`class` `DSTORE` DSTORE - Store double into local variable
`class` `DSUB` DSUB - Substract doubles
`class` `F2D` F2D - Convert float to double
`class` `F2I` F2I - Convert float to int
`class` `F2L` F2L - Convert float to long
`class` `FADD` FADD - Add floats
`class` `FALOAD` FALOAD - Load float from array
`class` `FASTORE` FASTORE - Store into float array
`class` `FCMPG` FCMPG - Compare floats: value1 > value2
`class` `FCMPL` FCMPL - Compare floats: value1 < value2
`class` `FCONST` FCONST - Push 0.0, 1.0 or 2.0, other values cause an exception
`class` `FDIV` FDIV - Divide floats
`class` `FieldInstruction` Super class for the GET/PUTxxx family of instructions.
`class` `FieldOrMethod` Super class for InvokeInstruction and FieldInstruction, since they have some methods in common!
`class` `FLOAD` FLOAD - Load float from local variable
`class` `FMUL` FMUL - Multiply floats
`class` `FNEG` FNEG - Negate float
`class` `FREM` FREM - Remainder of floats
`class` `FRETURN` FRETURN - Return float from method
`class` `FSTORE` FSTORE - Store float into local variable
`class` `FSUB` FSUB - Substract floats
`class` `GETFIELD` GETFIELD - Fetch field from object
`class` `GETSTATIC` GETSTATIC - Fetch static field from class
`class` `I2B` I2B - Convert int to byte
`class` `I2C` I2C - Convert int to char
`class` `I2D` I2D - Convert int to double
`class` `I2F` I2F - Convert int to float
`class` `I2L` I2L - Convert int to long
`class` `I2S` I2S - Convert int to short
`class` `IADD` IADD - Add ints
`class` `IALOAD` IALOAD - Load int from array
`class` `IAND` IAND - Bitwise AND int
`class` `IASTORE` IASTORE - Store into int array
`class` `ICONST` ICONST - Push value between -1, ..., 5, other values cause an exception
`class` `IDIV` IDIV - Divide ints
`class` `IINC` IINC - Increment local variable by constant
`class` `ILOAD` ILOAD - Load int from local variable onto stack
`class` `IMUL` IMUL - Multiply ints
`class` `INEG` INEG - Negate int
`class` `INSTANCEOF` INSTANCEOF - Determine if object is of given type
`class` `InvokeInstruction` Super class for the INVOKExxx family of instructions.
`class` `INVOKEINTERFACE` INVOKEINTERFACE - Invoke interface method
`class` `INVOKESPECIAL` INVOKESPECIAL - Invoke instance method; special handling for superclass, private and instance initialization method invocations
`class` `INVOKESTATIC` INVOKESTATIC - Invoke a class (static) method
`class` `INVOKEVIRTUAL` INVOKEVIRTUAL - Invoke instance method; dispatch based on class
`class` `IOR` IOR - Bitwise OR int
`class` `IREM` IREM - Remainder of int
`class` `IRETURN` IRETURN - Return int from method
`class` `ISHL` ISHL - Arithmetic shift left int
`class` `ISHR` ISHR - Arithmetic shift right int
`class` `ISTORE` ISTORE - Store int from stack into local variable
`class` `ISUB` ISUB - Substract ints
`class` `IUSHR` IUSHR - Logical shift right int
`class` `IXOR` IXOR - Bitwise XOR int
`class` `JSR` JSR - Jump to subroutine
`class` `JSR_W` JSR_W - Jump to subroutine
`class` `JsrInstruction` Super class for JSR - Jump to subroutine
`class` `L2D` L2D - Convert long to double
`class` `L2F` L2F - Convert long to float
`class` `L2I` L2I - Convert long to int
`class` `LADD` LADD - Add longs
`class` `LALOAD` LALOAD - Load long from array
`class` `LAND` LAND - Bitwise AND longs
`class` `LASTORE` LASTORE - Store into long array
`class` `LCMP` LCMP - Compare longs:
`class` `LCONST` LCONST - Push 0 or 1, other values cause an exception
`class` `LDC` LDC - Push item from constant pool.
`class` `LDC_W` LDC_W - Push item from constant pool (wide index)
`class` `LDC2_W` LDC2_W - Push long or double from constant pool
`class` `LDIV` LDIV - Divide longs
`class` `LLOAD` LLOAD - Load long from local variable
`class` `LMUL` LMUL - Multiply longs
`class` `LNEG` LNEG - Negate long
`class` `LoadInstruction` Denotes an unparameterized instruction to load a value from a local variable, e.g.
`class` `LocalVariableInstruction` Abstract super class for instructions dealing with local variables.
`class` `LOR` LOR - Bitwise OR long
`class` `LREM` LREM - Remainder of long
`class` `LRETURN` LRETURN - Return long from method
`class` `LSHL` LSHL - Arithmetic shift left long
`class` `LSHR` LSHR - Arithmetic shift right long
`class` `LSTORE` LSTORE - Store long into local variable
`class` `LSUB` LSUB - Substract longs
`class` `LUSHR` LUSHR - Logical shift right long
`class` `LXOR` LXOR - Bitwise XOR long
`class` `MULTIANEWARRAY` MULTIANEWARRAY - Create new mutidimensional array of references
`class` `NEW` NEW - Create new object
`class` `PUTFIELD` PUTFIELD - Put field in object
`class` `PUTSTATIC` PUTSTATIC - Put static field in class
`class` `RET` RET - Return from subroutine
`class` `RETURN` RETURN - Return from void method
`class` `ReturnInstruction` Super class for the xRETURN family of instructions.
`class` `SALOAD` SALOAD - Load short from array
`class` `SASTORE` SASTORE - Store into short array
`class` `SIPUSH` SIPUSH - Push short
`class` `StoreInstruction` Denotes an unparameterized instruction to store a value into a local variable, e.g.

Methods in org.apache.bcel.generic with parameters of type TypedInstruction
`void` `Visitor.visitTypedInstruction(TypedInstruction obj)`
`void` `EmptyVisitor.visitTypedInstruction(TypedInstruction obj)`

Copyright © 2002-2006 Apache Software Foundation. All Rights Reserved.