Example usage for org.objectweb.asm Opcodes IFLE

Introduction

In this page you can find the example usage for org.objectweb.asm Opcodes IFLE.

Prototype

int IFLE

To view the source code for org.objectweb.asm Opcodes IFLE.

Click Source Link

Usage

From source file:jpcsp.Allegrex.compiler.CodeInstruction.java

License:Open Source License

private int getBranchingOpcode(CompilerContext context, MethodVisitor mv) {
    int branchingOpcode = Opcodes.NOP;

    if (insn == Instructions.BEQ) {
        branchingOpcode = getBranchingOpcodeBranch2(context, mv, Opcodes.IF_ICMPEQ, Opcodes.IF_ICMPNE);
    } else if (insn == Instructions.BEQL) {
        branchingOpcode = getBranchingOpcodeBranch2L(context, mv, Opcodes.IF_ICMPEQ, Opcodes.IF_ICMPNE);
    } else if (insn == Instructions.BNE) {
        branchingOpcode = getBranchingOpcodeBranch2(context, mv, Opcodes.IF_ICMPNE, Opcodes.IF_ICMPEQ);
    } else if (insn == Instructions.BNEL) {
        branchingOpcode = getBranchingOpcodeBranch2L(context, mv, Opcodes.IF_ICMPNE, Opcodes.IF_ICMPEQ);
    } else if (insn == Instructions.BGEZ) {
        branchingOpcode = getBranchingOpcodeBranch1(context, mv, Opcodes.IFGE, Opcodes.IFLT);
    } else if (insn == Instructions.BGEZL) {
        branchingOpcode = getBranchingOpcodeBranch1L(context, mv, Opcodes.IFGE, Opcodes.IFLT);
    } else if (insn == Instructions.BGTZ) {
        branchingOpcode = getBranchingOpcodeBranch1(context, mv, Opcodes.IFGT, Opcodes.IFLE);
    } else if (insn == Instructions.BGTZL) {
        branchingOpcode = getBranchingOpcodeBranch1L(context, mv, Opcodes.IFGT, Opcodes.IFLE);
    } else if (insn == Instructions.BLEZ) {
        branchingOpcode = getBranchingOpcodeBranch1(context, mv, Opcodes.IFLE, Opcodes.IFGT);
    } else if (insn == Instructions.BLEZL) {
        branchingOpcode = getBranchingOpcodeBranch1L(context, mv, Opcodes.IFLE, Opcodes.IFGT);
    } else if (insn == Instructions.BLTZ) {
        branchingOpcode = getBranchingOpcodeBranch1(context, mv, Opcodes.IFLT, Opcodes.IFGE);
    } else if (insn == Instructions.BLTZL) {
        branchingOpcode = getBranchingOpcodeBranch1L(context, mv, Opcodes.IFLT, Opcodes.IFGE);
    } else if (insn == Instructions.J) {
        branchingOpcode = getBranchingOpcodeBranch0(context, mv);
    } else if (insn == Instructions.JAL) {
        branchingOpcode = getBranchingOpcodeCall0(context, mv);
    } else if (insn == Instructions.BLTZAL) {
        branchingOpcode = getBranchingOpcodeCall1(context, mv, Opcodes.IFLT, Opcodes.IFGE);
    } else if (insn == Instructions.BLTZALL) {
        branchingOpcode = getBranchingOpcodeCall1L(context, mv, Opcodes.IFLT, Opcodes.IFGE);
    } else if (insn == Instructions.BGEZAL) {
        branchingOpcode = getBranchingOpcodeCall1(context, mv, Opcodes.IFGE, Opcodes.IFLT);
    } else if (insn == Instructions.BGEZALL) {
        branchingOpcode = getBranchingOpcodeCall1L(context, mv, Opcodes.IFGE, Opcodes.IFLT);
    } else if (insn == Instructions.BC1F) {
        branchingOpcode = getBranchingOpcodeBC1(context, mv, Opcodes.IFEQ, Opcodes.IFNE);
    } else if (insn == Instructions.BC1FL) {
        branchingOpcode = getBranchingOpcodeBC1L(context, mv, Opcodes.IFEQ, Opcodes.IFNE);
    } else if (insn == Instructions.BC1T) {
        branchingOpcode = getBranchingOpcodeBC1(context, mv, Opcodes.IFNE, Opcodes.IFEQ);
    } else if (insn == Instructions.BC1TL) {
        branchingOpcode = getBranchingOpcodeBC1L(context, mv, Opcodes.IFNE, Opcodes.IFEQ);
    } else if (insn == Instructions.BVF) {
        branchingOpcode = getBranchingOpcodeBV(context, mv, Opcodes.IFEQ, Opcodes.IFNE);
    } else if (insn == Instructions.BVT) {
        branchingOpcode = getBranchingOpcodeBV(context, mv, Opcodes.IFNE, Opcodes.IFEQ);
    } else if (insn == Instructions.BVFL) {
        branchingOpcode = getBranchingOpcodeBVL(context, mv, Opcodes.IFEQ, Opcodes.IFNE);
    } else if (insn == Instructions.BVTL) {
        branchingOpcode = getBranchingOpcodeBVL(context, mv, Opcodes.IFNE, Opcodes.IFEQ);
    } else {//from ww  w  .j  a  va 2 s . com
        log.error("CodeInstruction.getBranchingOpcode: unknown instruction "
                + insn.disasm(getAddress(), getOpcode()));
    }

    return branchingOpcode;
}

---

From source file:name.martingeisse.minimal.compiler.Compiler.java

License:Open Source License

/**
 * Compiles a {@link MethodNode} to MCode.
 * /*w  ww. j ava2  s. co m*/
 * @param methodNode the method node to compile
 * @return the compiled code
 */
public ImmutableList<MCodeEntry> compile(final MethodNode methodNode) {
    for (int i = 0; i < methodNode.instructions.size(); i++) {
        final AbstractInsnNode instruction = methodNode.instructions.get(i);
        if (instruction instanceof LineNumberNode) {
            // ignored
        } else if (instruction instanceof FrameNode) {
            // this could be useful in the future
        } else if (instruction instanceof LabelNode) {
            label(((LabelNode) instruction).getLabel());
        } else if (instruction instanceof InsnNode) {
            switch (instruction.getOpcode()) {

            case Opcodes.ICONST_M1:
                iconst(-1);
                break;

            case Opcodes.ICONST_0:
                iconst(0);
                break;

            case Opcodes.ICONST_1:
                iconst(1);
                break;

            case Opcodes.ICONST_2:
                iconst(2);
                break;

            case Opcodes.ICONST_3:
                iconst(3);
                break;

            case Opcodes.ICONST_4:
                iconst(4);
                break;

            case Opcodes.ICONST_5:
                iconst(5);
                break;

            default:
                unsupported(instruction);
                break;

            }
        } else if (instruction instanceof VarInsnNode) {
            final VarInsnNode varInsnNode = (VarInsnNode) instruction;
            switch (varInsnNode.getOpcode()) {

            case Opcodes.ILOAD:
                iload(varInsnNode.var);
                break;

            case Opcodes.ISTORE:
                istore(varInsnNode.var);
                break;

            default:
                unsupported(instruction);
                break;

            }
        } else if (instruction instanceof IincInsnNode) {
            final IincInsnNode iincInsnNode = (IincInsnNode) instruction;
            iinc(iincInsnNode.var, iincInsnNode.incr);
        } else if (instruction instanceof JumpInsnNode) {
            final JumpInsnNode jumpInsnNode = (JumpInsnNode) instruction;
            switch (jumpInsnNode.getOpcode()) {

            case Opcodes.IFEQ:
            case Opcodes.IFNE:
            case Opcodes.IFLT:
            case Opcodes.IFGE:
            case Opcodes.IFGT:
            case Opcodes.IFLE:
                branch1(jumpInsnNode.label.getLabel(), jumpInsnNode.getOpcode());
                break;

            case Opcodes.IF_ICMPEQ:
            case Opcodes.IF_ICMPNE:
            case Opcodes.IF_ICMPLT:
            case Opcodes.IF_ICMPGE:
            case Opcodes.IF_ICMPGT:
            case Opcodes.IF_ICMPLE:
                branch2(jumpInsnNode.label.getLabel(), jumpInsnNode.getOpcode());
                break;

            case Opcodes.IFNULL:
            case Opcodes.IFNONNULL:
                // unsupported: one-argument reference comparison operator
                unsupported(instruction);
                break;

            case Opcodes.IF_ACMPEQ:
            case Opcodes.IF_ACMPNE:
                // unsupported: two-argument reference comparison operator
                unsupported(instruction);
                break;

            case Opcodes.GOTO:
                jump(jumpInsnNode.label.getLabel());
                break;

            case Opcodes.JSR:
                jsr(jumpInsnNode.label.getLabel());
                break;

            default:
                unsupported(instruction);
                break;

            }
        } else if (instruction instanceof IntInsnNode) {
            final IntInsnNode intInsnNode = (IntInsnNode) instruction;
            if (instruction.getOpcode() == Opcodes.BIPUSH || instruction.getOpcode() == Opcodes.SIPUSH) {
                iconst(intInsnNode.operand);
            } else {
                // NEWARRAY
                unsupported(instruction);
            }
        } else if (instruction instanceof MethodInsnNode) {
            final MethodInsnNode methodInsnNode = (MethodInsnNode) instruction;
            if (methodInsnNode.getOpcode() == Opcodes.INVOKESTATIC) {
                if (methodInsnNode.owner.replace('/', '.').equals(Native.class.getName())) {
                    nativeCall(methodInsnNode.name, methodInsnNode.desc);
                } else {
                    unsupported(instruction);
                }
            } else {
                unsupported(instruction);
            }
        } else {
            unsupported(instruction);
        }
    }
    return builder.build();
}

---

From source file:name.martingeisse.minimal.compiler.Compiler.java

License:Open Source License

private MBinaryIntegerOperator mapOperator(final int jvmOpcode) {
    switch (jvmOpcode) {

    case Opcodes.IFEQ:
    case Opcodes.IF_ICMPEQ:
        return MBinaryIntegerOperator.EQUAL;

    case Opcodes.IFNE:
    case Opcodes.IF_ICMPNE:
        return MBinaryIntegerOperator.NOT_EQUAL;

    case Opcodes.IFLT:
    case Opcodes.IF_ICMPLT:
        return MBinaryIntegerOperator.LESS_THAN;

    case Opcodes.IFLE:
    case Opcodes.IF_ICMPLE:
        return MBinaryIntegerOperator.LESS_THAN_OR_EQUAL;

    case Opcodes.IFGT:
    case Opcodes.IF_ICMPGT:
        return MBinaryIntegerOperator.GREATER_THAN;

    case Opcodes.IFGE:
    case Opcodes.IF_ICMPGE:
        return MBinaryIntegerOperator.GREATER_THAN_OR_EQUAL;

    default://from ww w  . ja v  a 2 s  . co  m
        throw new IllegalArgumentException("cannot map comparison operator for JVM opcode: " + jvmOpcode);

    }
}

---

From source file:org.adjective.stout.operation.JumpOperation.java

License:Apache License

public void getInstructions(ExecutionStack stack, InstructionCollector collector) {
    switch (_op) {
    case Opcodes.IFEQ:
    case Opcodes.IFNE:
    case Opcodes.IFLT:
    case Opcodes.IFGE:
    case Opcodes.IFGT:
    case Opcodes.IFLE:
        checkExpression(TypeDescriptor.INT, stack);
        break;/*from   w  w  w .  j a  va 2  s.c  o  m*/
    case Opcodes.IFNULL:
    case Opcodes.IFNONNULL:
        checkExpression(TypeDescriptor.OBJECT, stack);
        break;
    default:
        throw new IllegalStateException("Do not know how to handle jump opcode " + getOpcodeDescription(_op));
    }
    _expression.getInstructions(stack, collector);
    collector.add(new JumpInstruction(_op, _label));
}

---

From source file:org.decojer.cavaj.readers.asm.ReadMethodVisitor.java

License:Open Source License

@Override
public void visitJumpInsn(final int opcode, final Label label) {
    T t = null;// w  ww  .j  ava 2s.  c o  m
    Object oValue = null;

    final int targetPc = getPc(label);

    switch (opcode) {
    /********
     * GOTO *
     ********/
    case Opcodes.GOTO: {
        final GOTO op = new GOTO(this.ops.size(), opcode, this.line);
        add(op);
        op.setTargetPc(targetPc);
        if (targetPc < 0) {
            getUnresolved(label).add(op);
        }
        break;
    }
    /********
     * JCMP *
     ********/
    case Opcodes.IF_ACMPEQ:
        t = T.REF;
        oValue = CmpType.T_EQ;
        // fall through
    case Opcodes.IF_ACMPNE:
        if (t == null) {
            t = T.REF;
            oValue = CmpType.T_NE;
        }
        // fall through
    case Opcodes.IF_ICMPEQ:
        if (t == null) {
            t = T.AINT; // boolean too
            oValue = CmpType.T_EQ;
        }
        // fall through
    case Opcodes.IF_ICMPGE:
        if (t == null) {
            t = T.INT;
            oValue = CmpType.T_GE;
        }
        // fall through
    case Opcodes.IF_ICMPGT:
        if (t == null) {
            t = T.INT;
            oValue = CmpType.T_GT;
        }
        // fall through
    case Opcodes.IF_ICMPLE:
        if (t == null) {
            t = T.INT;
            oValue = CmpType.T_LE;
        }
        // fall through
    case Opcodes.IF_ICMPLT:
        if (t == null) {
            t = T.INT;
            oValue = CmpType.T_LT;
        }
        // fall through
    case Opcodes.IF_ICMPNE:
        if (t == null) {
            t = T.AINT; // boolean too
            oValue = CmpType.T_NE;
        } {
        assert oValue instanceof CmpType;
        final JCMP op = new JCMP(this.ops.size(), opcode, this.line, t, (CmpType) oValue);
        add(op);
        op.setTargetPc(targetPc);
        if (targetPc < 0) {
            getUnresolved(label).add(op);
        }
    }
        break;
    /********
     * JCND *
     ********/
    case Opcodes.IFNULL:
        t = T.REF;
        oValue = CmpType.T_EQ;
        // fall through
    case Opcodes.IFNONNULL:
        if (t == null) {
            t = T.REF;
            oValue = CmpType.T_NE;
        }
        // fall through
    case Opcodes.IFEQ:
        if (t == null) {
            t = T.AINT; // boolean too
            oValue = CmpType.T_EQ;
        }
        // fall through
    case Opcodes.IFGE:
        if (t == null) {
            t = T.INT;
            oValue = CmpType.T_GE;
        }
        // fall through
    case Opcodes.IFGT:
        if (t == null) {
            t = T.INT;
            oValue = CmpType.T_GT;
        }
        // fall through
    case Opcodes.IFLE:
        if (t == null) {
            t = T.INT;
            oValue = CmpType.T_LE;
        }
        // fall through
    case Opcodes.IFLT:
        if (t == null) {
            t = T.INT;
            oValue = CmpType.T_LT;
        }
        // fall through
    case Opcodes.IFNE:
        if (t == null) {
            t = T.AINT; // boolean too
            oValue = CmpType.T_NE;
        } {
        assert oValue instanceof CmpType;
        final JCND op = new JCND(this.ops.size(), opcode, this.line, t, (CmpType) oValue);
        add(op);
        op.setTargetPc(targetPc);
        if (targetPc < 0) {
            getUnresolved(label).add(op);
        }
    }
        break;
    /*******
     * JSR *
     *******/
    case Opcodes.JSR: {
        final JSR op = new JSR(this.ops.size(), opcode, this.line);
        add(op);
        op.setTargetPc(targetPc);
        if (targetPc < 0) {
            getUnresolved(label).add(op);
        }
        break;
    }
    default:
        log.warn(getM() + ": Unknown jump insn opcode '" + opcode + "'!");
    }
}

---

From source file:org.evosuite.graphs.cfg.BytecodeInstructionPool.java

License:Open Source License

/**
 * Determine how many bytes the current instruction occupies together with
 * its operands//  w w w. j  a v a2s. com
 * 
 * @return
 */
private int getBytecodeIncrement(AbstractInsnNode instructionNode) {
    int opcode = instructionNode.getOpcode();
    switch (opcode) {
    case Opcodes.ALOAD: // index
    case Opcodes.ASTORE: // index
    case Opcodes.DLOAD:
    case Opcodes.DSTORE:
    case Opcodes.FLOAD:
    case Opcodes.FSTORE:
    case Opcodes.ILOAD:
    case Opcodes.ISTORE:
    case Opcodes.LLOAD:
    case Opcodes.LSTORE:
        VarInsnNode varNode = (VarInsnNode) instructionNode;
        if (varNode.var > 3)
            return 1;
        else
            return 0;
    case Opcodes.BIPUSH: // byte
    case Opcodes.NEWARRAY:
    case Opcodes.RET:
        return 1;
    case Opcodes.LDC:
        LdcInsnNode ldcNode = (LdcInsnNode) instructionNode;
        if (ldcNode.cst instanceof Double || ldcNode.cst instanceof Long)
            return 2; // LDC2_W
        else
            return 1;
    case 19: //LDC_W
    case 20: //LDC2_W
        return 2;
    case Opcodes.ANEWARRAY: // indexbyte1, indexbyte2
    case Opcodes.CHECKCAST: // indexbyte1, indexbyte2
    case Opcodes.GETFIELD:
    case Opcodes.GETSTATIC:
    case Opcodes.GOTO:
    case Opcodes.IF_ACMPEQ:
    case Opcodes.IF_ACMPNE:
    case Opcodes.IF_ICMPEQ:
    case Opcodes.IF_ICMPNE:
    case Opcodes.IF_ICMPGE:
    case Opcodes.IF_ICMPGT:
    case Opcodes.IF_ICMPLE:
    case Opcodes.IF_ICMPLT:
    case Opcodes.IFLE:
    case Opcodes.IFLT:
    case Opcodes.IFGE:
    case Opcodes.IFGT:
    case Opcodes.IFNE:
    case Opcodes.IFEQ:
    case Opcodes.IFNONNULL:
    case Opcodes.IFNULL:
    case Opcodes.IINC:
    case Opcodes.INSTANCEOF:
    case Opcodes.INVOKESPECIAL:
    case Opcodes.INVOKESTATIC:
    case Opcodes.INVOKEVIRTUAL:
    case Opcodes.JSR:
    case Opcodes.NEW:
    case Opcodes.PUTFIELD:
    case Opcodes.PUTSTATIC:
    case Opcodes.SIPUSH:
        // case Opcodes.LDC_W
        // case Opcodes.LDC2_W

        return 2;
    case Opcodes.MULTIANEWARRAY:
        return 3;
    case Opcodes.INVOKEDYNAMIC:
    case Opcodes.INVOKEINTERFACE:
        return 4;

    case Opcodes.LOOKUPSWITCH:
    case Opcodes.TABLESWITCH:
        // TODO: Could be more
        return 4;
    // case Opcodes.GOTO_W 
    // case Opcodes.JSR_W
    }
    return 0;
}

---

From source file:org.evosuite.instrumentation.ContainerTransformation.java

License:Open Source License

private static InsnList createNewIfThenElse(MethodInsnNode n) {
    LabelNode labelIsNotEmpty = new LabelNode();
    LabelNode labelEndif = new LabelNode();
    InsnList il = new InsnList();
    il.add(n);// ww w  .j a v a2s.  c  om
    il.add(new JumpInsnNode(Opcodes.IFLE, labelIsNotEmpty));
    il.add(new InsnNode(Opcodes.ICONST_1));
    il.add(new JumpInsnNode(Opcodes.GOTO, labelEndif));
    il.add(labelIsNotEmpty);
    il.add(new InsnNode(Opcodes.ICONST_0));
    il.add(labelEndif);
    return il;
}

---

From source file:org.evosuite.instrumentation.coverage.BranchInstrumentation.java

License:Open Source License

/**
 * <p>//from  www  .j  a v  a2  s  . com
 * getInstrumentation
 * </p>
 *
 * @param instruction
 *            a {@link org.evosuite.graphs.cfg.BytecodeInstruction} object.
 * @return a {@link org.objectweb.asm.tree.InsnList} object.
 */
protected InsnList getInstrumentation(BytecodeInstruction instruction) {
    if (instruction == null)
        throw new IllegalArgumentException("null given");
    if (!instruction.isActualBranch())
        throw new IllegalArgumentException("branch instruction expected");
    if (!BranchPool.getInstance(classLoader).isKnownAsNormalBranchInstruction(instruction))
        throw new IllegalArgumentException(
                "expect given instruction to be known by the BranchPool as a normal branch instruction");

    int opcode = instruction.getASMNode().getOpcode();
    int instructionId = instruction.getInstructionId();
    int branchId = BranchPool.getInstance(classLoader).getActualBranchIdForNormalBranchInstruction(instruction);
    if (branchId < 0)
        throw new IllegalStateException("expect BranchPool to know branchId for all branch instructions");

    InsnList instrumentation = new InsnList();

    switch (opcode) {
    case Opcodes.IFEQ:
    case Opcodes.IFNE:
    case Opcodes.IFLT:
    case Opcodes.IFGE:
    case Opcodes.IFGT:
    case Opcodes.IFLE:
        instrumentation.add(new InsnNode(Opcodes.DUP));
        instrumentation.add(new LdcInsnNode(opcode));
        // instrumentation.add(new LdcInsnNode(id));
        instrumentation.add(new LdcInsnNode(branchId));
        instrumentation.add(new LdcInsnNode(instructionId));
        instrumentation.add(
                new MethodInsnNode(Opcodes.INVOKESTATIC, EXECUTION_TRACER, "passedBranch", "(IIII)V", false));
        logger.debug("Adding passedBranch val=?, opcode=" + opcode + ", branch=" + branchId + ", bytecode_id="
                + instructionId);

        break;
    case Opcodes.IF_ICMPEQ:
    case Opcodes.IF_ICMPNE:
    case Opcodes.IF_ICMPLT:
    case Opcodes.IF_ICMPGE:
    case Opcodes.IF_ICMPGT:
    case Opcodes.IF_ICMPLE:
        instrumentation.add(new InsnNode(Opcodes.DUP2));
        instrumentation.add(new LdcInsnNode(opcode));
        // instrumentation.add(new LdcInsnNode(id));
        instrumentation.add(new LdcInsnNode(branchId));
        instrumentation.add(new LdcInsnNode(instructionId));
        instrumentation.add(
                new MethodInsnNode(Opcodes.INVOKESTATIC, EXECUTION_TRACER, "passedBranch", "(IIIII)V", false));
        break;
    case Opcodes.IF_ACMPEQ:
    case Opcodes.IF_ACMPNE:
        instrumentation.add(new InsnNode(Opcodes.DUP2));
        instrumentation.add(new LdcInsnNode(opcode));
        // instrumentation.add(new LdcInsnNode(id));
        instrumentation.add(new LdcInsnNode(branchId));
        instrumentation.add(new LdcInsnNode(instructionId));
        instrumentation.add(new MethodInsnNode(Opcodes.INVOKESTATIC, EXECUTION_TRACER, "passedBranch",
                "(Ljava/lang/Object;Ljava/lang/Object;III)V", false));
        break;
    case Opcodes.IFNULL:
    case Opcodes.IFNONNULL:
        instrumentation.add(new InsnNode(Opcodes.DUP));
        instrumentation.add(new LdcInsnNode(opcode));
        // instrumentation.add(new LdcInsnNode(id));
        instrumentation.add(new LdcInsnNode(branchId));
        instrumentation.add(new LdcInsnNode(instructionId));
        instrumentation.add(new MethodInsnNode(Opcodes.INVOKESTATIC, EXECUTION_TRACER, "passedBranch",
                "(Ljava/lang/Object;III)V", false));
        break;
    }
    return instrumentation;
}

---

From source file:org.evosuite.instrumentation.error.DequeInstrumentation.java

License:Open Source License

@Override
public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
    if (listNames.contains(owner)) {
        if (emptyListMethods.contains(name)) {
            // empty
            Map<Integer, Integer> tempVariables = getMethodCallee(desc);

            tagBranchStart();// ww  w  .  j av  a2s  . co m
            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, owner, "isEmpty", "()Z", false);
            insertBranchWithoutTag(Opcodes.IFLE, "java/util/NoSuchElementException");
            tagBranchEnd();
            restoreMethodParameters(tempVariables, desc);

        }
    }
}

---

From source file:org.evosuite.instrumentation.error.LinkedHashSetInstrumentation.java

License:Open Source License

@Override
public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
    if (owner.equals(SETNAME)) {
        if (emptyListMethods.contains(name)) {
            // empty
            Map<Integer, Integer> tempVariables = getMethodCallee(desc);

            tagBranchStart();/*from w w w .  jav  a  2s  . co  m*/
            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, SETNAME, "isEmpty", "()Z", false);
            insertBranchWithoutTag(Opcodes.IFLE, "java/util/NoSuchElementException");
            tagBranchEnd();
            restoreMethodParameters(tempVariables, desc);

        }
    }
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• »