Example usage for org.objectweb.asm Opcodes BIPUSH

Introduction

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

Prototype

int BIPUSH

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

Click Source Link

Usage

From source file:com.asakusafw.dag.compiler.codegen.AsmUtil.java

License:Apache License

/**
 * Adds a constant value on to the top of the stack.
 * @param method the current method visitor
 * @param value the target value//from w  ww . ja v a  2s.com
 */
public static void getInt(MethodVisitor method, int value) {
    if (-1 <= value && value <= 5) {
        method.visitInsn(Opcodes.ICONST_0 + value);
    } else if (Byte.MIN_VALUE <= value && value <= Byte.MAX_VALUE) {
        method.visitIntInsn(Opcodes.BIPUSH, value);
    } else if (Short.MIN_VALUE <= value && value <= Short.MAX_VALUE) {
        method.visitIntInsn(Opcodes.SIPUSH, value);
    } else {
        method.visitLdcInsn(value);
    }
}

---

From source file:com.codename1.tools.translator.BytecodeMethod.java

License:Open Source License

boolean optimize() {
    int instructionCount = instructions.size();

    // optimize away a method that only contains the void return instruction e.g. blank constructors etc.
    if (instructionCount < 6) {
        int realCount = instructionCount;
        Instruction actual = null;//from  www  .  ja  va  2 s.c  o  m
        for (int iter = 0; iter < instructionCount; iter++) {
            Instruction current = instructions.get(iter);
            if (current instanceof LabelInstruction) {
                realCount--;
                continue;
            }
            if (current instanceof LineNumber) {
                realCount--;
                continue;
            }
            actual = current;
        }

        if (realCount == 1 && actual != null && actual.getOpcode() == Opcodes.RETURN) {
            return false;
        }
    }

    boolean astoreCalls = false;
    boolean hasInstructions = false;

    boolean hasTryCatch = false;
    for (int iter = 0; iter < instructionCount - 1; iter++) {
        Instruction current = instructions.get(iter);
        if (current instanceof TryCatch) {
            hasTryCatch = true;
        }
        current.setMethod(this);
        if (current.isOptimized()) {
            continue;
        }
        int currentOpcode = current.getOpcode();
        switch (currentOpcode) {
        case Opcodes.CHECKCAST: {
            // Remove the check cast for now as it gets in the way of other optimizations
            instructions.remove(iter);
            iter--;
            instructionCount--;
            break;
        }
        }
    }

    for (int iter = 0; iter < instructionCount - 1; iter++) {
        Instruction current = instructions.get(iter);
        if (current.isOptimized()) {
            // This instruction has already been optimized
            // we should skip it and proceed to the next one
            continue;
        }
        Instruction next = instructions.get(iter + 1);

        int currentOpcode = current.getOpcode();
        int nextOpcode = next.getOpcode();

        if (ArithmeticExpression.isArithmeticOp(current)) {
            int addedIndex = ArithmeticExpression.tryReduce(instructions, iter);
            if (addedIndex >= 0) {
                iter = addedIndex;
                instructionCount = instructions.size();
                continue;
            }
        }

        if (current instanceof Field) {
            int newIter = Field.tryReduce(instructions, iter);
            if (newIter >= 0) {
                iter = newIter;
                instructionCount = instructions.size();
                continue;
            }
        }

        switch (currentOpcode) {

        case Opcodes.ARRAYLENGTH: {
            if (!dependentClasses.contains("java_lang_NullPointerException")) {
                dependentClasses.add("java_lang_NullPointerException");
            }
            int newIter = ArrayLengthExpression.tryReduce(instructions, iter);
            if (newIter >= 0) {
                instructionCount = instructions.size();
                iter = newIter;
                continue;
            }
            break;
        }

        case Opcodes.DUP: {
            int newIter = DupExpression.tryReduce(instructions, iter);
            if (newIter >= 0) {
                iter = newIter;
                instructionCount = instructions.size();
                continue;
            }
            break;
        }

        case Opcodes.POP: {
            if (iter > 0) {
                Instruction prev = instructions.get(iter - 1);
                if (prev instanceof CustomInvoke) {
                    CustomInvoke inv = (CustomInvoke) prev;
                    if (inv.methodHasReturnValue()) {
                        inv.setNoReturn(true);
                        instructions.remove(iter);
                        iter--;
                        instructionCount--;
                        continue;
                    }
                }
            }
            break;
        }

        case Opcodes.ASTORE:
        case Opcodes.ISTORE:
        case Opcodes.DSTORE:
        case Opcodes.LSTORE:
        case Opcodes.FSTORE: {
            if (iter > 0 && current instanceof VarOp) {
                VarOp currentVarOp = (VarOp) current;
                Instruction prev = instructions.get(iter - 1);
                if (prev instanceof AssignableExpression) {
                    AssignableExpression expr = (AssignableExpression) prev;
                    StringBuilder sb = new StringBuilder();
                    if (currentVarOp.assignFrom(expr, sb)) {
                        instructions.remove(iter - 1);
                        instructions.remove(iter - 1);
                        instructions.add(iter - 1,
                                new CustomIntruction(sb.toString(), sb.toString(), dependentClasses));
                        iter = iter - 1;
                        instructionCount = instructions.size();
                        continue;
                    }

                } else if (prev instanceof CustomInvoke) {
                    CustomInvoke inv = (CustomInvoke) prev;
                    StringBuilder sb = new StringBuilder();
                    if (currentVarOp.assignFrom(inv, sb)) {
                        instructions.remove(iter - 1);
                        instructions.remove(iter - 1);
                        instructions.add(iter - 1,
                                new CustomIntruction(sb.toString(), sb.toString(), dependentClasses));
                        iter = iter - 1;
                        instructionCount = instructions.size();
                        continue;
                    }
                }
            }

            break;
        }

        case Opcodes.IRETURN:
        case Opcodes.FRETURN:
        case Opcodes.ARETURN:
        case Opcodes.LRETURN:
        case Opcodes.DRETURN: {
            if (iter > 0 && current instanceof BasicInstruction) {
                Instruction prev = instructions.get(iter - 1);
                if (prev instanceof AssignableExpression) {
                    AssignableExpression expr = (AssignableExpression) prev;
                    StringBuilder sb = new StringBuilder();
                    if (expr.assignTo(null, sb)) {
                        instructions.remove(iter - 1);
                        instructions.remove(iter - 1);
                        String exprString = sb.toString().trim();
                        String retVal = exprString;
                        sb.setLength(0);
                        if (!prev.isConstant()) {
                            sb.append("\n{\n    ");
                            switch (currentOpcode) {
                            case Opcodes.IRETURN:
                                sb.append("JAVA_INT");
                                break;
                            case Opcodes.FRETURN:
                                sb.append("JAVA_FLOAT");
                                break;
                            case Opcodes.ARETURN:
                                sb.append("JAVA_OBJECT");
                                break;
                            case Opcodes.LRETURN:
                                sb.append("JAVA_LONG");
                                break;
                            case Opcodes.DRETURN:
                                sb.append("JAVA_DOUBLE");
                                break;
                            }
                            sb.append(" ___returnValue=").append(exprString).append(";\n");
                            retVal = "___returnValue";
                        }
                        if (synchronizedMethod) {
                            if (staticMethod) {
                                sb.append("    monitorExit(threadStateData, (JAVA_OBJECT)&class__");
                                sb.append(getClsName());
                                sb.append(");\n");
                            } else {
                                sb.append("    monitorExit(threadStateData, __cn1ThisObject);\n");
                            }
                        }
                        if (hasTryCatch) {
                            sb.append(
                                    "    releaseForReturnInException(threadStateData, cn1LocalsBeginInThread, methodBlockOffset); return ")
                                    .append(retVal).append(";\n");
                        } else {
                            sb.append("    releaseForReturn(threadStateData, cn1LocalsBeginInThread); return ")
                                    .append(retVal).append(";\n");
                        }
                        if (!prev.isConstant()) {
                            sb.append("}\n");
                        }

                        instructions.add(iter - 1,
                                new CustomIntruction(sb.toString(), sb.toString(), dependentClasses));
                        iter--;
                        instructionCount = instructions.size();
                        continue;

                    }
                } else if (prev instanceof CustomInvoke) {

                    CustomInvoke expr = (CustomInvoke) prev;
                    String returnType = expr.getReturnValue();
                    if (returnType != null && !"JAVA_OBJECT".equals(returnType)) {
                        // We can't safely return a JAVA_OBJECT directly because it needs to be added 
                        // to the stack for the GC
                        StringBuilder sb = new StringBuilder();
                        if (expr.appendExpression(sb)) {
                            instructions.remove(iter - 1);
                            instructions.remove(iter - 1);
                            String exprString = sb.toString().trim();
                            String retVal = exprString;
                            sb.setLength(0);
                            if (!expr.isConstant()) {

                                sb.append("\n{\n    ");
                                switch (currentOpcode) {
                                case Opcodes.IRETURN:
                                    sb.append("JAVA_INT");
                                    break;
                                case Opcodes.FRETURN:
                                    sb.append("JAVA_FLOAT");
                                    break;
                                case Opcodes.ARETURN:
                                    sb.append("JAVA_OBJECT");
                                    break;
                                case Opcodes.LRETURN:
                                    sb.append("JAVA_LONG");
                                    break;
                                case Opcodes.DRETURN:
                                    sb.append("JAVA_DOUBLE");
                                    break;
                                }

                                sb.append(" ___returnValue=").append(exprString).append(";\n");
                                retVal = "___returnValue";
                            }
                            if (synchronizedMethod) {
                                if (staticMethod) {
                                    sb.append("    monitorExit(threadStateData, (JAVA_OBJECT)&class__");
                                    sb.append(getClsName());
                                    sb.append(");\n");
                                } else {
                                    sb.append("    monitorExit(threadStateData, __cn1ThisObject);\n");
                                }
                            }
                            if (hasTryCatch) {
                                sb.append(
                                        "    releaseForReturnInException(threadStateData, cn1LocalsBeginInThread, methodBlockOffset); return ")
                                        .append(retVal).append(";\n");
                            } else {
                                sb.append(
                                        "    releaseForReturn(threadStateData, cn1LocalsBeginInThread); return ")
                                        .append(retVal).append(";\n");
                            }
                            if (!expr.isConstant()) {
                                sb.append("}\n");
                            }

                            instructions.add(iter - 1,
                                    new CustomIntruction(sb.toString(), sb.toString(), dependentClasses));
                            iter--;
                            instructionCount = instructions.size();
                            continue;

                        }
                    }
                }
            }
            break;
        }

        case Opcodes.BASTORE:
        case Opcodes.SASTORE:
        case Opcodes.CASTORE:
        case Opcodes.AASTORE:
        case Opcodes.IASTORE:
        case Opcodes.DASTORE:
        case Opcodes.LASTORE:
        case Opcodes.FASTORE: {
            if (iter > 2 && current instanceof BasicInstruction) {
                StringBuilder devNull = new StringBuilder();
                String arrayLiteral = null;
                String indexLiteral = null;
                String valueLiteral = null;
                Instruction prev3 = instructions.get(iter - 3);
                if (prev3 instanceof AssignableExpression) {
                    if (((AssignableExpression) prev3).assignTo(null, devNull)) {
                        arrayLiteral = devNull.toString().trim();

                    }
                }
                devNull.setLength(0);
                Instruction prev2 = instructions.get(iter - 2);
                if (prev2 instanceof AssignableExpression) {
                    if (((AssignableExpression) prev2).assignTo(null, devNull)) {
                        indexLiteral = devNull.toString().trim();
                    }
                }
                devNull.setLength(0);
                Instruction prev1 = instructions.get(iter - 1);

                if (prev1 instanceof AssignableExpression) {
                    if (((AssignableExpression) prev1).assignTo(null, devNull)) {
                        valueLiteral = devNull.toString().trim();
                    }
                } else if (prev1 instanceof CustomInvoke) {
                    devNull.setLength(0);
                    if (((CustomInvoke) prev1).appendExpression(devNull)) {
                        valueLiteral = devNull.toString().trim();
                    }
                }

                if (arrayLiteral != null && indexLiteral != null && valueLiteral != null) {
                    String elementType = null;
                    switch (current.getOpcode()) {
                    case Opcodes.AASTORE:
                        elementType = "OBJECT";
                        break;
                    case Opcodes.IASTORE:
                        elementType = "INT";
                        break;
                    case Opcodes.DASTORE:
                        elementType = "DOUBLE";
                        break;

                    case Opcodes.LASTORE:
                        elementType = "LONG";
                        break;
                    case Opcodes.FASTORE:
                        elementType = "FLOAT";
                        break;
                    case Opcodes.CASTORE:
                        elementType = "CHAR";
                        break;
                    case Opcodes.BASTORE:
                        elementType = "BYTE";
                        break;
                    case Opcodes.SASTORE:
                        elementType = "SHORT";
                        break;

                    }
                    if (elementType == null) {
                        break;
                    }

                    instructions.remove(iter - 3);
                    instructions.remove(iter - 3);
                    instructions.remove(iter - 3);
                    instructions.remove(iter - 3);
                    String code = "    CN1_SET_ARRAY_ELEMENT_" + elementType + "(" + arrayLiteral + ", "
                            + indexLiteral + ", " + valueLiteral + ");\n";
                    instructions.add(iter - 3, new CustomIntruction(code, code, dependentClasses));
                    iter = iter - 3;
                    instructionCount = instructions.size();
                    continue;
                }
            }

            break;
        }

        case Opcodes.FALOAD:
        case Opcodes.BALOAD:
        case Opcodes.IALOAD:
        case Opcodes.LALOAD:
        case Opcodes.DALOAD:
        case Opcodes.AALOAD:
        case Opcodes.SALOAD:
        case Opcodes.CALOAD: {
            int newIter = ArrayLoadExpression.tryReduce(instructions, iter);
            if (newIter >= 0) {
                iter = newIter;
                instructionCount = instructions.size();
                continue;
            }
            break;
        }

        /* Try to optimize if statements that just use constants
           and local variables so that they don't need the intermediate
           push and pop from the stack.
        */
        case Opcodes.IF_ACMPEQ:
        case Opcodes.IF_ACMPNE:
        case Opcodes.IF_ICMPLE:
        case Opcodes.IF_ICMPLT:
        case Opcodes.IF_ICMPNE:
        case Opcodes.IF_ICMPGT:
        case Opcodes.IF_ICMPEQ:
        case Opcodes.IF_ICMPGE: {

            if (iter > 1) {
                Instruction leftArg = instructions.get(iter - 2);
                Instruction rightArg = instructions.get(iter - 1);

                String leftLiteral = null;
                String rightLiteral = null;

                if (leftArg instanceof AssignableExpression) {
                    StringBuilder sb = new StringBuilder();
                    if (((AssignableExpression) leftArg).assignTo(null, sb)) {
                        leftLiteral = sb.toString().trim();
                    }
                } else if (leftArg instanceof CustomInvoke) {
                    CustomInvoke inv = (CustomInvoke) leftArg;
                    StringBuilder sb = new StringBuilder();
                    if (!"JAVA_OBJECT".equals(inv.getReturnValue()) && inv.appendExpression(sb)) {
                        leftLiteral = sb.toString().trim();
                    }
                }
                if (rightArg instanceof AssignableExpression) {
                    StringBuilder sb = new StringBuilder();
                    if (((AssignableExpression) rightArg).assignTo(null, sb)) {
                        rightLiteral = sb.toString().trim();
                    }
                } else if (rightArg instanceof CustomInvoke) {
                    CustomInvoke inv = (CustomInvoke) rightArg;
                    StringBuilder sb = new StringBuilder();
                    if (!"JAVA_OBJECT".equals(inv.getReturnValue()) && inv.appendExpression(sb)) {
                        rightLiteral = sb.toString().trim();
                    }
                }

                if (rightLiteral != null && leftLiteral != null) {
                    Jump jmp = (Jump) current;
                    instructions.remove(iter - 2);
                    instructions.remove(iter - 2);
                    instructions.remove(iter - 2);
                    //instructions.remove(iter-2);
                    iter -= 2;
                    //instructionCount -= 2;
                    StringBuilder sb = new StringBuilder();
                    String operator = null;
                    String opName = null;
                    switch (currentOpcode) {
                    case Opcodes.IF_ICMPLE:
                        operator = "<=";
                        opName = "IF_ICMPLE";
                        break;
                    case Opcodes.IF_ICMPLT:
                        operator = "<";
                        opName = "IF_IMPLT";
                        break;
                    case Opcodes.IF_ICMPNE:
                        operator = "!=";
                        opName = "IF_ICMPNE";
                        break;
                    case Opcodes.IF_ICMPGT:
                        operator = ">";
                        opName = "IF_ICMPGT";
                        break;
                    case Opcodes.IF_ICMPGE:
                        operator = ">=";
                        opName = "IF_ICMPGE";
                        break;
                    case Opcodes.IF_ICMPEQ:
                        operator = "==";
                        opName = "IF_ICMPEQ";
                        break;
                    case Opcodes.IF_ACMPEQ:
                        operator = "==";
                        opName = "IF_ACMPEQ";
                        break;
                    case Opcodes.IF_ACMPNE:
                        operator = "!=";
                        opName = "IF_ACMPNE";
                        break;
                    default:
                        throw new RuntimeException(
                                "Invalid operator during optimization of integer comparison");
                    }

                    sb.append("if (").append(leftLiteral).append(operator).append(rightLiteral).append(") /* ")
                            .append(opName).append(" CustomJump */ ");
                    CustomJump newJump = CustomJump.create(jmp, sb.toString());
                    //jmp.setCustomCompareCode(sb.toString());
                    newJump.setOptimized(true);
                    instructions.add(iter, newJump);
                    instructionCount = instructions.size();

                }

            }
            break;
        }
        case Opcodes.IFNONNULL:
        case Opcodes.IFNULL:

        case Opcodes.IFLE:
        case Opcodes.IFLT:
        case Opcodes.IFNE:
        case Opcodes.IFGT:
        case Opcodes.IFEQ:
        case Opcodes.IFGE: {
            String rightArg = "0";
            if (currentOpcode == Opcodes.IFNONNULL || currentOpcode == Opcodes.IFNULL) {
                rightArg = "JAVA_NULL";
            }
            if (iter > 0) {
                Instruction leftArg = instructions.get(iter - 1);

                String leftLiteral = null;

                if (leftArg instanceof AssignableExpression) {
                    StringBuilder sb = new StringBuilder();
                    if (((AssignableExpression) leftArg).assignTo(null, sb)) {
                        leftLiteral = sb.toString().trim();
                    }
                } else if (leftArg instanceof CustomInvoke) {
                    CustomInvoke inv = (CustomInvoke) leftArg;
                    StringBuilder sb = new StringBuilder();
                    if (inv.appendExpression(sb)) {
                        leftLiteral = sb.toString().trim();
                    }
                }

                if (leftLiteral != null) {
                    Jump jmp = (Jump) current;
                    instructions.remove(iter - 1);
                    instructions.remove(iter - 1);
                    //instructions.remove(iter-2);
                    iter -= 1;
                    //instructionCount -= 2;
                    StringBuilder sb = new StringBuilder();
                    String operator = null;
                    String opName = null;
                    switch (currentOpcode) {
                    case Opcodes.IFLE:
                        operator = "<=";
                        opName = "IFLE";
                        break;
                    case Opcodes.IFLT:
                        operator = "<";
                        opName = "IFLT";
                        break;
                    case Opcodes.IFNE:
                        operator = "!=";
                        opName = "IFNE";
                        break;
                    case Opcodes.IFGT:
                        operator = ">";
                        opName = "IFGT";
                        break;
                    case Opcodes.IFGE:
                        operator = ">=";
                        opName = "IFGE";
                        break;
                    case Opcodes.IFEQ:
                        operator = "==";
                        opName = "IFEQ";
                        break;
                    case Opcodes.IFNULL:
                        operator = "==";
                        opName = "IFNULL";
                        break;
                    case Opcodes.IFNONNULL:
                        operator = "!=";
                        opName = "IFNONNULL";
                        break;
                    default:
                        throw new RuntimeException(
                                "Invalid operator during optimization of integer comparison");
                    }

                    sb.append("if (").append(leftLiteral).append(operator).append(rightArg).append(") /* ")
                            .append(opName).append(" CustomJump */ ");
                    CustomJump newJump = CustomJump.create(jmp, sb.toString());
                    //jmp.setCustomCompareCode(sb.toString());
                    newJump.setOptimized(true);
                    instructions.add(iter, newJump);
                    instructionCount = instructions.size();

                }

            }
            break;
        }

        case Opcodes.INVOKEVIRTUAL:
        case Opcodes.INVOKESTATIC:
        case Opcodes.INVOKESPECIAL:
        case Opcodes.INVOKEINTERFACE: {
            if (current instanceof Invoke) {
                Invoke inv = (Invoke) current;
                List<ByteCodeMethodArg> invocationArgs = inv.getArgs();
                int numArgs = invocationArgs.size();

                //if (current.getOpcode() != Opcodes.INVOKESTATIC) {
                //    numArgs++;
                //}
                if (iter >= numArgs) {
                    String[] argLiterals = new String[numArgs];
                    StringBuilder devNull = new StringBuilder();
                    for (int i = 0; i < numArgs; i++) {
                        devNull.setLength(0);
                        Instruction instr = instructions.get(iter - numArgs + i);
                        if (instr instanceof AssignableExpression
                                && ((AssignableExpression) instr).assignTo(null, devNull)) {
                            argLiterals[i] = devNull.toString().trim();
                        } else if (instr instanceof CustomInvoke) {
                            CustomInvoke cinv = (CustomInvoke) instr;
                            devNull.setLength(0);
                            if (!"JAVA_OBJECT".equals(cinv.getReturnValue())
                                    && cinv.appendExpression(devNull)) {
                                // We can't add invocations that return objects directly
                                // because they need to be added to the stack for GC
                                argLiterals[i] = devNull.toString().trim();
                            }
                        } else if (instr instanceof ArithmeticExpression) {
                            argLiterals[i] = ((ArithmeticExpression) instr).getExpressionAsString().trim();
                        } else if (instr instanceof VarOp) {
                            VarOp var = (VarOp) instr;
                            switch (instr.getOpcode()) {
                            case Opcodes.ALOAD: {
                                if (!isStatic() && var.getIndex() == 0) {
                                    argLiterals[i] = "__cn1ThisObject";
                                } else {
                                    argLiterals[i] = "locals[" + var.getIndex() + "].data.o";
                                }
                                break;
                            }
                            case Opcodes.ILOAD: {
                                argLiterals[i] = "ilocals_" + var.getIndex() + "_";
                                break;
                            }
                            case Opcodes.ACONST_NULL: {
                                argLiterals[i] = "JAVA_NULL";
                                break;
                            }
                            case Opcodes.DLOAD: {
                                argLiterals[i] = "dlocals_" + var.getIndex() + "_";
                                break;
                            }
                            case Opcodes.FLOAD: {
                                argLiterals[i] = "flocals_" + var.getIndex() + "_";
                                break;
                            }
                            case Opcodes.LLOAD: {
                                argLiterals[i] = "llocals_" + var.getIndex() + "_";
                                break;
                            }
                            case Opcodes.ICONST_0: {
                                argLiterals[i] = "0";
                                break;
                            }
                            case Opcodes.ICONST_1: {
                                argLiterals[i] = "1";
                                break;
                            }
                            case Opcodes.ICONST_2: {
                                argLiterals[i] = "2";
                                break;
                            }
                            case Opcodes.ICONST_3: {
                                argLiterals[i] = "3";
                                break;
                            }
                            case Opcodes.ICONST_4: {
                                argLiterals[i] = "4";
                                break;
                            }
                            case Opcodes.ICONST_5: {
                                argLiterals[i] = "5";
                                break;
                            }
                            case Opcodes.ICONST_M1: {
                                argLiterals[i] = "-1";
                                break;
                            }
                            case Opcodes.LCONST_0: {
                                argLiterals[i] = "(JAVA_LONG)0";
                                break;
                            }
                            case Opcodes.LCONST_1: {
                                argLiterals[i] = "(JAVA_LONG)1";
                                break;
                            }
                            case Opcodes.BIPUSH:
                            case Opcodes.SIPUSH: {
                                argLiterals[i] = String.valueOf(var.getIndex());

                                break;
                            }
                            }
                        } else {
                            switch (instr.getOpcode()) {

                            case Opcodes.ACONST_NULL: {
                                argLiterals[i] = "JAVA_NULL";
                                break;
                            }

                            case Opcodes.ICONST_0: {
                                argLiterals[i] = "0";
                                break;
                            }
                            case Opcodes.ICONST_1: {
                                argLiterals[i] = "1";
                                break;
                            }
                            case Opcodes.ICONST_2: {
                                argLiterals[i] = "2";
                                break;
                            }
                            case Opcodes.ICONST_3: {
                                argLiterals[i] = "3";
                                break;
                            }
                            case Opcodes.ICONST_4: {
                                argLiterals[i] = "4";
                                break;
                            }
                            case Opcodes.ICONST_5: {
                                argLiterals[i] = "5";
                                break;
                            }
                            case Opcodes.ICONST_M1: {
                                argLiterals[i] = "-1";
                                break;
                            }
                            case Opcodes.LCONST_0: {
                                argLiterals[i] = "(JAVA_LONG)0";
                                break;
                            }
                            case Opcodes.LCONST_1: {
                                argLiterals[i] = "(JAVA_LONG)1";
                                break;
                            }
                            case Opcodes.BIPUSH: {
                                if (instr instanceof BasicInstruction) {
                                    argLiterals[i] = String.valueOf(((BasicInstruction) instr).getValue());
                                }
                                break;
                            }
                            case Opcodes.LDC: {
                                if (instr instanceof Ldc) {
                                    Ldc ldc = (Ldc) instr;
                                    argLiterals[i] = ldc.getValueAsString();

                                }
                                break;
                            }

                            }

                        }
                    }

                    // Check to make sure that we have all the args as literals.
                    boolean missingLiteral = false;
                    for (String lit : argLiterals) {
                        if (lit == null) {
                            missingLiteral = true;
                            break;
                        }
                    }

                    // We have all of the arguments as literals.  Let's
                    // add them to our invoke instruction.
                    if (!missingLiteral) {
                        CustomInvoke newInvoke = CustomInvoke.create(inv);
                        instructions.remove(iter);
                        instructions.add(iter, newInvoke);
                        int newIter = iter;
                        for (int i = 0; i < numArgs; i++) {
                            instructions.remove(iter - numArgs);
                            newIter--;
                            newInvoke.setLiteralArg(i, argLiterals[i]);
                        }
                        if (inv.getOpcode() != Opcodes.INVOKESTATIC) {
                            Instruction ldTarget = instructions.get(iter - numArgs - 1);
                            if (ldTarget instanceof AssignableExpression) {
                                StringBuilder targetExprStr = new StringBuilder();
                                if (((AssignableExpression) ldTarget).assignTo(null, targetExprStr)) {
                                    newInvoke.setTargetObjectLiteral(targetExprStr.toString().trim());
                                    instructions.remove(iter - numArgs - 1);
                                    newIter--;

                                }

                            } else if (ldTarget instanceof CustomInvoke) {
                                // WE Can't pass a custom invoke as the target directly
                                // because it the return value needs to be added to the 
                                // stack for the GC
                            } else {
                                switch (ldTarget.getOpcode()) {
                                case Opcodes.ALOAD: {
                                    VarOp v = (VarOp) ldTarget;
                                    if (isStatic() && v.getIndex() == 0) {
                                        newInvoke.setTargetObjectLiteral("__cn1ThisObject");
                                    } else {
                                        newInvoke.setTargetObjectLiteral("locals[" + v.getIndex() + "].data.o");
                                    }
                                    instructions.remove(iter - numArgs - 1);
                                    newIter--;
                                    break;
                                }
                                }
                            }
                        }

                        newInvoke.setOptimized(true);
                        //iter = 0;
                        instructionCount = instructions.size();
                        iter = newIter;

                    }
                }
            }
            break;
        }

        }
        astoreCalls = astoreCalls || currentOpcode == Opcodes.ASTORE || currentOpcode == Opcodes.ISTORE
                || currentOpcode == Opcodes.LSTORE || currentOpcode == Opcodes.DSTORE
                || currentOpcode == Opcodes.FSTORE;

        hasInstructions = hasInstructions | current.getOpcode() != -1;
    }
    return hasInstructions;
}

---

From source file:com.codename1.tools.translator.bytecodes.ArithmeticExpression.java

public static boolean isArg(Instruction instr) {
    if (instr instanceof ArithmeticExpression) {
        return true;
    }/* w  w  w  . j a v a2s  .  c o m*/
    if (instr instanceof AssignableExpression) {
        StringBuilder dummy = new StringBuilder();

        if (((AssignableExpression) instr).assignTo(null, dummy)) {
            return true;
        }
    }
    int opcode = instr.getOpcode();
    switch (opcode) {

    case Opcodes.FLOAD:
    case Opcodes.DLOAD:
    case Opcodes.ILOAD:
    case Opcodes.LLOAD:
    case org.objectweb.asm.Opcodes.ICONST_0:
    case org.objectweb.asm.Opcodes.ICONST_1:
    case org.objectweb.asm.Opcodes.ICONST_2:
    case org.objectweb.asm.Opcodes.ICONST_3:
    case org.objectweb.asm.Opcodes.ICONST_4:
    case org.objectweb.asm.Opcodes.ICONST_5:
    case org.objectweb.asm.Opcodes.ICONST_M1:
    case org.objectweb.asm.Opcodes.LCONST_0:
    case org.objectweb.asm.Opcodes.LCONST_1:
    case Opcodes.DCONST_0:
    case Opcodes.DCONST_1:
    case Opcodes.FCONST_0:
    case Opcodes.FCONST_1:
    case Opcodes.FCONST_2:
    case org.objectweb.asm.Opcodes.BIPUSH:
    case org.objectweb.asm.Opcodes.SIPUSH:
    case Opcodes.LDC:
        return true;
    }
    return false;
}

---

From source file:com.codename1.tools.translator.bytecodes.ArithmeticExpression.java

public String getExpressionAsString() {

    Instruction instr = lastInstruction;
    int opcode = lastInstruction.getOpcode();
    if (subExpression == null) {
        // This is the root of it... probably an FLOAD
        if (lastInstruction instanceof AssignableExpression
                && !(lastInstruction instanceof ArithmeticExpression)) {
            StringBuilder out = new StringBuilder();
            if (((AssignableExpression) lastInstruction).assignTo(null, out)) {
                String strOut = out.toString();
                if (strOut.trim().isEmpty()) {
                    throw new RuntimeException("Instruction produces blank string output: " + lastInstruction);
                }/* w w  w .java2 s  .  co  m*/
                if (strOut == null || "null".equals(strOut)) {
                    throw new RuntimeException(
                            "ArithmeticExpression produced null value.  This shouldn't happen: "
                                    + lastInstruction);
                }
                return strOut;
            }
        }

        if (lastInstruction instanceof VarOp) {
            VarOp var = (VarOp) lastInstruction;
            switch (opcode) {
            case Opcodes.FLOAD: {
                return "flocals_" + var.getIndex() + "_";

            }
            case Opcodes.DLOAD: {
                return "dlocals_" + var.getIndex() + "_";
            }

            case Opcodes.ILOAD: {
                return "ilocals_" + var.getIndex() + "_";
            }

            case Opcodes.LLOAD: {
                return "llocals_" + var.getIndex() + "_";
            }

            case org.objectweb.asm.Opcodes.ICONST_0: {
                return "0";

            }
            case org.objectweb.asm.Opcodes.ICONST_1: {
                return "1";

            }
            case org.objectweb.asm.Opcodes.ICONST_2: {
                return "2";

            }
            case org.objectweb.asm.Opcodes.ICONST_3: {
                return "3";

            }
            case org.objectweb.asm.Opcodes.ICONST_4: {
                return "4";

            }
            case org.objectweb.asm.Opcodes.ICONST_5: {
                return "5";

            }
            case org.objectweb.asm.Opcodes.ICONST_M1: {
                return "(-1)";

            }
            case org.objectweb.asm.Opcodes.LCONST_0: {
                return "((JAVA_LONG)0)";

            }
            case Opcodes.DCONST_0: {
                return "((JAVA_DOUBLE)0)";
            }
            case Opcodes.DCONST_1: {
                return "((JAVA_DOUBLE)1)";
            }
            case Opcodes.FCONST_0: {
                return "((JAVA_FLOAT)0)";
            }
            case Opcodes.FCONST_1: {
                return "((JAVA_FLOAT)1)";
            }
            case Opcodes.FCONST_2: {
                return "((JAVA_FLOAT)2";
            }

            case org.objectweb.asm.Opcodes.LCONST_1: {
                return "((JAVA_LONG)1)";

            }
            case org.objectweb.asm.Opcodes.BIPUSH:
            case org.objectweb.asm.Opcodes.SIPUSH: {
                return String.valueOf(var.getIndex());
            }
            default: {
                throw new RuntimeException("Unsupported Opcode in ArithmeticExpression: " + opcode + " " + var);
            }
            }
        } else {
            switch (instr.getOpcode()) {

            case org.objectweb.asm.Opcodes.ICONST_0: {
                return "0";

            }
            case org.objectweb.asm.Opcodes.ICONST_1: {
                return "1";

            }
            case org.objectweb.asm.Opcodes.ICONST_2: {
                return "2";

            }
            case org.objectweb.asm.Opcodes.ICONST_3: {
                return "3";

            }
            case org.objectweb.asm.Opcodes.ICONST_4: {
                return "4";

            }
            case org.objectweb.asm.Opcodes.ICONST_5: {
                return "5";

            }
            case org.objectweb.asm.Opcodes.ICONST_M1: {
                return "(-1)";

            }
            case org.objectweb.asm.Opcodes.LCONST_0: {
                return "((JAVA_LONG)0)";

            }
            case org.objectweb.asm.Opcodes.LCONST_1: {
                return "(JAVA_LONG)1";

            }
            case org.objectweb.asm.Opcodes.BIPUSH: {
                if (instr instanceof BasicInstruction) {
                    return String.valueOf(((BasicInstruction) instr).getValue());
                }
                break;
            }
            case org.objectweb.asm.Opcodes.LDC: {
                if (instr instanceof Ldc) {
                    Ldc ldc = (Ldc) instr;
                    return ldc.getValueAsString();

                }
                break;
            }
            default: {
                throw new RuntimeException(
                        "Unsupported Opcode in ArithmeticExpression: " + opcode + " " + instr);
            }

            }
        }

    } else {

        switch (opcode) {

        case Opcodes.ISHL: {
            return "BC_ISHL_EXPR(" + subExpression.getExpressionAsString().trim() + ", "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }
        case Opcodes.ISHR: {
            return "BC_ISHR_EXPR(" + subExpression.getExpressionAsString().trim() + ", "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }
        case Opcodes.LSHL: {
            return "BC_LSHL_EXPR(" + subExpression.getExpressionAsString().trim() + ", "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }
        case Opcodes.LSHR: {
            return "BC_LSHR_EXPR(" + subExpression.getExpressionAsString().trim() + ", "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }
        case Opcodes.IUSHR: {
            return "BC_IUSHR_EXPR(" + subExpression.getExpressionAsString().trim() + ", "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }
        case Opcodes.LUSHR: {
            return "BC_LUSHR_EXPR(" + subExpression.getExpressionAsString().trim() + ", "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }

        case Opcodes.DCMPG:
        case Opcodes.DCMPL:
        case Opcodes.FCMPG:
        case Opcodes.FCMPL:
        case Opcodes.LCMP: {
            return "CN1_CMP_EXPR(" + subExpression.getExpressionAsString().trim() + ", "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }
        case Opcodes.D2F: {
            return "((JAVA_FLOAT)" + subExpression.getExpressionAsString().trim() + ")";
        }
        case Opcodes.F2D: {
            return subExpression.getExpressionAsString().trim();
        }
        case Opcodes.F2I: {
            return "((JAVA_INT)" + subExpression.getExpressionAsString().trim() + ")";
        }
        case Opcodes.F2L: {
            return "((JAVA_LONG)" + subExpression.getExpressionAsString().trim() + ")";
        }
        case Opcodes.D2I: {
            return "((JAVA_INT)" + subExpression.getExpressionAsString().trim() + ")";
        }
        case Opcodes.D2L: {
            return "((JAVA_LONG)" + subExpression.getExpressionAsString().trim() + ")";
        }
        case Opcodes.I2B: {
            return "((" + subExpression.getExpressionAsString() + " << 24) >> 24)";
        }
        case Opcodes.I2C: {
            return "(" + subExpression.getExpressionAsString().trim() + " & 0xffff)";
        }
        case Opcodes.I2D: {
            return "((JAVA_DOUBLE)" + subExpression.getExpressionAsString().trim() + ")";
        }
        case Opcodes.I2F: {
            return "((JAVA_FLOAT)" + subExpression.getExpressionAsString().trim() + ")";
        }
        case Opcodes.I2L: {
            return "((JAVA_LONG)" + subExpression.getExpressionAsString().trim() + ")";
        }
        case Opcodes.I2S: {
            return "((" + subExpression.getExpressionAsString().trim() + " << 16) >> 16)";
        }
        case Opcodes.L2D: {
            return "((JAVA_DOUBLE)" + subExpression.getExpressionAsString().trim() + ")";
        }
        case Opcodes.L2F: {
            return "((JAVA_FLOAT)" + subExpression.getExpressionAsString().trim() + ")";
        }
        case Opcodes.L2I: {
            return "((JAVA_INT)" + subExpression.getExpressionAsString().trim() + ")";
        }
        case Opcodes.IAND:
        case Opcodes.LAND: {
            return "(" + subExpression.getExpressionAsString().trim() + " & "
                    + subExpression2.getExpressionAsString().trim() + ")";

        }
        case Opcodes.IOR:
        case Opcodes.LOR: {
            return "(" + subExpression.getExpressionAsString().trim() + " | "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }
        case Opcodes.IXOR:
        case Opcodes.LXOR: {
            return "(" + subExpression.getExpressionAsString().trim() + " ^ "
                    + subExpression2.getExpressionAsString().trim() + ")";

        }
        case Opcodes.DADD:
        case Opcodes.IADD:
        case Opcodes.LADD:
        case Opcodes.FADD: {
            return "(" + subExpression.getExpressionAsString().trim() + " + "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }

        case Opcodes.DSUB:
        case Opcodes.ISUB:
        case Opcodes.LSUB:
        case Opcodes.FSUB: {
            return "(" + subExpression.getExpressionAsString().trim() + " - "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }

        case Opcodes.DMUL:
        case Opcodes.IMUL:
        case Opcodes.LMUL:
        case Opcodes.FMUL: {
            return "(" + subExpression.getExpressionAsString().trim() + " * "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }

        case Opcodes.DDIV:
        case Opcodes.IDIV:
        case Opcodes.LDIV:
        case Opcodes.FDIV: {
            return "(" + subExpression.getExpressionAsString().trim() + " / "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }

        case Opcodes.FREM:
        case Opcodes.DREM: {
            return "fmod(" + subExpression.getExpressionAsString().trim() + ", "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }

        case Opcodes.LREM:
        case Opcodes.IREM: {
            if (subExpression2.getExpressionAsString() == null
                    || "null".equals(subExpression2.getExpressionAsString())) {
                throw new RuntimeException("2nd param of REM is null.  Should never happen.  Expression is "
                        + subExpression2 + " with last instruction " + subExpression2.lastInstruction);
            }
            return "(" + subExpression.getExpressionAsString().trim() + " % "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }

        case Opcodes.FNEG:
        case Opcodes.INEG:
        case Opcodes.LNEG:
        case Opcodes.DNEG:
            return "(-(" + subExpression.getExpressionAsString().trim() + "))";

        default: {
            throw new RuntimeException("Unsupported Opcode in ArithmeticExpression: " + opcode + " " + instr);
        }

        }
    }
    throw new RuntimeException("Did not return a value in getExpressionAsString() with lastInstruction "
            + lastInstruction + " subExpression " + subExpression + " and subExpression2 " + subExpression2);
}

---

From source file:com.codename1.tools.translator.bytecodes.BasicInstruction.java

License:Open Source License

@Override
public void appendInstruction(StringBuilder b, List<Instruction> instructions) {
    switch (opcode) {
    case Opcodes.NOP:
        break;/*from  w  w  w.  j  a v  a 2  s  .  c  o m*/

    case Opcodes.ACONST_NULL:
        b.append("    PUSH_POINTER(JAVA_NULL); /* ACONST_NULL */\n");
        break;

    case Opcodes.ICONST_M1:
        b.append("    PUSH_INT(-1); /* ICONST_M1 */\n");
        break;

    case Opcodes.ICONST_0:
        b.append("    PUSH_INT(0); /* ICONST_0 */\n");
        break;

    case Opcodes.ICONST_1:
        b.append("    PUSH_INT(1); /* ICONST_1 */\n");
        break;

    case Opcodes.ICONST_2:
        b.append("    PUSH_INT(2); /* ICONST_2 */\n");
        break;

    case Opcodes.ICONST_3:
        b.append("    PUSH_INT(3); /* ICONST_3 */\n");
        break;

    case Opcodes.ICONST_4:
        b.append("    PUSH_INT(4); /* ICONST_4 */\n");
        break;

    case Opcodes.ICONST_5:
        b.append("    PUSH_INT(5); /* ICONST_5 */\n");
        break;

    case Opcodes.LCONST_0:
        b.append("    PUSH_LONG(0); /* LCONST_0 */\n");
        break;

    case Opcodes.LCONST_1:
        b.append("    PUSH_LONG(1); /* LCONST_1 */\n");
        break;

    case Opcodes.FCONST_0:
        b.append("    PUSH_FLOAT(0); /* FCONST_0 */\n");
        break;

    case Opcodes.FCONST_1:
        b.append("    PUSH_FLOAT(1); /* FCONST_1 */\n");
        break;

    case Opcodes.FCONST_2:
        b.append("    PUSH_FLOAT(2); /* FCONST_2 */\n");
        break;

    case Opcodes.DCONST_0:
        b.append("    PUSH_DOUBLE(0); /* DCONST_0 */\n");
        break;

    case Opcodes.DCONST_1:
        b.append("    PUSH_DOUBLE(1); /* DCONST_1 */\n");
        break;

    case Opcodes.BALOAD:
        b.append("    { CHECK_ARRAY_ACCESS(2, SP[-1].data.i); /* BALOAD */ \n"
                + "    SP--; SP[-1].type = CN1_TYPE_INT; \n"
                + "    SP[-1].data.i = ((JAVA_ARRAY_BYTE*) (*(JAVA_ARRAY)SP[-1].data.o).data)[(*SP).data.i]; \n"
                + "    }\n");
        break;

    case Opcodes.CALOAD:
        b.append("    CHECK_ARRAY_ACCESS(2, SP[-1].data.i); /* CALOAD */\n"
                + "    SP--; SP[-1].type = CN1_TYPE_INT; \n"
                + "    SP[-1].data.i = ((JAVA_ARRAY_CHAR*) (*(JAVA_ARRAY)SP[-1].data.o).data)[(*SP).data.i];\n");
        break;

    case Opcodes.IALOAD:
        b.append("    CHECK_ARRAY_ACCESS(2, SP[-1].data.i); /* IALOAD */\n"
                + "    SP--; SP[-1].type = CN1_TYPE_INT; \n"
                + "    SP[-1].data.i = ((JAVA_ARRAY_INT*) (*(JAVA_ARRAY)SP[-1].data.o).data)[(*SP).data.i];\n");
        break;

    case Opcodes.SALOAD:
        b.append("    CHECK_ARRAY_ACCESS(2, SP[-1].data.i); \n" + "    SP--; SP[-1].type = CN1_TYPE_INT; \n"
                + "    SP[-1].data.i = ((JAVA_ARRAY_SHORT*) (*(JAVA_ARRAY)SP[-1].data.o).data)[(*SP).data.i]; /* SALOAD */\n");
        break;

    case Opcodes.LALOAD:
        b.append("    CHECK_ARRAY_ACCESS(2, SP[-1].data.i); /* LALOAD */\n"
                + "    SP--; SP[-1].type = CN1_TYPE_LONG; \n"
                + "    SP[-1].data.l = LONG_ARRAY_LOOKUP((JAVA_ARRAY)SP[-1].data.o, (*SP).data.i);\n");
        break;

    case Opcodes.FALOAD:
        b.append("    CHECK_ARRAY_ACCESS(2, SP[-1].data.i); /* FALOAD */\n"
                + "    SP--; SP[-1].type = CN1_TYPE_FLOAT; \n"
                + "    SP[-1].data.f = FLOAT_ARRAY_LOOKUP((JAVA_ARRAY)SP[-1].data.o, (*SP).data.i);\n");
        break;

    case Opcodes.DALOAD:
        b.append("    CHECK_ARRAY_ACCESS(2, SP[-1].data.i); /* DALOAD */\n"
                + "    SP--; SP[-1].type = CN1_TYPE_DOUBLE; \n"
                + "    SP[-1].data.d = DOUBLE_ARRAY_LOOKUP((JAVA_ARRAY)SP[-1].data.o, (*SP).data.i);\n");
        break;

    case Opcodes.AALOAD:
        b.append("    CHECK_ARRAY_ACCESS(2, SP[-1].data.i); /* AALOAD */\n"
                + "    SP--; SP[-1].type = CN1_TYPE_INVALID; \n"
                + "    SP[-1].data.o = ((JAVA_ARRAY_OBJECT*) (*(JAVA_ARRAY)SP[-1].data.o).data)[(*SP).data.i]; \n"
                + "    SP[-1].type = CN1_TYPE_OBJECT; \n");
        break;

    case Opcodes.BASTORE:
        b.append("    CHECK_ARRAY_ACCESS(3, SP[-2].data.i); /* BASTORE */\n"
                + "    ((JAVA_ARRAY_BYTE*) (*(JAVA_ARRAY)SP[-3].data.o).data)[SP[-2].data.i] = SP[-1].data.i; SP -= 3;\n");
        break;

    case Opcodes.CASTORE:
        b.append("    CHECK_ARRAY_ACCESS(3, SP[-2].data.i); /* CASTORE */\n"
                + "    ((JAVA_ARRAY_CHAR*) (*(JAVA_ARRAY)SP[-3].data.o).data)[SP[-2].data.i] = SP[-1].data.i; SP -= 3;\n\n");
        break;

    case Opcodes.SASTORE:
        b.append("    CHECK_ARRAY_ACCESS(3, SP[-2].data.i); /* SASTORE */\n"
                + "    ((JAVA_ARRAY_SHORT*) (*(JAVA_ARRAY)SP[-3].data.o).data)[SP[-2].data.i] = SP[-1].data.i; SP -= 3;\n");
        break;

    case Opcodes.IASTORE:
        b.append("    CHECK_ARRAY_ACCESS(3, SP[-2].data.i); /* IASTORE */\n"
                + "    ((JAVA_ARRAY_INT*) (*(JAVA_ARRAY)SP[-3].data.o).data)[SP[-2].data.i] = SP[-1].data.i; SP -= 3;\n");
        break;

    case Opcodes.LASTORE:
        b.append("    CHECK_ARRAY_ACCESS(3, SP[-2].data.i); /* LASTORE */\n"
                + "    LONG_ARRAY_LOOKUP((JAVA_ARRAY)SP[-3].data.o, SP[-2].data.i) = SP[-1].data.l; SP -= 3;\n");
        break;

    case Opcodes.FASTORE:
        b.append("    CHECK_ARRAY_ACCESS(3, SP[-2].data.i); /* FASTORE */\n"
                + "    FLOAT_ARRAY_LOOKUP((JAVA_ARRAY)SP[-3].data.o, SP[-2].data.i) = SP[-1].data.f; SP -= 3;\n");
        break;

    case Opcodes.DASTORE:
        b.append("    CHECK_ARRAY_ACCESS(3, SP[-2].data.i); /* DASTORE */\n"
                + "    DOUBLE_ARRAY_LOOKUP((JAVA_ARRAY)SP[-3].data.o, SP[-2].data.i) = SP[-1].data.d; SP -= 3;\n");
        break;

    case Opcodes.AASTORE:
        b.append("    CHECK_ARRAY_ACCESS(3, SP[-2].data.i); { /* BC_AASTORE */\n"
                + "    JAVA_OBJECT aastoreTmp = SP[-3].data.o; \n"
                + "    ((JAVA_ARRAY_OBJECT*) (*(JAVA_ARRAY)aastoreTmp).data)[SP[-2].data.i] = SP[-1].data.o; \n"
                + "    SP -= 3; }\n");
        break;

    case Opcodes.POP:
        b.append("    SP--; /* POP */\n");
        break;

    case Opcodes.POP2:
        b.append("    popMany(threadStateData, 2, &SP); /* POP2 */\n");
        break;

    /*case Opcodes.DUP:
        b.append("    PUSH_INT(PEEK_INT(1));\n");
        break;
            
    case Opcodes.DUP_X1:
        b.append("    DUP_X1();\n");
        break;
                
    case Opcodes.DUP_X2:
        b.append("    DUP_X2();\n");
        break;*/

    case Opcodes.DUP:
        b.append("    BC_DUP(); /* DUP */\n");
        break;

    case Opcodes.DUP2:
        b.append("    BC_DUP2(); /* DUP2 */\n");
        break;

    case Opcodes.DUP_X1:
        b.append("    BC_DUP2_X1(); /* DUP_X1 */\n");
        break;

    case Opcodes.DUP2_X1:
        b.append("    BC_DUP2_X1(); /* DUP2_X1 */\n");
        break;

    case Opcodes.DUP_X2:
        b.append("    BC_DUP2_X2(); /* DUP_X2 */\n");
        break;

    case Opcodes.DUP2_X2:
        b.append("    BC_DUP2_X2(); /* DUP2_X2 */\n");
        break;

    case Opcodes.SWAP:
        b.append("    swapStack(SP); /* SWAP */\n");
        break;

    case Opcodes.IADD:
        b.append("    SP--; SP[-1].data.i = SP[-1].data.i + (*SP).data.i; /* IADD */\n");
        break;

    case Opcodes.LADD:
        b.append("    SP--; SP[-1].data.l = SP[-1].data.l + (*SP).data.l; /* LADD */\n");
        break;

    case Opcodes.FADD:
        b.append("    SP--; SP[-1].data.f = SP[-1].data.f + (*SP).data.f; /* FADD */\n");
        break;

    case Opcodes.DADD:
        b.append("    SP--; SP[-1].data.d = SP[-1].data.d + (*SP).data.d; /* DADD */\n");
        break;

    case Opcodes.ISUB:
        b.append("    SP--; SP[-1].data.i = (SP[-1].data.i - (*SP).data.i); /* ISUB */\n");
        break;

    case Opcodes.LSUB:
        b.append("    SP--; SP[-1].data.l = (SP[-1].data.l - (*SP).data.l); /* LSUB */\n");
        break;

    case Opcodes.FSUB:
        b.append("    SP--; SP[-1].data.f = (SP[-1].data.f - (*SP).data.f); /* FSUB */\n");
        break;

    case Opcodes.DSUB:
        b.append("    SP--; SP[-1].data.d = (SP[-1].data.d - (*SP).data.d); /* DSUB */\n");
        break;

    case Opcodes.IMUL:
        b.append("    SP--; SP[-1].data.i = SP[-1].data.i * (*SP).data.i; /* IMUL */\n");
        break;

    case Opcodes.LMUL:
        b.append("    SP--; SP[-1].data.l = SP[-1].data.l * (*SP).data.l; /* LMUL */\n");
        break;

    case Opcodes.FMUL:
        b.append("    SP--; SP[-1].data.f = SP[-1].data.f * (*SP).data.f; /* FMUL */\n");
        break;

    case Opcodes.DMUL:
        b.append("    SP--; SP[-1].data.d = SP[-1].data.d * (*SP).data.d; /* DMUL */\n");
        break;

    case Opcodes.IDIV:
        b.append("    SP--; SP[-1].data.i = SP[-1].data.i / (*SP).data.i; /* IDIV */\n");
        break;

    case Opcodes.LDIV:
        b.append("    SP--; SP[-1].data.l = SP[-1].data.l / (*SP).data.l; /* LDIV */\n");
        break;

    case Opcodes.FDIV:
        b.append("    SP--; SP[-1].data.f = SP[-1].data.f / (*SP).data.f; /* FDIV */\n");
        break;

    case Opcodes.DDIV:
        b.append("    SP--; SP[-1].data.d = SP[-1].data.d / (*SP).data.d; /* DDIV */\n");
        break;

    case Opcodes.IREM:
        b.append("    SP--; SP[-1].data.i = SP[-1].data.i % (*SP).data.i; /* IREM */\n");
        break;

    case Opcodes.LREM:
        b.append("    SP--; SP[-1].data.l = SP[-1].data.l % (*SP).data.l; /* LREM */\n");
        break;

    case Opcodes.FREM:
        b.append("    SP--; SP[-1].data.f = fmod(SP[-1].data.f, (*SP).data.f); /* FREM */\n");
        break;

    case Opcodes.DREM:
        b.append("    SP--; SP[-1].data.d = fmod(SP[-1].data.d, (*SP).data.d); /* DREM */\n");
        break;

    case Opcodes.INEG:
        b.append("    SP[-1].data.i *= -1; /* INEG */\n");
        break;

    case Opcodes.LNEG:
        b.append("    SP[-1].data.l *= -1; /* LNEG */\n");
        break;

    case Opcodes.FNEG:
        b.append("    SP[-1].data.f *= -1; /* FNEG */\n");
        break;

    case Opcodes.DNEG:
        b.append("    SP[-1].data.d *= -1; /* DNEG */\n");
        break;

    case Opcodes.ISHL:
        b.append("    SP--; SP[-1].data.i = (SP[-1].data.i << (0x1f & (*SP).data.i)); /* ISHL */\n");
        break;

    case Opcodes.LSHL:
        b.append("    SP--; SP[-1].data.l = (SP[-1].data.l << (0x3f & (*SP).data.i)); /* LSHL */\n");
        break;

    case Opcodes.ISHR:
        b.append("    SP--; SP[-1].data.i = (SP[-1].data.i >> (0x1f & (*SP).data.i)); /* ISHR */\n");
        break;

    case Opcodes.LSHR:
        b.append("    SP--; SP[-1].data.l = (SP[-1].data.l >> (0x3f & (*SP).data.l)); /* LSHR */\n");
        break;

    case Opcodes.IUSHR:
        b.append(
                "    SP--; SP[-1].data.i = (((unsigned int)SP[-1].data.i) >> (0x1f & ((unsigned int)(*SP).data.i))); /* IUSHR */\n");
        break;

    case Opcodes.LUSHR:
        b.append(
                "    SP--; SP[-1].data.l = (((unsigned long long)SP[-1].data.l) >> (0x3f & ((unsigned long long)(*SP).data.i))); /* LUSHR */\n");
        break;

    case Opcodes.IAND:
        b.append("    SP--; SP[-1].data.i = SP[-1].data.i & (*SP).data.i; /* IAND */\n");
        break;

    case Opcodes.LAND:
        b.append("    SP--; SP[-1].data.l = SP[-1].data.l & (*SP).data.l; /* LAND */\n");
        break;

    case Opcodes.IOR:
        b.append("    SP--; SP[-1].data.i = SP[-1].data.i | (*SP).data.i; /* IOR */\n");
        break;

    case Opcodes.LOR:
        b.append("    SP--; SP[-1].data.l = SP[-1].data.l | (*SP).data.l; /* LOR */\n");
        break;

    case Opcodes.IXOR:
        b.append("    SP--; SP[-1].data.i = SP[-1].data.i ^ (*SP).data.i; /* IXOR */\n");
        break;

    case Opcodes.LXOR:
        b.append("    SP--; SP[-1].data.l = SP[-1].data.l ^ (*SP).data.l; /* LXOR */\n");
        break;

    case Opcodes.I2L:
        b.append("    SP[-1].data.l = SP[-1].data.i; /* I2L */\n");
        break;

    case Opcodes.I2F:
        b.append("    SP[-1].data.f = (JAVA_FLOAT)SP[-1].data.i; /* I2F */\n");
        break;

    case Opcodes.I2D:
        b.append("    SP[-1].data.d = SP[-1].data.i; /* I2D */;\n");
        break;

    case Opcodes.L2I:
        b.append("    SP[-1].data.i = (JAVA_INT)SP[-1].data.l; /* L2I */\n");
        break;

    case Opcodes.L2F:
        b.append("    SP[-1].data.f = (JAVA_FLOAT)SP[-1].data.l; /* L2F */\n");
        break;

    case Opcodes.L2D:
        b.append("    SP[-1].data.d = (JAVA_DOUBLE)SP[-1].data.l; /* L2D */\n");
        break;

    case Opcodes.F2I:
        b.append("    SP[-1].data.i = (JAVA_INT)SP[-1].data.f; /* F2I */\n");
        break;

    case Opcodes.F2L:
        b.append("    SP[-1].data.l = (JAVA_LONG)SP[-1].data.f; /* F2L */\n");
        break;

    case Opcodes.F2D:
        b.append("    SP[-1].data.d = SP[-1].data.f; /* F2D */\n");
        break;

    case Opcodes.D2I:
        b.append("    SP[-1].data.i = (JAVA_INT)SP[-1].data.d; /* D2I */\n");
        break;

    case Opcodes.D2L:
        b.append("    SP[-1].data.l = (JAVA_LONG)SP[-1].data.d; /* D2L */\n");
        break;

    case Opcodes.D2F:
        b.append("    SP[-1].data.f = (JAVA_FLOAT)SP[-1].data.d; /* D2F */\n");
        break;

    case Opcodes.I2B:
        b.append("    SP[-1].data.i = ((SP[-1].data.i << 24) >> 24); /* I2B */\n");
        break;

    case Opcodes.I2C:
        b.append("    SP[-1].data.i = (SP[-1].data.i & 0xffff); /* I2C */\n");
        break;

    case Opcodes.I2S:
        b.append("    SP[-1].data.i = ((SP[-1].data.i << 16) >> 16); /* I2S */\n");
        break;

    case Opcodes.LCMP:
        b.append("    BC_LCMP();\n");
        break;

    case Opcodes.FCMPG:
    case Opcodes.FCMPL:
        b.append("    BC_FCMPL();\n");
        break;

    case Opcodes.DCMPL:
    case Opcodes.DCMPG:
        b.append("    BC_DCMPL();\n");
        break;

    case Opcodes.IRETURN:
        appendSynchronized(b);

        if (TryCatch.isTryCatchInMethod()) {
            b.append(
                    "    releaseForReturnInException(threadStateData, cn1LocalsBeginInThread, methodBlockOffset); return SP[-1].data.i;\n");
            //                    b.append(maxLocals);
            //                    b.append(", stack, locals, methodBlockOffset); \n    return SP[-1].data.i;\n");
        } else {
            b.append("    releaseForReturn(threadStateData, cn1LocalsBeginInThread); return SP[-1].data.i;\n");
            //                    b.append(maxLocals);
            //                    b.append(", stack, locals); \n    return SP[-1].data.i;\n");
        }
        break;

    case Opcodes.LRETURN:
        appendSynchronized(b);

        if (TryCatch.isTryCatchInMethod()) {
            b.append(
                    "    releaseForReturnInException(threadStateData, cn1LocalsBeginInThread, methodBlockOffset); \n    return POP_LONG();\n");
        } else {
            b.append(
                    "    releaseForReturn(threadStateData, cn1LocalsBeginInThread); \n    return POP_LONG();\n");
        }
        break;

    case Opcodes.FRETURN:
        appendSynchronized(b);

        if (TryCatch.isTryCatchInMethod()) {
            b.append(
                    "    releaseForReturnInException(threadStateData, cn1LocalsBeginInThread, methodBlockOffset); \n    return POP_FLOAT();\n");
        } else {
            b.append(
                    "    releaseForReturn(threadStateData, cn1LocalsBeginInThread); \n    return POP_FLOAT();\n");
        }
        break;

    case Opcodes.DRETURN:
        appendSynchronized(b);

        if (TryCatch.isTryCatchInMethod()) {
            b.append(
                    "    releaseForReturnInException(threadStateData, cn1LocalsBeginInThread, methodBlockOffset); \n    return POP_DOUBLE();\n");
        } else {
            b.append(
                    "    releaseForReturn(threadStateData, cn1LocalsBeginInThread); \n    return POP_DOUBLE();\n");
        }
        break;

    case Opcodes.ARETURN:
        appendSynchronized(b);

        if (TryCatch.isTryCatchInMethod()) {
            b.append(
                    "    releaseForReturnInException(threadStateData, cn1LocalsBeginInThread, methodBlockOffset); \n    return POP_OBJ();\n");
        } else {
            b.append(
                    "    releaseForReturn(threadStateData, cn1LocalsBeginInThread); \n    return POP_OBJ();\n");
        }
        break;

    case Opcodes.RETURN:
        appendSynchronized(b);

        if (!hasInstructions) {
            b.append("    return;\n");
            break;
        }
        if (TryCatch.isTryCatchInMethod()) {
            b.append(
                    "    releaseForReturnInException(threadStateData, cn1LocalsBeginInThread, methodBlockOffset); \n    return;\n");
        } else {
            b.append("    releaseForReturn(threadStateData, cn1LocalsBeginInThread); \n    return;\n");
        }
        break;

    case Opcodes.ARRAYLENGTH:
        b.append("    { /* ARRAYLENGTH */\n" + "        if(SP[-1].data.o == JAVA_NULL) { \n"
                + "            throwException(threadStateData, __NEW_INSTANCE_java_lang_NullPointerException(threadStateData)); \n"
                + "        }; \n" + "        SP[-1].type = CN1_TYPE_INT; \n"
                + "        SP[-1].data.i = (*((JAVA_ARRAY)SP[-1].data.o)).length; \n" + "    }\n");
        break;

    case Opcodes.ATHROW:
        //b.append("    NSLog(@\"Exception thrown %s %d %s %s\\n\", __FILE__, __LINE__, __PRETTY_FUNCTION__, __FUNCTION__);\n");
        b.append("    throwException(threadStateData, POP_OBJ());\n");
        break;

    case Opcodes.MONITORENTER:
        b.append("    monitorEnter(threadStateData, POP_OBJ());\n");
        break;

    case Opcodes.MONITOREXIT:
        b.append("    monitorExit(threadStateData, POP_OBJ());\n");
        break;

    // int instructions
    case Opcodes.SIPUSH:
    case Opcodes.BIPUSH:
        b.append("    PUSH_INT(");
        b.append(value);
        b.append(");\n");
        break;

    case Opcodes.NEWARRAY:
        switch (value) {
        case 4: // boolean
            b.append(
                    "    SP--; PUSH_OBJ(allocArray(threadStateData, (*SP).data.i, &class_array1__JAVA_BOOLEAN, sizeof(JAVA_ARRAY_BOOLEAN), 1));\n");
            break;
        case 5: // char
            b.append(
                    "    SP--; PUSH_OBJ(allocArray(threadStateData, (*SP).data.i, &class_array1__JAVA_CHAR, sizeof(JAVA_ARRAY_CHAR), 1));\n");
            break;
        case 6: // float
            b.append(
                    "    SP--; PUSH_OBJ(allocArray(threadStateData, (*SP).data.i, &class_array1__JAVA_FLOAT, sizeof(JAVA_ARRAY_FLOAT), 1));\n");
            break;
        case 7: // double
            b.append(
                    "    SP--; PUSH_OBJ(allocArray(threadStateData, (*SP).data.i, &class_array1__JAVA_DOUBLE, sizeof(JAVA_ARRAY_DOUBLE), 1));\n");
            break;
        case 8: // byte
            b.append(
                    "    SP--; PUSH_OBJ(allocArray(threadStateData, (*SP).data.i, &class_array1__JAVA_BYTE, sizeof(JAVA_ARRAY_BYTE), 1));\n");
            break;
        case 9: // short
            b.append(
                    "    SP--; PUSH_OBJ(allocArray(threadStateData, (*SP).data.i, &class_array1__JAVA_SHORT, sizeof(JAVA_ARRAY_SHORT), 1));\n");
            break;
        case 10: // int
            b.append(
                    "    SP--; PUSH_OBJ(allocArray(threadStateData, (*SP).data.i, &class_array1__JAVA_INT, sizeof(JAVA_ARRAY_INT), 1));\n");
            break;
        case 11: // long 
            b.append(
                    "    SP--; PUSH_OBJ(allocArray(threadStateData, (*SP).data.i, &class_array1__JAVA_LONG, sizeof(JAVA_ARRAY_LONG), 1));\n");
            break;
        }
        break;
    }
}

---

From source file:com.codename1.tools.translator.bytecodes.BasicInstruction.java

License:Open Source License

@Override
public boolean assignTo(String varName, StringBuilder sb) {
    StringBuilder b = new StringBuilder();
    //StringBuilder b2 = new StringBuilder();
    //if (typeVarName != null) {
    //    b2.append(typeVarName).append(" = ");
    //    //  w w  w .j  a v a  2  s . c om
    //}
    if (varName != null) {
        b.append(varName).append(" = ");
    }
    switch (opcode) {
    case Opcodes.ACONST_NULL:
        b.append("JAVA_NULL /* ACONST_NULL */");
        //b2.append("CN1_TYPE_OBJECT");
        break;

    case Opcodes.ICONST_M1:
        b.append("-1 /* ICONST_M1 */");
        //b2.append("CN1_TYPE_INT");
        break;

    case Opcodes.ICONST_0:
        b.append("0 /* ICONST_0 */");
        //b2.append("CN1_TYPE_INT");
        break;

    case Opcodes.ICONST_1:
        b.append("1 /* ICONST_1 */");
        //b2.append("CN1_TYPE_INT");
        break;

    case Opcodes.ICONST_2:
        b.append("2 /* ICONST_2 */");
        //b2.append("CN1_TYPE_INT");
        break;

    case Opcodes.ICONST_3:
        b.append("3 /* ICONST_3 */");
        //b2.append("CN1_TYPE_INT");
        break;

    case Opcodes.ICONST_4:
        b.append("4/* ICONST_4 */");
        //b2.append("CN1_TYPE_INT");
        break;

    case Opcodes.ICONST_5:
        b.append("5 /* ICONST_5 */");
        ///b2.append("CN1_TYPE_INT");
        break;

    case Opcodes.LCONST_0:
        b.append("0 /* LCONST_0 */");
        //b2.append("CN1_TYPE_LONG");
        break;

    case Opcodes.LCONST_1:
        b.append("1 /* LCONST_1 */");
        //b2.append("CN1_TYPE_LONG");
        break;

    case Opcodes.FCONST_0:
        b.append("0 /* FCONST_0 */");
        //b2.append("CN1_TYPE_FLOAT");
        break;

    case Opcodes.FCONST_1:
        b.append("1 /* FCONST_1 */");
        //b2.append("CN1_TYPE_FLOAT");
        break;

    case Opcodes.FCONST_2:
        b.append("2 /* FCONST_2 */");
        //b2.append("CN1_TYPE_FLOAT");
        break;

    case Opcodes.DCONST_0:
        b.append("0 /* DCONST_0 */");
        //b2.append("CN1_TYPE_DOUBLE");
        break;

    case Opcodes.DCONST_1:
        b.append("1 /* DCONST_1 */");
        //b2.append("CN1_TYPE_DOUBLE");
        break;

    // int instructions
    case Opcodes.SIPUSH:
    case Opcodes.BIPUSH:
        b.append(value);
        b.append("/* SIPUSH */");
        //b2.append("CN1_TYPE_INT");
        break;

    default:
        return false;
    }

    if (varName != null) {
        sb.append("    ");
        b.append("; \n");
    }

    //if (typeVarName != null) {
    //    sb.append(b2).append("; ");
    //}
    sb.append(b);

    return true;
}

---

From source file:com.codename1.tools.translator.bytecodes.VarOp.java

License:Open Source License

@Override
public void appendInstruction(StringBuilder b) {
    b.append("    ");
    switch (opcode) {
    case Opcodes.ILOAD:
        b.append("(*SP).type = CN1_TYPE_INT; /* ILOAD */ \n" + "    (*SP).data.i = ilocals_");
        b.append(var);
        b.append("_; \n    SP++;\n");
        return;//from   w w w.  j a v  a2 s.  co m
    case Opcodes.LLOAD:
        b.append("BC_LLOAD(");
        break;
    case Opcodes.FLOAD:
        b.append("BC_FLOAD(");
        break;
    case Opcodes.DLOAD:
        b.append("BC_DLOAD(");
        break;
    case Opcodes.ALOAD:
        b.append("BC_ALOAD(");
        break;
    case Opcodes.ISTORE:
        b.append("BC_ISTORE(");
        break;
    case Opcodes.LSTORE:
        b.append("BC_LSTORE(");
        break;
    case Opcodes.FSTORE:
        b.append("BC_FSTORE(");
        break;
    case Opcodes.DSTORE:
        b.append("BC_DSTORE(");
        break;
    case Opcodes.ASTORE:
        b.append("BC_ASTORE(");
        break;
    case Opcodes.RET:
        b.append("/* RET TODO */");
        //b.append("goto label_");
        //b.append(var);
        //b.append("; /* RET */\n");
        return;
    case Opcodes.SIPUSH:
    case Opcodes.BIPUSH:
        b.append("PUSH_INT(");
        break;
    case Opcodes.NEWARRAY:
        switch (var) {
        case 4: // boolean
            b.append(
                    "PUSH_OBJ(allocArray(threadStateData, POP_INT(), &class_array1__JAVA_BOOLEAN, sizeof(JAVA_ARRAY_BOOLEAN), 1));\n");
            break;
        case 5: // char
            b.append(
                    "PUSH_OBJ(allocArray(threadStateData, POP_INT(), &class_array1__JAVA_CHAR, sizeof(JAVA_ARRAY_CHAR), 1));\n");
            break;
        case 6: // float
            b.append(
                    "PUSH_OBJ(allocArray(threadStateData, POP_INT(), &class_array1__JAVA_FLOAT, sizeof(JAVA_ARRAY_FLOAT), 1));\n");
            break;
        case 7: // double
            b.append(
                    "PUSH_OBJ(allocArray(threadStateData, POP_INT(), &class_array1__JAVA_DOUBLE, sizeof(JAVA_ARRAY_DOUBLE), 1));\n");
            break;
        case 8: // byte
            b.append(
                    "PUSH_OBJ(allocArray(threadStateData, POP_INT(), &class_array1__JAVA_BYTE, sizeof(JAVA_ARRAY_BYTE), 1));\n");
            break;
        case 9: // short
            b.append(
                    "PUSH_OBJ(allocArray(threadStateData, POP_INT(), &class_array1__JAVA_SHORT, sizeof(JAVA_ARRAY_SHORT), 1));\n");
            break;
        case 10: // int
            b.append(
                    "PUSH_OBJ(allocArray(threadStateData, POP_INT(), &class_array1__JAVA_INT, sizeof(JAVA_ARRAY_INT), 1));\n");
            break;
        case 11: // long 
            b.append(
                    "PUSH_OBJ(allocArray(threadStateData, POP_INT(), &class_array1__JAVA_LONG, sizeof(JAVA_ARRAY_LONG), 1));\n");
            break;
        }
        return;
    default:
        throw new RuntimeException("Missing opcode: " + opcode);
    }
    b.append(var);
    b.append(");\n");
}

---

From source file:com.codename1.tools.translator.Util.java

License:Open Source License

public static char[] getStackInputTypes(Instruction instr) {
    char[] out = instr.getStackInputTypes();
    if (out != null) {
        return out;
    }/* www. j a v  a 2  s.  c om*/

    switch (instr.getOpcode()) {

    case Opcodes.NOP:
    case Opcodes.ACONST_NULL:
    case Opcodes.ICONST_M1:
    case Opcodes.ICONST_0:
    case Opcodes.ICONST_2:
    case Opcodes.ICONST_3:
    case Opcodes.ICONST_4:
    case Opcodes.ICONST_5:
    case Opcodes.LCONST_0:
    case Opcodes.LCONST_1:
    case Opcodes.FCONST_0:
    case Opcodes.FCONST_1:
    case Opcodes.FCONST_2:
    case Opcodes.DCONST_0:
    case Opcodes.DCONST_1:
    case Opcodes.SIPUSH:
    case Opcodes.BIPUSH:
        return new char[0];
    case Opcodes.BALOAD:
    case Opcodes.CALOAD:
    case Opcodes.IALOAD:
    case Opcodes.SALOAD:
    case Opcodes.LALOAD:
    case Opcodes.FALOAD:
    case Opcodes.DALOAD:
    case Opcodes.AALOAD:
        return new char[] { 'i', 'o' };

    case Opcodes.BASTORE:
    case Opcodes.CASTORE:
    case Opcodes.SASTORE:
    case Opcodes.IASTORE:
        return new char[] { 'i', 'i', 'o' };
    case Opcodes.LASTORE:
        return new char[] { 'l', 'i', 'o' };
    case Opcodes.FASTORE:
        return new char[] { 'f', 'i', 'o' };
    case Opcodes.DASTORE:
        return new char[] { 'd', 'i', 'o' };
    case Opcodes.AASTORE:
        return new char[] { 'o', 'i', 'o' };

    case Opcodes.POP:
        return new char[] { '*' };

    case Opcodes.POP2:
        return new char[] { '*', '*' };

    case Opcodes.DUP:
        return new char[] { '0' };

    case Opcodes.DUP2:
    case Opcodes.DUP_X2:
    case Opcodes.DUP2_X2:
        return null; // DUP2 depends on the types on the stack so we don't statically know the input types

    case Opcodes.DUP_X1:
    case Opcodes.DUP2_X1:
        return new char[] { '0', '1' };
    case Opcodes.SWAP:
        return new char[] { '0', '1' };
    case Opcodes.IADD:
    case Opcodes.ISUB:
    case Opcodes.IMUL:
    case Opcodes.IDIV:
    case Opcodes.IREM:
    case Opcodes.ISHL:
    case Opcodes.ISHR:
    case Opcodes.IUSHR:
    case Opcodes.IAND:
    case Opcodes.IOR:
    case Opcodes.IXOR:
        return new char[] { 'i', 'i' };

    case Opcodes.LADD:
    case Opcodes.LSUB:
    case Opcodes.LMUL:
    case Opcodes.LDIV:
    case Opcodes.LREM:
    case Opcodes.LSHL:
    case Opcodes.LSHR:
    case Opcodes.LAND:
    case Opcodes.LOR:
    case Opcodes.LXOR:
    case Opcodes.LCMP:
        return new char[] { 'l', 'l' };
    case Opcodes.FADD:
    case Opcodes.FSUB:
    case Opcodes.FMUL:
    case Opcodes.FDIV:
    case Opcodes.FREM:
    case Opcodes.FCMPG:
    case Opcodes.FCMPL:
        return new char[] { 'f', 'f' };
    case Opcodes.DADD:
    case Opcodes.DSUB:
    case Opcodes.DMUL:
    case Opcodes.DDIV:
    case Opcodes.DREM:
    case Opcodes.DCMPL:
    case Opcodes.DCMPG:
        return new char[] { 'd', 'd' };

    case Opcodes.INEG:
    case Opcodes.I2L:
    case Opcodes.I2F:
    case Opcodes.I2D:
    case Opcodes.I2B:
    case Opcodes.I2C:
    case Opcodes.I2S:
    case Opcodes.NEWARRAY:
        return new char[] { 'i' };
    case Opcodes.LNEG:
    case Opcodes.L2I:
    case Opcodes.L2F:
    case Opcodes.L2D:
        return new char[] { 'l' };

    case Opcodes.FNEG:
    case Opcodes.F2I:
    case Opcodes.F2L:
    case Opcodes.F2D:
        return new char[] { 'f' };
    case Opcodes.DNEG:
    case Opcodes.D2I:
    case Opcodes.D2L:
    case Opcodes.D2F:
        return new char[] { 'd' };
    case Opcodes.LUSHR:
        return new char[] { 'i', 'l' };

    case Opcodes.ARRAYLENGTH:
    case Opcodes.MONITORENTER:
    case Opcodes.MONITOREXIT:
    case Opcodes.ATHROW:
        return new char[] { 'o' };
    default:
        return null;

    }

}

---

From source file:com.codename1.tools.translator.Util.java

License:Open Source License

public static char[] getStackOutputTypes(Instruction instr) {
    char[] out = instr.getStackOutputTypes();
    if (out != null) {
        return out;
    }/*  w  w  w  .  j a v  a2 s  .co  m*/

    switch (instr.getOpcode()) {
    case Opcodes.NOP:
    case Opcodes.BASTORE:
    case Opcodes.CASTORE:
    case Opcodes.SASTORE:
    case Opcodes.IASTORE:
    case Opcodes.LASTORE:
    case Opcodes.FASTORE:
    case Opcodes.DASTORE:
    case Opcodes.AASTORE:
    case Opcodes.POP:
    case Opcodes.POP2:
    case Opcodes.MONITORENTER:
    case Opcodes.MONITOREXIT:
    case Opcodes.ATHROW:
        return new char[0];

    case Opcodes.ACONST_NULL:
    case Opcodes.AALOAD:
    case Opcodes.NEWARRAY:
        return new char[] { 'o' };

    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:
    case Opcodes.BALOAD:
    case Opcodes.CALOAD:
    case Opcodes.IALOAD:
    case Opcodes.SALOAD:
    case Opcodes.IADD:
    case Opcodes.ISUB:
    case Opcodes.IMUL:
    case Opcodes.IDIV:
    case Opcodes.IREM:
    case Opcodes.INEG:
    case Opcodes.ISHL:
    case Opcodes.ISHR:
    case Opcodes.IUSHR:
    case Opcodes.IAND:
    case Opcodes.IOR:
    case Opcodes.IXOR:
    case Opcodes.F2I:
    case Opcodes.D2I:
    case Opcodes.L2I:
    case Opcodes.I2C:
    case Opcodes.I2S:
    case Opcodes.LCMP:
    case Opcodes.FCMPG:
    case Opcodes.FCMPL:
    case Opcodes.DCMPL:
    case Opcodes.DCMPG:
    case Opcodes.ARRAYLENGTH:
    case Opcodes.SIPUSH:
    case Opcodes.BIPUSH:
        return new char[] { 'i' };
    case Opcodes.LCONST_0:
    case Opcodes.LCONST_1:
    case Opcodes.LALOAD:
    case Opcodes.LADD:
    case Opcodes.LSUB:
    case Opcodes.LMUL:
    case Opcodes.LDIV:
    case Opcodes.LREM:
    case Opcodes.LNEG:
    case Opcodes.LSHL:
    case Opcodes.LSHR:
    case Opcodes.LUSHR:
    case Opcodes.LAND:
    case Opcodes.LOR:
    case Opcodes.LXOR:
    case Opcodes.I2L:
    case Opcodes.F2L:
    case Opcodes.D2L:
        return new char[] { 'l' };
    case Opcodes.FCONST_0:
    case Opcodes.FCONST_1:
    case Opcodes.FCONST_2:
    case Opcodes.FALOAD:
    case Opcodes.FADD:
    case Opcodes.FSUB:
    case Opcodes.FMUL:
    case Opcodes.FDIV:
    case Opcodes.FREM:
    case Opcodes.FNEG:
    case Opcodes.I2F:
    case Opcodes.D2F:
    case Opcodes.L2F:
        return new char[] { 'f' };
    case Opcodes.DCONST_0:
    case Opcodes.DCONST_1:
    case Opcodes.DALOAD:
    case Opcodes.DADD:
    case Opcodes.DSUB:
    case Opcodes.DMUL:
    case Opcodes.DDIV:
    case Opcodes.DREM:
    case Opcodes.DNEG:
    case Opcodes.I2D:
    case Opcodes.F2D:
    case Opcodes.L2D:
        return new char[] { 'd' };
    case Opcodes.DUP:
        return new char[] { '0', '0' };

    case Opcodes.DUP2:
    case Opcodes.DUP_X2:
    case Opcodes.DUP2_X2:
        return null;

    case Opcodes.DUP_X1:
    case Opcodes.DUP2_X1:
        return new char[] { '0', '1', '0' };
    case Opcodes.SWAP:
        return new char[] { '1', '0' };

    default:
        return null;
    }

}

---

From source file:com.dank.asm.InsnNodeUtils.java

License:Open Source License

/**
 * Creates a numeric push instruction./*  www  .  j  a va 2s .  c  om*/
 * 
 * @param num
 *            The number to push.
 * @return The instruction node.
 */
public static AbstractInsnNode createNumericPushInsn(Number num) {
    long value = num.longValue();
    if (value == -1) {
        return new InsnNode(Opcodes.ICONST_M1);
    } else if (value == 0) {
        return new InsnNode(Opcodes.ICONST_0);
    } else if (value == 1) {
        return new InsnNode(Opcodes.ICONST_1);
    } else if (value == 2) {
        return new InsnNode(Opcodes.ICONST_2);
    } else if (value == 3) {
        return new InsnNode(Opcodes.ICONST_3);
    } else if (value == 4) {
        return new InsnNode(Opcodes.ICONST_4);
    } else if (value == 5) {
        return new InsnNode(Opcodes.ICONST_5);
    } else if (value >= Byte.MIN_VALUE && value <= Byte.MAX_VALUE) {
        return new IntInsnNode(Opcodes.BIPUSH, (int) value);
    } else if (value >= Short.MIN_VALUE && value <= Short.MAX_VALUE) {
        return new IntInsnNode(Opcodes.SIPUSH, (int) value);
    } else if (value >= Integer.MIN_VALUE && value <= Integer.MAX_VALUE) {
        return new LdcInsnNode((int) value);
    } else {
        return new LdcInsnNode(/* (long) */value);
    }
}

---

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