Example usage for org.objectweb.asm Opcodes DADD

Introduction

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

Prototype

int DADD

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

Click Source Link

Usage

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

License:Open Source License

@Test
public void testAddUnderflow() {
    int result = ErrorConditionChecker.underflowDistance(x, y, Opcodes.DADD);
    assertUnderflow(new BigDecimal(x).add(new BigDecimal(y)), result, x + y);
}

---

From source file:org.evosuite.instrumentation.mutation.ReplaceArithmeticOperator.java

License:Open Source License

/**
 * <p>calculate</p>//from  w  ww .jav a2s . com
 *
 * @param x a double.
 * @param y a double.
 * @param opcode a int.
 * @return a double.
 */
public static double calculate(double x, double y, int opcode) {
    switch (opcode) {
    case Opcodes.DADD:
        return x + y;
    case Opcodes.DSUB:
        return x - y;
    case Opcodes.DMUL:
        return x * y;
    case Opcodes.DDIV:
        return x / y;
    case Opcodes.DREM:
        return x % y;
    }
    throw new RuntimeException("Unknown integer opcode: " + opcode);
}

---

From source file:org.jacoco.core.internal.instr.FrameTracker.java

License:Open Source License

@Override
public void visitInsn(final int opcode) {
    final Object t1, t2, t3, t4;
    switch (opcode) {
    case Opcodes.NOP:
    case Opcodes.RETURN:
        break;/*  www  .  j a  va2 s .co m*/
    case Opcodes.ARETURN:
    case Opcodes.ATHROW:
    case Opcodes.FRETURN:
    case Opcodes.IRETURN:
    case Opcodes.MONITORENTER:
    case Opcodes.MONITOREXIT:
    case Opcodes.POP:
        pop(1);
        break;
    case Opcodes.DRETURN:
    case Opcodes.LRETURN:
    case Opcodes.POP2:
        pop(2);
        break;
    case Opcodes.AASTORE:
    case Opcodes.BASTORE:
    case Opcodes.CASTORE:
    case Opcodes.FASTORE:
    case Opcodes.IASTORE:
    case Opcodes.SASTORE:
        pop(3);
        break;
    case Opcodes.LASTORE:
    case Opcodes.DASTORE:
        pop(4);
        break;
    case Opcodes.ICONST_M1:
    case Opcodes.ICONST_0:
    case Opcodes.ICONST_1:
    case Opcodes.ICONST_2:
    case Opcodes.ICONST_3:
    case Opcodes.ICONST_4:
    case Opcodes.ICONST_5:
        push(Opcodes.INTEGER);
        break;
    case Opcodes.ARRAYLENGTH:
    case Opcodes.F2I:
    case Opcodes.I2B:
    case Opcodes.I2C:
    case Opcodes.I2S:
    case Opcodes.INEG:
        pop(1);
        push(Opcodes.INTEGER);
        break;
    case Opcodes.BALOAD:
    case Opcodes.CALOAD:
    case Opcodes.D2I:
    case Opcodes.FCMPG:
    case Opcodes.FCMPL:
    case Opcodes.IADD:
    case Opcodes.IALOAD:
    case Opcodes.IAND:
    case Opcodes.IDIV:
    case Opcodes.IMUL:
    case Opcodes.IOR:
    case Opcodes.IREM:
    case Opcodes.ISHL:
    case Opcodes.ISHR:
    case Opcodes.ISUB:
    case Opcodes.IUSHR:
    case Opcodes.IXOR:
    case Opcodes.L2I:
    case Opcodes.SALOAD:
        pop(2);
        push(Opcodes.INTEGER);
        break;
    case Opcodes.DCMPG:
    case Opcodes.DCMPL:
    case Opcodes.LCMP:
        pop(4);
        push(Opcodes.INTEGER);
        break;
    case Opcodes.FCONST_0:
    case Opcodes.FCONST_1:
    case Opcodes.FCONST_2:
        push(Opcodes.FLOAT);
        break;
    case Opcodes.FNEG:
    case Opcodes.I2F:
        pop(1);
        push(Opcodes.FLOAT);
        break;
    case Opcodes.D2F:
    case Opcodes.FADD:
    case Opcodes.FALOAD:
    case Opcodes.FDIV:
    case Opcodes.FMUL:
    case Opcodes.FREM:
    case Opcodes.FSUB:
    case Opcodes.L2F:
        pop(2);
        push(Opcodes.FLOAT);
        break;
    case Opcodes.LCONST_0:
    case Opcodes.LCONST_1:
        push(Opcodes.LONG);
        push(Opcodes.TOP);
        break;
    case Opcodes.F2L:
    case Opcodes.I2L:
        pop(1);
        push(Opcodes.LONG);
        push(Opcodes.TOP);
        break;
    case Opcodes.D2L:
    case Opcodes.LALOAD:
    case Opcodes.LNEG:
        pop(2);
        push(Opcodes.LONG);
        push(Opcodes.TOP);
        break;
    case Opcodes.LSHL:
    case Opcodes.LSHR:
    case Opcodes.LUSHR:
        pop(3);
        push(Opcodes.LONG);
        push(Opcodes.TOP);
        break;
    case Opcodes.LADD:
    case Opcodes.LAND:
    case Opcodes.LDIV:
    case Opcodes.LMUL:
    case Opcodes.LOR:
    case Opcodes.LREM:
    case Opcodes.LSUB:
    case Opcodes.LXOR:
        pop(4);
        push(Opcodes.LONG);
        push(Opcodes.TOP);
        break;
    case Opcodes.DCONST_0:
    case Opcodes.DCONST_1:
        push(Opcodes.DOUBLE);
        push(Opcodes.TOP);
        break;
    case Opcodes.F2D:
    case Opcodes.I2D:
        pop(1);
        push(Opcodes.DOUBLE);
        push(Opcodes.TOP);
        break;
    case Opcodes.DALOAD:
    case Opcodes.DNEG:
    case Opcodes.L2D:
        pop(2);
        push(Opcodes.DOUBLE);
        push(Opcodes.TOP);
        break;
    case Opcodes.DADD:
    case Opcodes.DDIV:
    case Opcodes.DMUL:
    case Opcodes.DREM:
    case Opcodes.DSUB:
        pop(4);
        push(Opcodes.DOUBLE);
        push(Opcodes.TOP);
        break;
    case Opcodes.ACONST_NULL:
        push(Opcodes.NULL);
        break;
    case Opcodes.AALOAD:
        pop(1);
        t1 = pop();
        push(Type.getType(((String) t1).substring(1)));
        break;
    case Opcodes.DUP:
        t1 = pop();
        push(t1);
        push(t1);
        break;
    case Opcodes.DUP_X1:
        t1 = pop();
        t2 = pop();
        push(t1);
        push(t2);
        push(t1);
        break;
    case Opcodes.DUP_X2:
        t1 = pop();
        t2 = pop();
        t3 = pop();
        push(t1);
        push(t3);
        push(t2);
        push(t1);
        break;
    case Opcodes.DUP2:
        t1 = pop();
        t2 = pop();
        push(t2);
        push(t1);
        push(t2);
        push(t1);
        break;
    case Opcodes.DUP2_X1:
        t1 = pop();
        t2 = pop();
        t3 = pop();
        push(t2);
        push(t1);
        push(t3);
        push(t2);
        push(t1);
        break;
    case Opcodes.DUP2_X2:
        t1 = pop();
        t2 = pop();
        t3 = pop();
        t4 = pop();
        push(t2);
        push(t1);
        push(t4);
        push(t3);
        push(t2);
        push(t1);
        break;
    case Opcodes.SWAP:
        t1 = pop();
        t2 = pop();
        push(t1);
        push(t2);
        break;
    default:
        throw new IllegalArgumentException();
    }
    mv.visitInsn(opcode);
}

---

From source file:org.jboss.byteman.rule.expression.ArithmeticExpression.java

License:Open Source License

public void compile(MethodVisitor mv, CompileContext compileContext) throws CompileException {
    // make sure we are at the right source line
    compileContext.notifySourceLine(line);

    int currentStack = compileContext.getStackCount();
    int expectedStack = 0;
    Expression operand0 = getOperand(0);
    Expression operand1 = getOperand(1);
    Type type0 = operand0.getType();
    Type type1 = operand1.getType();
    // compile lhs -- it adds 1 or 2 to the stack height
    operand0.compile(mv, compileContext);
    // do any required type conversion
    compileTypeConversion(type0, type, mv, compileContext);
    // compile rhs -- it adds 1 or 2 to the stack height
    operand1.compile(mv, compileContext);
    // do any required type conversion
    compileTypeConversion(type1, type, mv, compileContext);

    try {//from   w  ww . java2 s  .  com
        // n.b. be careful with characters here
        if (type == type.B || type == type.S || type == type.C || type == type.I) {
            // TODO we should probably only respect the byte, short and char types for + and -
            // TODO also need to decide how to handle divide by zero

            expectedStack = 1;

            switch (oper) {
            case MUL:
                mv.visitInsn(Opcodes.IMUL);
                break;
            case DIV:
                mv.visitInsn(Opcodes.IDIV);
                break;
            case PLUS:
                mv.visitInsn(Opcodes.IADD);
                break;
            case MINUS:
                mv.visitInsn(Opcodes.ISUB);
                break;
            case MOD:
                mv.visitInsn(Opcodes.IREM);
                break;
            default:
                // should never happen
                throw new CompileException("ArithmeticExpression.compile : unexpected operator " + oper);
            }
            // now coerce back to appropriate type
            if (type == type.B) {
                mv.visitInsn(Opcodes.I2B);
            } else if (type == type.S) {
                mv.visitInsn(Opcodes.I2S);
            } else if (type == type.C) {
                mv.visitInsn(Opcodes.I2C);
            } // else if (type == type.I) { do nothing }
              // ok, we popped two bytes but added one
            compileContext.addStackCount(-1);
        } else if (type == type.J) {

            expectedStack = 2;

            switch (oper) {
            case MUL:
                mv.visitInsn(Opcodes.LMUL);
                break;
            case DIV:
                mv.visitInsn(Opcodes.LDIV);
                break;
            case PLUS:
                mv.visitInsn(Opcodes.LADD);
                break;
            case MINUS:
                mv.visitInsn(Opcodes.LSUB);
                break;
            case MOD:
                mv.visitInsn(Opcodes.LREM);
                break;
            default:
                // should never happen
                throw new CompileException("ArithmeticExpression.compile : unexpected operator " + oper);
            }
            // ok, we popped four bytes but added two
            compileContext.addStackCount(-2);
        } else if (type == type.F) {

            expectedStack = 1;

            switch (oper) {
            case MUL:
                mv.visitInsn(Opcodes.FMUL);
                break;
            case DIV:
                mv.visitInsn(Opcodes.FDIV);
                break;
            case PLUS:
                mv.visitInsn(Opcodes.FADD);
                break;
            case MINUS:
                mv.visitInsn(Opcodes.FSUB);
                break;
            case MOD:
                mv.visitInsn(Opcodes.FREM);
                break;
            default:
                // should never happen
                throw new CompileException("ArithmeticExpression.compile : unexpected operator " + oper);
            }
            // ok, we popped two bytes but added one
            compileContext.addStackCount(-1);
        } else if (type == type.D) {

            expectedStack = 2;

            switch (oper) {
            case MUL:
                mv.visitInsn(Opcodes.DMUL);
                break;
            case DIV:
                mv.visitInsn(Opcodes.DDIV);
                break;
            case PLUS:
                mv.visitInsn(Opcodes.DADD);
                break;
            case MINUS:
                mv.visitInsn(Opcodes.DSUB);
                break;
            case MOD:
                mv.visitInsn(Opcodes.DREM);
                break;
            default:
                // should never happen
                throw new CompileException("ArithmeticExpression.compile : unexpected operator " + oper);
            }
            // ok, we popped four bytes but added two
            compileContext.addStackCount(-2);
        } else {
            throw new CompileException(
                    "ArithmeticExpression.compile : unexpected result type " + type.getName());
        }
    } catch (CompileException e) {
        throw e;
    } catch (Exception e) {
        throw new CompileException("ArithmeticExpression.compile : unexpected exception for operation " + token
                + getPos() + " in rule " + rule.getName(), e);
    }

    // check stack heights
    if (compileContext.getStackCount() != currentStack + expectedStack) {
        throw new CompileException("ArithmeticExpression.compile : invalid stack height "
                + compileContext.getStackCount() + " expecting " + (currentStack + expectedStack));
    }
}

---

From source file:org.jboss.byteman.rule.expression.PlusExpression.java

License:Open Source License

public void compile(MethodVisitor mv, CompileContext compileContext) throws CompileException {
    // make sure we are at the right source line
    compileContext.notifySourceLine(line);

    Expression oper0 = getOperand(0);
    Expression oper1 = getOperand(1);

    int currentStack = compileContext.getStackCount();
    int expected = 0;

    // compile and type convert each operand -- adds 2 or 4 depending upon type
    oper0.compile(mv, compileContext);//from   w w w  . j  a v  a2s  .co  m
    compileTypeConversion(oper0.getType(), type, mv, compileContext);
    oper1.compile(mv, compileContext);
    compileTypeConversion(oper1.getType(), type, mv, compileContext);

    if (type == Type.STRING) {
        // ok, we could optimize this for the case where the left or right operand is a String plus expression
        // by employing a StringBuffer but for now we will just evaluate the left and right operand and
        // then call concat to join them
        // add two strings leaving one string
        expected = 1;
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/String", "concat",
                "(Ljava/lang/String;)Ljava/lang/String;");
        compileContext.addStackCount(-1);
    } else if (type == Type.B) {
        // add two bytes leaving one byte
        expected = 1;
        mv.visitInsn(Opcodes.IADD);
        mv.visitInsn(Opcodes.I2B);
        compileContext.addStackCount(-1);
    } else if (type == Type.S) {
        // add two shorts leaving one short
        expected = 1;
        mv.visitInsn(Opcodes.IADD);
        mv.visitInsn(Opcodes.I2S);
        compileContext.addStackCount(-1);
    } else if (type == Type.C) {
        // add two chars leaving one char
        expected = 1;
        mv.visitInsn(Opcodes.IADD);
        mv.visitInsn(Opcodes.I2C);
        compileContext.addStackCount(-1);
    } else if (type == Type.I) {
        // add two ints leaving one int
        expected = 1;
        mv.visitInsn(Opcodes.IADD);
        compileContext.addStackCount(-1);
    } else if (type == Type.J) {
        // add two longs leaving one long
        expected = 2;
        mv.visitInsn(Opcodes.LADD);
        compileContext.addStackCount(-2);
    } else if (type == Type.F) {
        // add two floats leaving one float
        expected = 1;
        mv.visitInsn(Opcodes.FADD);
        compileContext.addStackCount(-1);
    } else if (type == Type.D) {
        // add two doubles leaving one double
        expected = 2;
        mv.visitInsn(Opcodes.DADD);
        compileContext.addStackCount(-2);
    }

    if (compileContext.getStackCount() != currentStack + expected) {
        throw new CompileException("PlusExpression.compile : invalid stack height "
                + compileContext.getStackCount() + " expecting " + (currentStack + expected));
    }
}

---

From source file:org.openquark.cal.internal.javamodel.AsmJavaBytecodeGenerator.java

License:Open Source License

private static final int getBinaryDoubleOpCode(String op) {
    switch (op.charAt(0)) {
    case '-':
        return Opcodes.DSUB;
    case '+':
        return Opcodes.DADD;
    case '*':
        return Opcodes.DMUL;
    case '/':
        return Opcodes.DDIV;
    case '%':
        return Opcodes.DREM;
    default:/*from   w w w. j a v a  2s  .c om*/
        throw new IllegalArgumentException("Invalid operand " + op);
    }
}

---

From source file:org.pitest.mutationtest.engine.gregor.mutators.experimental.extended.AODMutator1.java

License:Apache License

@Override
public void visitInsn(int opcode) {
    switch (opcode) {
    case Opcodes.IADD:
    case Opcodes.ISUB:
    case Opcodes.IMUL:
    case Opcodes.IDIV:
    case Opcodes.IREM:

    case Opcodes.FADD:
    case Opcodes.FSUB:
    case Opcodes.FMUL:
    case Opcodes.FDIV:
    case Opcodes.FREM:
        if (this.shouldMutate(OpcodeToType.typeOfOpcode(opcode))) {
            mv.visitInsn(Opcodes.POP);//from www  .j a va  2s . c  o  m
        } else {
            mv.visitInsn(opcode);
        }
        break;
    case Opcodes.LADD:
    case Opcodes.LSUB:
    case Opcodes.LMUL:
    case Opcodes.LDIV:
    case Opcodes.LREM:

    case Opcodes.DADD:
    case Opcodes.DSUB:
    case Opcodes.DMUL:
    case Opcodes.DDIV:
    case Opcodes.DREM:
        if (this.shouldMutate(OpcodeToType.typeOfOpcode(opcode))) {
            mv.visitInsn(Opcodes.POP2);
        } else {
            mv.visitInsn(opcode);
        }
        break;
    default:
        mv.visitInsn(opcode);
        break;
    }
}

---

From source file:org.pitest.mutationtest.engine.gregor.mutators.experimental.extended.AODMutator2.java

License:Apache License

@Override
public void visitInsn(int opcode) {
    switch (opcode) {
    case Opcodes.IADD:
    case Opcodes.ISUB:
    case Opcodes.IMUL:
    case Opcodes.IDIV:
    case Opcodes.IREM:
        if (this.shouldMutate(OpcodeToType.typeOfOpcode(opcode))) {
            int storage = this.newLocal(Type.INT_TYPE);
            mv.visitVarInsn(Opcodes.ISTORE, storage);
            mv.visitInsn(Opcodes.POP);/*from  w  w w  .ja va 2 s  .c  om*/
            mv.visitVarInsn(Opcodes.ILOAD, storage);
            /*
             * Alternative : mv.visitInsn(Opcodes.SWAP);
             * mv.visitInsn(Opcodes.POP);
             * mv.visitVarInsn(Opcodes.ILOAD,storage);
             */
        } else {
            mv.visitInsn(opcode);
        }
        break;
    case Opcodes.FADD:
    case Opcodes.FSUB:
    case Opcodes.FMUL:
    case Opcodes.FDIV:
    case Opcodes.FREM:
        if (this.shouldMutate(OpcodeToType.typeOfOpcode(opcode))) {
            int storage = this.newLocal(Type.FLOAT_TYPE);
            mv.visitVarInsn(Opcodes.FSTORE, storage);
            mv.visitInsn(Opcodes.POP);
            mv.visitVarInsn(Opcodes.FLOAD, storage);
        } else {
            mv.visitInsn(opcode);
        }
        break;
    case Opcodes.LADD:
    case Opcodes.LSUB:
    case Opcodes.LMUL:
    case Opcodes.LDIV:
    case Opcodes.LREM:
        if (this.shouldMutate(OpcodeToType.typeOfOpcode(opcode))) {
            int storage = this.newLocal(Type.LONG_TYPE);
            mv.visitVarInsn(Opcodes.LSTORE, storage);
            mv.visitInsn(Opcodes.POP2);
            mv.visitVarInsn(Opcodes.LLOAD, storage);
        } else {
            mv.visitInsn(opcode);
        }
        break;
    case Opcodes.DADD:
    case Opcodes.DSUB:
    case Opcodes.DMUL:
    case Opcodes.DDIV:
    case Opcodes.DREM:
        if (this.shouldMutate(OpcodeToType.typeOfOpcode(opcode))) {
            int storage = this.newLocal(Type.DOUBLE_TYPE);
            mv.visitVarInsn(Opcodes.DSTORE, storage);
            mv.visitInsn(Opcodes.POP2);
            mv.visitVarInsn(Opcodes.DLOAD, storage);
        } else {
            mv.visitInsn(opcode);
        }
        break;
    default:
        mv.visitInsn(opcode);
        break;
    }
}

---

From source file:org.pitest.mutationtest.engine.gregor.mutators.experimental.extended.UOIMutator1.java

License:Apache License

@Override
public void visitVarInsn(int opcode, int var) {
    mv.visitVarInsn(opcode, var);

    switch (opcode) {
    case Opcodes.ILOAD:
        if (this.shouldMutate("Incremented (a++) integer local variable number " + var)) {
            mv.visitIincInsn(var, 1);
        }/*from www. j  a  v  a2  s.  c  om*/
        break;
    case Opcodes.FLOAD:
        if (this.shouldMutate("Incremented (a++) float local variable number " + var)) {
            mv.visitInsn(Opcodes.DUP);
            mv.visitInsn(Opcodes.FCONST_1);
            mv.visitInsn(Opcodes.FADD);
            mv.visitVarInsn(Opcodes.FSTORE, var);
        }
        break;
    case Opcodes.LLOAD:
        if (this.shouldMutate("Incremented (a++) long local variable number " + var)) {
            mv.visitInsn(Opcodes.DUP2);
            mv.visitInsn(Opcodes.LCONST_1);
            mv.visitInsn(Opcodes.LADD);
            mv.visitVarInsn(Opcodes.LSTORE, var);
        }
        break;
    case Opcodes.DLOAD:
        if (this.shouldMutate("Incremented (a++) double local variable number " + var)) {
            mv.visitInsn(Opcodes.DUP2);
            mv.visitInsn(Opcodes.DCONST_1);
            mv.visitInsn(Opcodes.DADD);
            mv.visitVarInsn(Opcodes.DSTORE, var);
        }
        break;

    default:
        break;
    }
}

---

From source file:org.pitest.mutationtest.engine.gregor.mutators.experimental.extended.UOIMutator1.java

License:Apache License

@Override
public void visitInsn(final int opcode) {
    // I F L D + BS
    switch (opcode) {
    case Opcodes.IALOAD:
        if (this.shouldMutate("Incremented (a++) integer array field")) {
            mv.visitInsn(Opcodes.DUP2); // Array and its index on stack, times two
            mv.visitInsn(opcode); // IALOAD
            mv.visitInsn(Opcodes.DUP_X2); // put the result of array[index] under [array ref] [index] [array[index]]
            mv.visitInsn(Opcodes.ICONST_1);
            mv.visitInsn(Opcodes.IADD);/*from   w  w  w .  j  a  v  a2s  . c  o m*/
            mv.visitInsn(Opcodes.IASTORE);
        } else {
            mv.visitInsn(opcode);
        }
        break;
    case Opcodes.FALOAD:
        if (this.shouldMutate("Incremented (a++) float array field")) {
            mv.visitInsn(Opcodes.DUP2);
            mv.visitInsn(opcode);
            mv.visitInsn(Opcodes.DUP_X2);
            mv.visitInsn(Opcodes.FCONST_1);
            mv.visitInsn(Opcodes.FADD);
            mv.visitInsn(Opcodes.FASTORE);
        } else {
            mv.visitInsn(opcode);
        }
        break;
    case Opcodes.LALOAD:
        if (this.shouldMutate("Incremented (a++) long array field")) {
            mv.visitInsn(Opcodes.DUP2);
            mv.visitInsn(opcode);
            mv.visitInsn(Opcodes.DUP2_X2);
            mv.visitInsn(Opcodes.LCONST_1);
            mv.visitInsn(Opcodes.LADD);
            mv.visitInsn(Opcodes.LASTORE);
        } else {
            mv.visitInsn(opcode);
        }
        break;
    case Opcodes.DALOAD:
        if (this.shouldMutate("Incremented (a++) double array field")) {
            mv.visitInsn(Opcodes.DUP2);
            mv.visitInsn(opcode);
            mv.visitInsn(Opcodes.DUP2_X2);
            mv.visitInsn(Opcodes.DCONST_1);
            mv.visitInsn(Opcodes.DADD);
            mv.visitInsn(Opcodes.DASTORE);
        } else {
            mv.visitInsn(opcode);
        }
        break;

    case Opcodes.BALOAD:
        if (this.shouldMutate("Incremented (a++) byte array field")) {
            mv.visitInsn(Opcodes.DUP2);
            mv.visitInsn(opcode);
            mv.visitInsn(Opcodes.DUP_X2);
            mv.visitInsn(Opcodes.ICONST_1);
            mv.visitInsn(Opcodes.IADD);
            mv.visitInsn(Opcodes.I2B);
            mv.visitInsn(Opcodes.BASTORE);
        } else {
            mv.visitInsn(opcode);
        }
        break;

    case Opcodes.SALOAD:
        if (this.shouldMutate("Incremented (a++) short array field")) {
            mv.visitInsn(Opcodes.DUP2);
            mv.visitInsn(opcode);
            mv.visitInsn(Opcodes.DUP_X2);
            mv.visitInsn(Opcodes.ICONST_1);
            mv.visitInsn(Opcodes.IADD);
            mv.visitInsn(Opcodes.I2S);
            mv.visitInsn(Opcodes.SASTORE);
        } else {
            mv.visitInsn(opcode);
        }
        break;

    default:
        mv.visitInsn(opcode);
        break;
    }
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• »