Class InstructionFactory

java.lang.Object
org.apache.bcel.generic.InstructionFactory
All Implemented Interfaces:
InstructionConstants

public class InstructionFactory extends Object implements InstructionConstants
Instances of this class may be used, e.g., to generate typed versions of instructions. Its main purpose is to be used as the byte code generating backend of a compiler. You can subclass it to add your own create methods.

Note: The static createXXX methods return singleton instances from the InstructionConst class.

See Also:
  • Field Details

  • Constructor Details

    • InstructionFactory

      public InstructionFactory(ClassGen cg)
      Initialize with ClassGen object
    • InstructionFactory

      public InstructionFactory(ClassGen cg, ConstantPoolGen cp)
    • InstructionFactory

      public InstructionFactory(ConstantPoolGen cp)
      Initialize just with ConstantPoolGen object
  • Method Details

    • createArrayLoad

      public static ArrayInstruction createArrayLoad(Type type)
      Parameters:
      type - type of elements of array, i.e., array.getElementType()
    • createArrayStore

      public static ArrayInstruction createArrayStore(Type type)
      Parameters:
      type - type of elements of array, i.e., array.getElementType()
    • createBinaryDoubleOp

      private static ArithmeticInstruction createBinaryDoubleOp(char op)
    • createBinaryFloatOp

      private static ArithmeticInstruction createBinaryFloatOp(char op)
    • createBinaryIntOp

      private static ArithmeticInstruction createBinaryIntOp(char first, String op)
    • createBinaryLongOp

      private static ArithmeticInstruction createBinaryLongOp(char first, String op)
      Create an invokedynamic instruction.
      Parameters:
      bootstrap_index - index into the bootstrap_methods array
      name - name of the called method
      ret_type - return type of method
      argTypes - argument types of method
      See Also:
    • createBinaryOperation

      public static ArithmeticInstruction createBinaryOperation(String op, Type type)
      Create binary operation for simple basic types, such as int and float.
      Parameters:
      op - operation, such as "+", "*", "<<", etc.
    • createBranchInstruction

      public static BranchInstruction createBranchInstruction(short opcode, InstructionHandle target)
      Create branch instruction by given opcode, except LOOKUPSWITCH and TABLESWITCH. For those you should use the SWITCH compound instruction.
    • createDup

      public static StackInstruction createDup(int size)
      Parameters:
      size - size of operand, either 1 (int, e.g.) or 2 (double)
    • createDup_1

      public static StackInstruction createDup_1(int size)
      Parameters:
      size - size of operand, either 1 (int, e.g.) or 2 (double)
    • createDup_2

      public static StackInstruction createDup_2(int size)
      Parameters:
      size - size of operand, either 1 (int, e.g.) or 2 (double)
    • createLoad

      public static LocalVariableInstruction createLoad(Type type, int index)
      Parameters:
      index - index of local variable
    • createNull

      public static Instruction createNull(Type type)
      Create "null" value for reference types, 0 for basic types like int
    • createPop

      public static StackInstruction createPop(int size)
      Parameters:
      size - size of operand, either 1 (int, e.g.) or 2 (double)
    • createReturn

      public static ReturnInstruction createReturn(Type type)
      Create typed return
    • createStore

      public static LocalVariableInstruction createStore(Type type, int index)
      Parameters:
      index - index of local variable
    • createThis

      public static Instruction createThis()
      Create reference to 'this'
    • isString

      private static boolean isString(Type type)
    • createAppend

      public Instruction createAppend(Type type)
    • createCast

      public Instruction createCast(Type srcType, Type destType)
      Create conversion operation for two stack operands, this may be an I2C, instruction, e.g., if the operands are basic types and CHECKCAST if they are reference types.
    • createCheckCast

      public CHECKCAST createCheckCast(ReferenceType t)
    • createConstant

      public Instruction createConstant(Object value)
      Uses PUSH to push a constant value onto the stack.
      Parameters:
      value - must be of type Number, Boolean, Character or String
    • createFieldAccess

      public FieldInstruction createFieldAccess(String className, String name, Type type, short kind)
      Create a field instruction.
      Parameters:
      className - name of the accessed class
      name - name of the referenced field
      type - type of field
      kind - how to access, i.e., GETFIELD, PUTFIELD, GETSTATIC, PUTSTATIC
      See Also:
    • createGetField

      public GETFIELD createGetField(String className, String name, Type t)
    • createGetStatic

      public GETSTATIC createGetStatic(String className, String name, Type t)
    • createInstanceOf

      public INSTANCEOF createInstanceOf(ReferenceType t)
    • createInvoke

      private InvokeInstruction createInvoke(InstructionFactory.MethodObject m, short kind)
    • createInvoke

      public InvokeInstruction createInvoke(String className, String name, Type retType, Type[] argTypes, short kind)
      Create an invoke instruction. (Except for invokedynamic.)
      Parameters:
      className - name of the called class
      name - name of the called method
      retType - return type of method
      argTypes - argument types of method
      kind - how to invoke, i.e., INVOKEINTERFACE, INVOKESTATIC, INVOKEVIRTUAL, or INVOKESPECIAL
      See Also:
    • createInvoke

      public InvokeInstruction createInvoke(String className, String name, Type retType, Type[] argTypes, short kind, boolean useInterface)
      Create an invoke instruction. (Except for invokedynamic.)
      Parameters:
      className - name of the called class
      name - name of the called method
      retType - return type of method
      argTypes - argument types of method
      kind - how to invoke: INVOKEINTERFACE, INVOKESTATIC, INVOKEVIRTUAL, or INVOKESPECIAL
      useInterface - force use of InterfaceMethodref
      Returns:
      A new InvokeInstruction.
      Since:
      6.5.0
    • createNew

      public NEW createNew(ObjectType t)
    • createNew

      public NEW createNew(String s)
    • createNewArray

      public Instruction createNewArray(Type t, short dim)
      Create new array of given size and type.
      Returns:
      an instruction that creates the corresponding array at runtime, i.e. is an AllocationInstruction
    • createPrintln

      public InstructionList createPrintln(String s)
      Create a call to the most popular System.out.println() method.
      Parameters:
      s - the string to print
    • createPutField

      public PUTFIELD createPutField(String className, String name, Type t)
    • createPutStatic

      public PUTSTATIC createPutStatic(String className, String name, Type t)
    • getClassGen

      public ClassGen getClassGen()
    • getConstantPool

      public ConstantPoolGen getConstantPool()
    • setClassGen

      public void setClassGen(ClassGen c)
    • setConstantPool

      public void setConstantPool(ConstantPoolGen c)