com.sun.org.apache.bcel.internal.generic.Instruction Java Examples

/**
 * Helper method to generate an instance of a subclass of
 * {@link StoreInstruction} based on the specified {@link Type} that will
 * store a value in the specified local variable
 * @param index the JVM stack frame index of the variable that is to be
 * stored
 * @param type the {@link Type} of the variable
 * @return the generated {@link StoredInstruction}
 */
private static Instruction storeLocal(int index, Type type) {
    if (type == Type.BOOLEAN) {
       return new ISTORE(index);
    } else if (type == Type.INT) {
       return new ISTORE(index);
    } else if (type == Type.SHORT) {
       return new ISTORE(index);
    } else if (type == Type.LONG) {
       return new LSTORE(index);
    } else if (type == Type.BYTE) {
       return new ISTORE(index);
    } else if (type == Type.CHAR) {
       return new ISTORE(index);
    } else if (type == Type.FLOAT) {
       return new FSTORE(index);
    } else if (type == Type.DOUBLE) {
       return new DSTORE(index);
    } else {
       return new ASTORE(index);
    }
}
 

/**
 * Helper method to generate an instance of a subclass of
 * {@link LoadInstruction} based on the specified {@link Type} that will
 * load the specified local variable
 * @param index the JVM stack frame index of the variable that is to be
 * loaded
 * @param type the {@link Type} of the variable
 * @return the generated {@link LoadInstruction}
 */
private static Instruction loadLocal(int index, Type type) {
    if (type == Type.BOOLEAN) {
       return new ILOAD(index);
    } else if (type == Type.INT) {
       return new ILOAD(index);
    } else if (type == Type.SHORT) {
       return new ILOAD(index);
    } else if (type == Type.LONG) {
       return new LLOAD(index);
    } else if (type == Type.BYTE) {
       return new ILOAD(index);
    } else if (type == Type.CHAR) {
       return new ILOAD(index);
    } else if (type == Type.FLOAT) {
       return new FLOAD(index);
    } else if (type == Type.DOUBLE) {
       return new DLOAD(index);
    } else {
       return new ALOAD(index);
    }
}
 

/**
 * Returns an instruction for storing a value from the JVM stack
 * into this variable.
 */
public Instruction storeInstruction() {
    if (_storeInstruction == null) {
        _storeInstruction = _type.STORE(_local.getIndex());
    }
    return _storeInstruction;
}
 

public Instruction loadIterator() {
    return _aloadIterator;
}
 

public Instruction storeCurrentNode() {
    return _istoreCurrent;
}
 

public final Instruction reset() {
    return _reset;
}
 

public Instruction LOAD(int slot) {
    return new ALOAD(slot);
}
 

public Instruction loadDOM() {
    return _aloadDom;
}
 

public Instruction loadDOM() {
    return _aloadDom;
}
 

/**
 * Get index of the register where the DOM is stored.
 */
public Instruction loadDOM() {
    return _aloadDom;
}
 

public Instruction STORE(int slot) {
    return new ISTORE(slot);
}
 

public Instruction storeIterator() {
    return _astoreIterator;
}
 

public Instruction storeParameter(int index) {
    return new ASTORE(index + PARAM_START_INDEX);
}
 

public Instruction REM() {
    return InstructionConstants.DREM;
}
 

public Instruction LOAD(int slot) {
    return new ILOAD(slot);
}
 

/** by default context node is the same as current node. MK437 */
public Instruction loadContextNode() {
    return _iloadContext;
}
 

public Instruction loadDOM() {
    return _aloadDom;
}
 

public Instruction DIV() {
    return InstructionConst.DDIV;
}
 

public Instruction storeIterator() {
    return _astoreIterator;
}
 

public Instruction loadHandler() {
    return _aloadHandler;
}
 

public Instruction NEG() {
    return InstructionConst.INEG;
}
 

public Instruction storeDOM() {
    return _astoreDom;
}
 

public Instruction storeContextNode() {
    return _istoreContext;
}
 

public Instruction storeContextNode() {
    return storeCurrentNode();
}
 

public Instruction LOAD(int slot) {
    return null;            // should never be called
}
 

public Instruction storeIterator() {
    return _astoreIterator;
}
 

public Instruction storeParameter(int index) {
    return new ASTORE(index + PARAM_START_INDEX);
}
 

/**
 * Set the instruction for storing a value from the stack into this
 * variable and returns the old instruction.
 */
public Instruction setStoreInstruction(Instruction instruction) {
    Instruction tmp = _storeInstruction;
    _storeInstruction = instruction;
    return tmp;
}
 

public Instruction storeCurrentNode() {
    return _istoreCurrent != null
        ? _istoreCurrent
        : (_istoreCurrent = new ISTORE(getLocalIndex("current")));
}
 

public Instruction SUB() {
    return InstructionConstants.DSUB;
}