How to use org.apache.bcel.generic

public static void compileStripSpace(BranchHandle strip[], 
         int sCount,
         InstructionList il) {
final InstructionHandle target = il.append(ICONST_1);
il.append(IRETURN);
for (int i = 0; i < sCount; i++) {
  strip[i].setTarget(target);
}
}

public RtMethodGenerator(int access_flags, Type return_type,
       Type[] arg_types, String[] arg_names,
       String method_name, String class_name,
       InstructionList il, ConstantPoolGen cp) {
super(access_flags, return_type, arg_types, arg_names, method_name, 
   class_name, il, cp);

_astoreHandler = new ASTORE(HANDLER_INDEX);
_aloadHandler  = new ALOAD(HANDLER_INDEX);
}

  public BranchInstruction LE(boolean tozero) {
  return tozero ? (BranchInstruction) new IFLE(null) : 
    (BranchInstruction) new IF_ICMPLE(null);
  }
}

public AttributeSetMethodGenerator(String methodName, ClassGen classGen) {
super(org.apache.bcel.Constants.ACC_PRIVATE,
   org.apache.bcel.generic.Type.VOID,
   argTypes, argNames, methodName, 
   classGen.getClassName(),
   new InstructionList(),
   classGen.getConstantPool());

_aloadDom       = new ALOAD(DOM_INDEX);
_astoreDom      = new ASTORE(DOM_INDEX);
_astoreIterator = new ASTORE(ITERATOR_INDEX);
_aloadIterator  = new ALOAD(ITERATOR_INDEX);
_astoreHandler  = new ASTORE(HANDLER_INDEX);
_aloadHandler   = new ALOAD(HANDLER_INDEX);
}

/**
 * Translates an object of this type to its unboxed representation.
 */ 
public void translateUnBox(ClassGenerator classGen,
        MethodGenerator methodGen) {
final ConstantPoolGen cpg = classGen.getConstantPool();
final InstructionList il = methodGen.getInstructionList();
il.append(new CHECKCAST(cpg.addClass(BOOLEAN_CLASS)));
il.append(new INVOKEVIRTUAL(cpg.addMethodref(BOOLEAN_CLASS,
             BOOLEAN_VALUE, 
             BOOLEAN_VALUE_SIG)));
}

/**
 * Translates an object of this type to its unboxed representation.
 */ 
public void translateUnBox(ClassGenerator classGen,
        MethodGenerator methodGen) {
final ConstantPoolGen cpg = classGen.getConstantPool();
final InstructionList il = methodGen.getInstructionList();
il.append(new CHECKCAST(cpg.addClass(RUNTIME_NODE_CLASS)));
il.append(new GETFIELD(cpg.addFieldref(RUNTIME_NODE_CLASS,
            NODE_FIELD,
            NODE_FIELD_SIG)));
}

  /**
   * Translate code to call the BasisLibrary.unallowed_extensionF(String)
   * method.
   */
  private void translateUnallowedExtension(ConstantPoolGen cpg,
                       InstructionList il) {
  int index = cpg.addMethodref(BASIS_LIBRARY_CLASS,
           "unallowed_extension_functionF",
           "(Ljava/lang/String;)V");
  il.append(new PUSH(cpg, _fname.toString()));
  il.append(new INVOKESTATIC(index));   
  }      
}

public TestGenerator(int access_flags, Type return_type,
     Type[] arg_types, String[] arg_names,
     String method_name, String class_name,
     InstructionList il, ConstantPoolGen cp) {
super(access_flags, return_type, arg_types, arg_names, method_name, 
   class_name, il, cp);

_iloadCurrent  = new ILOAD(CURRENT_NODE_INDEX);
_istoreCurrent = new ISTORE(CURRENT_NODE_INDEX);
_iloadContext  = new ILOAD(CONTEXT_NODE_INDEX);
_istoreContext  = new ILOAD(CONTEXT_NODE_INDEX);
_astoreIterator = new ASTORE(ITERATOR_INDEX);
_aloadIterator  = new ALOAD(ITERATOR_INDEX);
}

public MatchGenerator(int access_flags, Type return_type, 
     Type[] arg_types, String[] arg_names, 
     String method_name, String class_name,
     InstructionList il, ConstantPoolGen cp) {
super(access_flags, return_type, arg_types, arg_names, method_name, 
   class_name, il, cp);

_iloadCurrent = new ILOAD(CURRENT_INDEX);
_istoreCurrent = new ISTORE(CURRENT_INDEX);
}

/**
 * Return whether the given FieldInstruction accesses a long or double
 * field.
 *
 * @param fieldIns
 *            the FieldInstruction
 * @param cpg
 *            the ConstantPoolGen for the method
 */
protected static boolean isLongOrDouble(FieldInstruction fieldIns, ConstantPoolGen cpg) {
  Type type = fieldIns.getFieldType(cpg);
  int code = type.getType();
  return code == Const.T_LONG || code == Const.T_DOUBLE;
}

public BranchInstruction LT(boolean tozero) {
return tozero ? (BranchInstruction) new IFLT(null) : 
  (BranchInstruction) new IF_ICMPLT(null);
}

public BranchInstruction GT(boolean tozero) {
return tozero ? (BranchInstruction) new IFGT(null) : 
  (BranchInstruction) new IF_ICMPGT(null);
}

public BranchInstruction GE(boolean tozero) {
return tozero ? (BranchInstruction) new IFGE(null) : 
  (BranchInstruction) new IF_ICMPGE(null);
}

/**
 * Determine if the given ObjectType reference represents a
 * <em>universal</em> exception handler. That is, one that will catch any
 * kind of exception.
 *
 * @param catchType
 *            the ObjectType of the exception handler
 * @return true if catchType is null, or if catchType is java.lang.Throwable
 */
public static boolean isUniversalExceptionHandler(ObjectType catchType) {
  return catchType == null || catchType.equals(Type.THROWABLE);
}

private static boolean internalIsSynthetic(final FieldGenOrMethodGen m) {
  if (m.isSynthetic()) {
    return true;
  }
  for (final Attribute a : m.getAttributes()) {
    if (a instanceof Synthetic) {
      return true;
    }
  }
  return false;
}

public static void compilePreserveSpace(BranchHandle preserve[], 
          int pCount,
          InstructionList il) {
final InstructionHandle target = il.append(ICONST_0);
il.append(IRETURN);
for (int i = 0; i < pCount; i++) {
  preserve[i].setTarget(target);
}
}

  public BranchInstruction LE(boolean tozero) {
  return tozero ? (BranchInstruction) new IFLE(null) : 
    (BranchInstruction) new IF_ICMPLE(null);
  }
}

public BranchInstruction LT(boolean tozero) {
return tozero ? (BranchInstruction) new IFLT(null) : 
  (BranchInstruction) new IF_ICMPLT(null);
}

public BranchInstruction GT(boolean tozero) {
return tozero ? (BranchInstruction) new IFGT(null) : 
  (BranchInstruction) new IF_ICMPGT(null);
}

public BranchInstruction GE(boolean tozero) {
return tozero ? (BranchInstruction) new IFGE(null) : 
  (BranchInstruction) new IF_ICMPGE(null);
}