org.apache.bcel.generic

## 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:
    `Const`, `InstructionConst`

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from interface org.apache.bcel.generic.InstructionConstants

      `InstructionConstants.Clinit`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected ClassGen` | `cg` Deprecated. (since 6.0) will be made private; do not access directly, use getter/setter
    `protected ConstantPoolGen` | `cp` Deprecated. (since 6.0) will be made private; do not access directly, use getter/setter

    - ### Fields inherited from interface org.apache.bcel.generic.InstructionConstants

      `AALOAD, AASTORE, ACONST_NULL, ALOAD_0, ALOAD_1, ALOAD_2, ARETURN, ARRAYLENGTH, ASTORE_0, ASTORE_1, ASTORE_2, ATHROW, BALOAD, BASTORE, bla, CALOAD, CASTORE, D2F, D2I, D2L, DADD, DALOAD, DASTORE, DCMPG, DCMPL, DCONST_0, DCONST_1, DDIV, DMUL, DNEG, DREM, DRETURN, DSUB, DUP, DUP_X1, DUP_X2, DUP2, DUP2_X1, DUP2_X2, F2D, F2I, F2L, FADD, FALOAD, FASTORE, FCMPG, FCMPL, FCONST_0, FCONST_1, FCONST_2, FDIV, FMUL, FNEG, FREM, FRETURN, FSUB, I2B, I2C, I2D, I2F, I2L, I2S, IADD, IALOAD, IAND, IASTORE, ICONST_0, ICONST_1, ICONST_2, ICONST_3, ICONST_4, ICONST_5, ICONST_M1, IDIV, ILOAD_0, ILOAD_1, ILOAD_2, IMUL, INEG, INSTRUCTIONS, IOR, IREM, IRETURN, ISHL, ISHR, ISTORE_0, ISTORE_1, ISTORE_2, ISUB, IUSHR, IXOR, L2D, L2F, L2I, LADD, LALOAD, LAND, LASTORE, LCMP, LCONST_0, LCONST_1, LDIV, LMUL, LNEG, LOR, LREM, LRETURN, LSHL, LSHR, LSUB, LUSHR, LXOR, MONITORENTER, MONITOREXIT, NOP, POP, POP2, RETURN, SALOAD, SASTORE, SWAP, THIS`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `InstructionFactory(ClassGen cg)` Initialize with ClassGen object
    `InstructionFactory(ClassGen cg, ConstantPoolGen cp)`
    `InstructionFactory(ConstantPoolGen cp)` Initialize just with ConstantPoolGen object

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `Instruction` | `createAppend(Type type)`
    `static ArrayInstruction` | `createArrayLoad(Type type)`
    `static ArrayInstruction` | `createArrayStore(Type type)`
    `static ArithmeticInstruction` | `createBinaryOperation(String op, Type type)` Create binary operation for simple basic types, such as int and float.
    `static BranchInstruction` | `createBranchInstruction(short opcode, InstructionHandle target)` Create branch instruction by given opcode, except LOOKUPSWITCH and TABLESWITCH.
    `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.
    `CHECKCAST` | `createCheckCast(ReferenceType t)`
    `Instruction` | `createConstant(Object value)` Uses PUSH to push a constant value onto the stack.
    `static StackInstruction` | `createDup_1(int size)`
    `static StackInstruction` | `createDup_2(int size)`
    `static StackInstruction` | `createDup(int size)`
    `FieldInstruction` | `createFieldAccess(String className, String name, Type type, short kind)` Create a field instruction.
    `GETFIELD` | `createGetField(String className, String name, Type t)`
    `GETSTATIC` | `createGetStatic(String className, String name, Type t)`
    `INSTANCEOF` | `createInstanceOf(ReferenceType t)`
    `InvokeInstruction` | `createInvoke(String className, String name, Type retType, Type[] argTypes, short kind)` Create an invoke instruction.
    `InvokeInstruction` | `createInvoke(String className, String name, Type retType, Type[] argTypes, short kind, boolean use_interface)` Create an invoke instruction.
    `static LocalVariableInstruction` | `createLoad(Type type, int index)`
    `NEW` | `createNew(ObjectType t)`
    `NEW` | `createNew(String s)`
    `Instruction` | `createNewArray(Type t, short dim)` Create new array of given size and type.
    `static Instruction` | `createNull(Type type)` Create "null" value for reference types, 0 for basic types like int
    `static StackInstruction` | `createPop(int size)`
    `InstructionList` | `createPrintln(String s)` Create a call to the most popular System.out.println() method.
    `PUTFIELD` | `createPutField(String className, String name, Type t)`
    `PUTSTATIC` | `createPutStatic(String className, String name, Type t)`
    `static ReturnInstruction` | `createReturn(Type type)` Create typed return
    `static LocalVariableInstruction` | `createStore(Type type, int index)`
    `static Instruction` | `createThis()` Create reference to `this'
    `ClassGen` | `getClassGen()`
    `ConstantPoolGen` | `getConstantPool()`
    `void` | `setClassGen(ClassGen c)`
    `void` | `setConstantPool(ConstantPoolGen c)`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### cg

          @Deprecated
          protected ClassGen cg

      Deprecated. (since 6.0) will be made private; do not access directly, use getter/setter

    - #### cp

          @Deprecated
          protected ConstantPoolGen cp

      Deprecated. (since 6.0) will be made private; do not access directly, use getter/setter

  - ### Constructor Detail

    - #### 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 Detail

    - #### 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()

    - #### 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'

    - #### 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:
        `Const`

    - #### 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

          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:
        `Const`

    - #### createInvoke

          public InvokeInstruction createInvoke(String className,
                                                String name,
                                                Type retType,
                                                Type[] argTypes,
                                                short kind,
                                                boolean use_interface)

      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
        `use_interface` - 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)

Copyright © 2004–2022 The Apache Software Foundation. All rights reserved.