Example usage for org.objectweb.asm MethodVisitor visitJumpInsn

List of usage examples for org.objectweb.asm MethodVisitor visitJumpInsn

  1. HOME
  2. Java
  3. org.objectweb.asm
  4. org.objectweb.asm.*
  5. MethodVisitor
  6. visitJumpInsn

Introduction

In this page you can find the example usage for org.objectweb.asm MethodVisitor visitJumpInsn.

Prototype

public void visitJumpInsn(final int opcode, final Label label)

Source Link

Document

Visits a jump instruction.

Usage

From source file:org.mbte.groovypp.compiler.transformers.BinaryExpressionTransformer.java

License:Apache License

private void intCmp(int op, boolean onTrue, MethodVisitor mv, Label label) {
    switch (op) {
    case Types.COMPARE_NOT_EQUAL:
        mv.visitJumpInsn(onTrue ? IFNE : IFEQ, label);
        break;//from  w w w. j  a  v  a2 s . c om

    case Types.COMPARE_EQUAL:
        mv.visitJumpInsn(onTrue ? IFEQ : IFNE, label);
        break;

    case Types.COMPARE_LESS_THAN:
        mv.visitJumpInsn(onTrue ? IFLT : IFGE, label);
        break;

    case Types.COMPARE_LESS_THAN_EQUAL:
        mv.visitJumpInsn(onTrue ? IFLE : IFGT, label);
        break;

    case Types.COMPARE_GREATER_THAN:
        mv.visitJumpInsn(onTrue ? IFGT : IFLE, label);
        break;

    case Types.COMPARE_GREATER_THAN_EQUAL:
        mv.visitJumpInsn(onTrue ? IFGE : IFLT, label);
        break;

    default:
        throw new IllegalStateException();
    }
}

From source file:org.mbte.groovypp.compiler.transformers.BinaryExpressionTransformer.java

License:Apache License

private BytecodeExpr evaluateCompare(final BinaryExpression be, final CompilerTransformer compiler,
        final Label label, final boolean onTrue, final int op) {
    final Operands operands = new Operands(be, compiler);
    BytecodeExpr l = compiler.transformSynthetic(operands.getLeft());

    BytecodeExpr r = compiler.transformSynthetic(operands.getRight());

    if (TypeUtil.isNumericalType(l.getType()) && TypeUtil.isNumericalType(r.getType())) {
        final ClassNode mathType = TypeUtil.getMathType(l.getType(), r.getType());
        final BytecodeExpr l1 = l;
        final BytecodeExpr r1 = r;
        return new BytecodeExpr(be, ClassHelper.VOID_TYPE) {
            public void compile(MethodVisitor mv) {
                l1.visit(mv);//www .j  av a2s . co  m
                box(l1.getType(), mv);
                cast(TypeUtil.wrapSafely(l1.getType()), TypeUtil.wrapSafely(mathType), mv);
                if (ClassHelper.isPrimitiveType(mathType))
                    unbox(mathType, mv);

                r1.visit(mv);
                box(r1.getType(), mv);
                cast(TypeUtil.wrapSafely(r1.getType()), TypeUtil.wrapSafely(mathType), mv);
                if (ClassHelper.isPrimitiveType(mathType))
                    unbox(mathType, mv);

                if (mathType == ClassHelper.int_TYPE) {
                    switch (op) {
                    case Types.COMPARE_EQUAL:
                        mv.visitJumpInsn(onTrue ? IF_ICMPEQ : IF_ICMPNE, label);
                        break;

                    case Types.COMPARE_NOT_EQUAL:
                        mv.visitJumpInsn(onTrue ? IF_ICMPNE : IF_ICMPEQ, label);
                        break;

                    case Types.COMPARE_LESS_THAN:
                        mv.visitJumpInsn(onTrue ? IF_ICMPLT : IF_ICMPGE, label);
                        break;

                    case Types.COMPARE_LESS_THAN_EQUAL:
                        mv.visitJumpInsn(onTrue ? IF_ICMPLE : IF_ICMPGT, label);
                        break;

                    case Types.COMPARE_GREATER_THAN:
                        mv.visitJumpInsn(onTrue ? IF_ICMPGT : IF_ICMPLE, label);
                        break;

                    case Types.COMPARE_GREATER_THAN_EQUAL:
                        mv.visitJumpInsn(onTrue ? IF_ICMPGE : IF_ICMPLT, label);
                        break;

                    default:
                        throw new IllegalStateException();
                    }
                } else if (mathType == ClassHelper.double_TYPE) {
                    mv.visitMethodInsn(INVOKESTATIC, "java/lang/Double", "compare", "(DD)I");
                    intCmp(op, onTrue, mv, label);
                } else if (mathType == ClassHelper.long_TYPE) {
                    mv.visitInsn(LCMP);
                    intCmp(op, onTrue, mv, label);
                } else if (mathType == ClassHelper.BigInteger_TYPE) {
                    mv.visitMethodInsn(INVOKEVIRTUAL, "java/math/BigInteger", "compareTo",
                            "(Ljava/math/BigInteger;)I");
                    intCmp(op, onTrue, mv, label);
                } else if (mathType == ClassHelper.BigDecimal_TYPE) {
                    mv.visitMethodInsn(INVOKEVIRTUAL, "java/math/BigDecimal", "compareTo",
                            "(Ljava/math/BigDecimal;)I");
                    intCmp(op, onTrue, mv, label);
                } else {
                    mv.visitMethodInsn(INVOKESTATIC, "org/codehaus/groovy/runtime/DefaultGroovyMethods",
                            "compareTo", "(Ljava/lang/Number;Ljava/lang/Number;)I");
                    intCmp(op, onTrue, mv, label);
                }
            }
        };
    } else {
        final BytecodeExpr l2 = l;
        final BytecodeExpr r2 = r;

        final boolean leftNull = l2.getType().equals(TypeUtil.NULL_TYPE);
        final boolean rightNull = r2.getType().equals(TypeUtil.NULL_TYPE);

        final int opType = be.getOperation().getType();
        if ((leftNull || rightNull) && (opType == Types.COMPARE_EQUAL || opType == Types.COMPARE_NOT_EQUAL
                || opType == Types.COMPARE_IDENTICAL || opType == Types.COMPARE_NOT_IDENTICAL)) {
            return new BytecodeExpr(be, ClassHelper.VOID_TYPE) {
                public void compile(MethodVisitor mv) {
                    if (rightNull) {
                        l2.visit(mv);
                        box(l2.getType(), mv);
                    } else {
                        r2.visit(mv);
                        box(r2.getType(), mv);
                    }

                    switch (opType) {
                    case Types.COMPARE_EQUAL:
                    case Types.COMPARE_IDENTICAL:
                        mv.visitJumpInsn(onTrue ? IFNULL : IFNONNULL, label);
                        break;

                    case Types.COMPARE_NOT_EQUAL:
                    case Types.COMPARE_NOT_IDENTICAL:
                        mv.visitJumpInsn(onTrue ? IFNONNULL : IFNULL, label);
                        break;
                    }
                }
            };
        }

        if (opType == Types.COMPARE_EQUAL || opType == Types.COMPARE_NOT_EQUAL) {
            int opType1 = opType;
            if (!onTrue) {
                if (opType == Types.COMPARE_EQUAL)
                    opType1 = Types.COMPARE_NOT_EQUAL;
                else
                    opType1 = Types.COMPARE_EQUAL;
            }
            return evaluateEqualNotEqual(be, compiler, label, l2, r2, opType1, false);
        }

        return new BytecodeExpr(be, ClassHelper.VOID_TYPE) {
            public void compile(MethodVisitor mv) {
                l2.visit(mv);
                box(l2.getType(), mv);

                r2.visit(mv);
                box(r2.getType(), mv);

                switch (opType) {
                case Types.COMPARE_IDENTICAL:
                    mv.visitJumpInsn(onTrue ? IF_ACMPEQ : IF_ACMPNE, label);
                    break;

                case Types.COMPARE_NOT_IDENTICAL:
                    mv.visitJumpInsn(onTrue ? IF_ACMPNE : IF_ACMPEQ, label);
                    break;

                case Types.COMPARE_LESS_THAN:
                    mv.visitMethodInsn(INVOKESTATIC, TypeUtil.DTT_INTERNAL, "compareTo",
                            "(Ljava/lang/Object;Ljava/lang/Object;)I");
                    mv.visitJumpInsn(onTrue ? IFLT : IFGE, label);
                    break;

                case Types.COMPARE_LESS_THAN_EQUAL:
                    mv.visitMethodInsn(INVOKESTATIC, TypeUtil.DTT_INTERNAL, "compareTo",
                            "(Ljava/lang/Object;Ljava/lang/Object;)I");
                    mv.visitJumpInsn(onTrue ? IFLE : IFGT, label);
                    break;

                case Types.COMPARE_GREATER_THAN:
                    mv.visitMethodInsn(INVOKESTATIC, TypeUtil.DTT_INTERNAL, "compareTo",
                            "(Ljava/lang/Object;Ljava/lang/Object;)I");
                    mv.visitJumpInsn(onTrue ? IFGT : IFLE, label);
                    break;

                case Types.COMPARE_GREATER_THAN_EQUAL:
                    mv.visitMethodInsn(INVOKESTATIC, TypeUtil.DTT_INTERNAL, "compareTo",
                            "(Ljava/lang/Object;Ljava/lang/Object;)I");
                    mv.visitJumpInsn(onTrue ? IFGE : IFLT, label);
                    break;

                default:
                    throw new UnsupportedOperationException();
                }
            }
        };
    }
}

From source file:org.mbte.groovypp.compiler.transformers.BinaryExpressionTransformer.java

License:Apache License

private BytecodeExpr evaluateEqualNotEqual(final BinaryExpression be, CompilerTransformer compiler,
        final Label label, final BytecodeExpr left, final BytecodeExpr right, final int opType,
        final boolean swap) {
    if (left.getType().equals(ClassHelper.OBJECT_TYPE)) {
        if (right.getType().equals(ClassHelper.OBJECT_TYPE)) {
            return new BytecodeExpr(be, ClassHelper.VOID_TYPE) {
                public void compile(MethodVisitor mv) {
                    swapIfNeeded(mv, swap, right, left);

                    mv.visitMethodInsn(INVOKESTATIC, "org/mbte/groovypp/runtime/DefaultGroovyPPMethods",
                            "equals", "(Ljava/lang/Object;Ljava/lang/Object;)Z");

                    switch (opType) {
                    case Types.COMPARE_EQUAL:
                        mv.visitJumpInsn(IFNE, label);
                        break;

                    case Types.COMPARE_NOT_EQUAL:
                        mv.visitJumpInsn(IFEQ, label);
                        break;
                    }/*from   w w  w  . j a v a  2s  . co m*/
                }
            };
        } else {
            return evaluateEqualNotEqual(be, compiler, label, right, left, opType, true);
        }
    }

    final ClassNode wrapper = ClassHelper.getWrapper(left.getType());
    if (wrapper.implementsInterface(TypeUtil.COMPARABLE) || wrapper.equals(TypeUtil.COMPARABLE)) {
        return new BytecodeExpr(be, ClassHelper.VOID_TYPE) {
            public void compile(MethodVisitor mv) {
                swapIfNeeded(mv, swap, right, left);

                mv.visitMethodInsn(INVOKESTATIC, "org/mbte/groovypp/runtime/DefaultGroovyPPMethods",
                        "compareToWithEqualityCheck", "(Ljava/lang/Object;Ljava/lang/Object;)I");
                switch (opType) {
                case Types.COMPARE_EQUAL:
                    mv.visitJumpInsn(IFEQ, label);
                    break;

                case Types.COMPARE_NOT_EQUAL:
                    mv.visitJumpInsn(IFNE, label);
                    break;
                }
            }
        };
    } else {
        final BytecodeExpr ldummy = new BytecodeExpr(left, TypeUtil.wrapSafely(left.getType())) {
            protected void compile(MethodVisitor mv) {
            }
        };
        final BytecodeExpr rdummy = new BytecodeExpr(right, TypeUtil.wrapSafely(right.getType())) {
            protected void compile(MethodVisitor mv) {
            }
        };
        final MethodCallExpression safeCall = new MethodCallExpression(ldummy, "equals",
                new ArgumentListExpression(rdummy));
        safeCall.setSourcePosition(be);

        final ResolvedMethodBytecodeExpr call = (ResolvedMethodBytecodeExpr) compiler.transform(safeCall);
        final boolean staticEquals = call.getMethodNode().isStatic()
                || (call.getMethodNode() instanceof ClassNodeCache.DGM);
        final boolean defaultEquals = !staticEquals
                && call.getMethodNode().getParameters()[0].getType().equals(ClassHelper.OBJECT_TYPE);

        if (staticEquals || defaultEquals) {
            return new BytecodeExpr(be, ClassHelper.VOID_TYPE) {
                public void compile(MethodVisitor mv) {
                    swapIfNeeded(mv, swap, right, left);

                    if (defaultEquals)
                        mv.visitMethodInsn(INVOKESTATIC, "org/mbte/groovypp/runtime/DefaultGroovyPPMethods",
                                "equals", "(Ljava/lang/Object;Ljava/lang/Object;)Z");
                    else {
                        call.visit(mv);
                    }

                    switch (opType) {
                    case Types.COMPARE_EQUAL:
                        mv.visitJumpInsn(IFNE, label);
                        break;

                    case Types.COMPARE_NOT_EQUAL:
                        mv.visitJumpInsn(IFEQ, label);
                        break;
                    }
                }
            };
        } else {
            // case of multi-method
            return new BytecodeExpr(be, ClassHelper.VOID_TYPE) {
                public void compile(MethodVisitor mv) {
                    swapIfNeeded(mv, swap, right, left);

                    Label end = new Label(), trueLabelPop2 = new Label(), falseLabelPop2 = new Label();

                    mv.visitInsn(DUP2);

                    switch (opType) {
                    case Types.COMPARE_EQUAL:
                        mv.visitJumpInsn(IF_ACMPEQ, trueLabelPop2);
                        break;

                    case Types.COMPARE_NOT_EQUAL:
                        mv.visitJumpInsn(IF_ACMPEQ, falseLabelPop2);
                        break;
                    }

                    mv.visitInsn(DUP2);
                    mv.visitInsn(POP);

                    switch (opType) {
                    case Types.COMPARE_EQUAL:
                        mv.visitJumpInsn(IFNULL, falseLabelPop2);
                        break;

                    case Types.COMPARE_NOT_EQUAL:
                        mv.visitJumpInsn(IFNULL, trueLabelPop2);
                        break;
                    }

                    call.visit(mv);

                    switch (opType) {
                    case Types.COMPARE_EQUAL:
                        mv.visitJumpInsn(IFNE, label);
                        break;

                    case Types.COMPARE_NOT_EQUAL:
                        mv.visitJumpInsn(IFEQ, label);
                        break;
                    }

                    mv.visitJumpInsn(GOTO, end);

                    mv.visitLabel(trueLabelPop2);
                    mv.visitInsn(POP2);
                    mv.visitJumpInsn(GOTO, label);

                    mv.visitLabel(falseLabelPop2);
                    mv.visitInsn(POP2);

                    mv.visitLabel(end);
                }
            };
        }
    }
}

From source file:org.mbte.groovypp.compiler.transformers.ExprTransformer.java

License:Apache License

public BytecodeExpr transformLogical(T exp, CompilerTransformer compiler, final Label label,
        final boolean onTrue) {
    final BytecodeExpr be;
    be = (BytecodeExpr) transform(exp, compiler);
    final ClassNode type = be.getType();

    if (type == ClassHelper.VOID_TYPE) {
        return be;
    }/*from  ww w.j av  a2  s . c  o m*/

    if (ClassHelper.isPrimitiveType(type)) {
        return new BytecodeExpr(exp, ClassHelper.VOID_TYPE) {
            protected void compile(MethodVisitor mv) {
                be.visit(mv);
                if (type == ClassHelper.byte_TYPE || type == ClassHelper.short_TYPE
                        || type == ClassHelper.char_TYPE || type == ClassHelper.boolean_TYPE
                        || type == ClassHelper.int_TYPE) {
                } else if (type == ClassHelper.long_TYPE) {
                    mv.visitInsn(L2I);
                } else if (type == ClassHelper.float_TYPE) {
                    mv.visitInsn(F2I);
                } else if (type == ClassHelper.double_TYPE) {
                    mv.visitInsn(D2I);
                }
                mv.visitJumpInsn(onTrue ? IFNE : IFEQ, label);
            }
        };
    } else {
        MethodCallExpression safeCall = new MethodCallExpression(new BytecodeExpr(exp, be.getType()) {
            protected void compile(MethodVisitor mv) {
            }
        }, "asBoolean", ArgumentListExpression.EMPTY_ARGUMENTS);
        safeCall.setSourcePosition(exp);

        final ResolvedMethodBytecodeExpr call = (ResolvedMethodBytecodeExpr) compiler.transform(safeCall);

        if (!call.getType().equals(ClassHelper.boolean_TYPE))
            compiler.addError("asBoolean should return 'boolean'", exp);

        if (call.getMethodNode().getDeclaringClass().equals(ClassHelper.OBJECT_TYPE)) {
            // fast path
            return new BytecodeExpr(exp, ClassHelper.VOID_TYPE) {
                protected void compile(MethodVisitor mv) {
                    be.visit(mv);
                    mv.visitJumpInsn(onTrue ? IFNONNULL : IFNULL, label);
                }
            };
        } else {
            return new BytecodeExpr(exp, ClassHelper.VOID_TYPE) {
                protected void compile(MethodVisitor mv) {
                    be.visit(mv);
                    mv.visitInsn(DUP);
                    Label nullLabel = new Label(), endLabel = new Label();

                    mv.visitJumpInsn(IFNULL, nullLabel);

                    call.visit(mv);

                    if (onTrue) {
                        mv.visitJumpInsn(IFEQ, endLabel);
                        mv.visitJumpInsn(GOTO, label);

                        mv.visitLabel(nullLabel);
                        mv.visitInsn(POP);
                    } else {
                        mv.visitJumpInsn(IFNE, endLabel);
                        mv.visitJumpInsn(GOTO, label);

                        mv.visitLabel(nullLabel);
                        mv.visitInsn(POP);
                        mv.visitJumpInsn(GOTO, label);
                    }

                    mv.visitLabel(endLabel);
                }
            };
        }
    }
}

From source file:org.mbte.groovypp.compiler.transformers.JumpIfExpressionTransformer.java

License:Apache License

public Expression transform(final JumpIfExpression exp, CompilerTransformer compiler) {
    if (exp.condition == null) {
        return new BytecodeExpr(exp, ClassHelper.VOID_TYPE) {
            protected void compile(MethodVisitor mv) {
                mv.visitJumpInsn(GOTO, exp.targetExpression.label);
            }/*w w w  .j a  v  a  2s. c  om*/
        };
    }

    return compiler.transformLogical(exp.condition, exp.targetExpression.label, true);
}

From source file:org.mbte.groovypp.compiler.transformers.MethodCallExpressionTransformer.java

License:Apache License

private Expression transformSafe(MethodCallExpression exp, CompilerTransformer compiler) {
    final BytecodeExpr object = (BytecodeExpr) compiler.transformToGround(exp.getObjectExpression());
    ClassNode type = TypeUtil.wrapSafely(object.getType());

    MethodCallExpression callExpression = new MethodCallExpression(new BytecodeExpr(object, type) {
        protected void compile(MethodVisitor mv) {
        }/*w  w  w.ja v  a2 s  .  co m*/
    }, exp.getMethod(), exp.getArguments());
    callExpression.setSourcePosition(exp);
    final BytecodeExpr call = (BytecodeExpr) compiler.transform(callExpression);

    if (ClassHelper.isPrimitiveType(call.getType())) {
        return new BytecodeExpr(exp, call.getType()) {
            protected void compile(MethodVisitor mv) {
                Label nullLabel = new Label(), endLabel = new Label();

                object.visit(mv);
                mv.visitInsn(DUP);
                mv.visitJumpInsn(IFNULL, nullLabel);

                call.visit(mv);
                mv.visitJumpInsn(GOTO, endLabel);

                mv.visitLabel(nullLabel);
                mv.visitInsn(POP);

                if (call.getType() == ClassHelper.long_TYPE) {
                    mv.visitInsn(LCONST_0);
                } else if (call.getType() == ClassHelper.float_TYPE) {
                    mv.visitInsn(FCONST_0);
                } else if (call.getType() == ClassHelper.double_TYPE) {
                    mv.visitInsn(DCONST_0);
                } else
                    mv.visitInsn(ICONST_0);

                mv.visitLabel(endLabel);
            }
        };
    } else {
        return new BytecodeExpr(exp, call.getType()) {
            protected void compile(MethodVisitor mv) {
                object.visit(mv);
                Label nullLabel = new Label();
                mv.visitInsn(DUP);
                mv.visitJumpInsn(IFNULL, nullLabel);
                call.visit(mv);
                box(call.getType(), mv);
                mv.visitLabel(nullLabel);
                checkCast(getType(), mv);
            }
        };
    }
}

From source file:org.mbte.groovypp.compiler.transformers.PropertyExpressionTransformer.java

License:Apache License

private Expression transformSafe(final PropertyExpression exp, CompilerTransformer compiler) {
    final BytecodeExpr object = (BytecodeExpr) compiler.transform(exp.getObjectExpression());
    ClassNode type = TypeUtil.wrapSafely(object.getType());

    final PropertyExpression newExp = new PropertyExpression(new BytecodeExpr(object, type) {
        protected void compile(MethodVisitor mv) {
            // nothing to do
            // expect parent on stack
        }/*from   w  w  w  .  j av  a2s. com*/
    }, exp.getProperty());
    newExp.setSourcePosition(exp);
    final BytecodeExpr call = (BytecodeExpr) compiler.transform(newExp);

    if (ClassHelper.isPrimitiveType(call.getType())) {
        return new BytecodeExpr(exp, call.getType()) {
            protected void compile(MethodVisitor mv) {
                Label nullLabel = new Label(), endLabel = new Label();

                object.visit(mv);
                mv.visitInsn(DUP);
                mv.visitJumpInsn(IFNULL, nullLabel);

                call.visit(mv);
                mv.visitJumpInsn(GOTO, endLabel);

                mv.visitLabel(nullLabel);
                mv.visitInsn(POP);

                if (call.getType() == ClassHelper.long_TYPE) {
                    mv.visitInsn(LCONST_0);
                } else if (call.getType() == ClassHelper.float_TYPE) {
                    mv.visitInsn(FCONST_0);
                } else if (call.getType() == ClassHelper.double_TYPE) {
                    mv.visitInsn(DCONST_0);
                } else
                    mv.visitInsn(ICONST_0);

                mv.visitLabel(endLabel);
            }
        };
    } else {
        return new BytecodeExpr(exp, call.getType()) {
            protected void compile(MethodVisitor mv) {
                object.visit(mv);
                Label nullLabel = new Label();
                mv.visitInsn(DUP);
                mv.visitJumpInsn(IFNULL, nullLabel);
                call.visit(mv);
                box(call.getType(), mv);
                mv.visitLabel(nullLabel);
                checkCast(getType(), mv);
            }
        };
    }
}

From source file:org.moe.natj.processor.cxx.BCGen.java

License:Apache License

/**
 * Loads (and optionally converts) a variable onto the stack which comes from Java code.
 *
 * @param mv    Method visitor/*from  www . j  a  v a 2s  . c  o m*/
 * @param type  Type
 * @param index Variable index
 * @return Width of the loaded variable
 */
public static int toNativeLoadType(MethodVisitor mv, CxxType type, int index) {
    switch (type.getKind()) {
    case CXX_OBJECT:
    case CXX_OBJECT_BY_VALUE:
    case CXX_OBJECT_BY_REFERENCE:
    case CXX_CONST_OBJECT:
    case CXX_CONST_OBJECT_BY_VALUE:
    case CXX_CONST_OBJECT_BY_REFERENCE: {
        if (type.isNonConstCxxObjectKind()) {
            final Label isNull = new Label();
            final Label join = new Label();

            // if non null
            mv.visitVarInsn(ALOAD, index);
            mv.visitJumpInsn(IFNULL, isNull);

            // is non null
            {
                final Label isInstanceOf = new Label();
                mv.visitVarInsn(ALOAD, index);
                if (type.isTemplateCxxClass()) {
                    mv.visitTypeInsn(CHECKCAST,
                            type.getClassInfoForCxxObjectType().mapperType.getInternalName());
                }
                mv.visitTypeInsn(INSTANCEOF, CxxSupport.CXX_CONST_IMPL_ITF.getInternalName());
                mv.visitJumpInsn(IFNE, isInstanceOf);

                // then
                mv.visitVarInsn(ALOAD, index);
                swapCxxObjectWithItsPeer(mv, false);
                mv.visitJumpInsn(GOTO, join);

                // else
                mv.visitLabel(isInstanceOf);
                throw_new_IllegalArgumentException(mv, "tried to pass const type as mutable parameter");
            }

            // is null
            {
                mv.visitLabel(isNull);
                if (type.isByValueCxxObjectKind()) {
                    throw_new_NullPointerException(mv, "parameters marked with @CxxByValue cannot be null");

                } else if (type.isByReferenceCxxObjectKind()) {
                    throw_new_NullPointerException(mv, "parameters marked with @CxxByReference cannot be null");

                } else {
                    mv.visitInsn(LCONST_0);
                }
            }

            // join
            mv.visitLabel(join);

        } else {
            mv.visitVarInsn(ALOAD, index);
            if (type.isTemplateCxxClass()) {
                mv.visitTypeInsn(CHECKCAST, type.getClassInfoForCxxObjectType().mapperType.getInternalName());
            }
            swapCxxObjectWithItsPeer(mv, true);
        }
        return 1;
    }
    case CXX_JAVA_OBJECT: {
        mv.visitVarInsn(ALOAD, index);
        CxxRuntime_getUIDForObject(mv);
        return 1;
    }
    case PTR:
    case CONST_PTR:
    case REF:
    case CONST_REF:
        mv.visitVarInsn(ALOAD, index);
        swapPtrWithItsPeer(mv);
        return 1;
    default:
        return loadPrimitiveType(mv, type, index);
    }
}

From source file:org.moe.natj.processor.cxx.BCGen.java

License:Apache License

/**
 * Returns (and optionally converts) a value coming from Java to native code.
 *
 * @param mv           Method visitor/* w  w w  . j  av a2 s .  c o m*/
 * @param type         Type
 * @param localManager Local variable manager
 */
public static void fromJavaReturnType(MethodVisitor mv, CxxType type, CxxUtils.LocalManager localManager) {
    switch (type.getKind()) {
    case CXX_OBJECT:
    case CXX_OBJECT_BY_VALUE:
    case CXX_OBJECT_BY_REFERENCE:
    case CXX_CONST_OBJECT:
    case CXX_CONST_OBJECT_BY_VALUE:
    case CXX_CONST_OBJECT_BY_REFERENCE: {
        if (type.isNonConstCxxObjectKind()) {
            final Label isNull = new Label();
            final Label join = new Label();

            // if non null
            mv.visitInsn(DUP);
            mv.visitJumpInsn(IFNULL, isNull);

            // is non null
            {
                final Label isInstanceOf = new Label();
                if (type.isTemplateCxxClass()) {
                    mv.visitTypeInsn(CHECKCAST,
                            type.getClassInfoForCxxObjectType().mapperType.getInternalName());
                }
                mv.visitInsn(DUP);
                mv.visitTypeInsn(INSTANCEOF, CxxSupport.CXX_CONST_IMPL_ITF.getInternalName());
                mv.visitJumpInsn(IFNE, isInstanceOf);

                // then
                swapCxxObjectWithItsPeer(mv, false);
                mv.visitJumpInsn(GOTO, join);

                // else
                mv.visitLabel(isInstanceOf);
                mv.visitInsn(POP);
                throw_new_IllegalArgumentException(mv, "tried to pass const type as mutable parameter");
            }

            // is null
            {
                mv.visitLabel(isNull);
                mv.visitInsn(POP);
                if (type.isByValueCxxObjectKind()) {
                    throw_new_NullPointerException(mv, "parameters marked with @CxxByValue cannot be null");

                } else if (type.isByReferenceCxxObjectKind()) {
                    throw_new_NullPointerException(mv, "parameters marked with @CxxByReference cannot be null");

                } else {
                    mv.visitInsn(LCONST_0);
                }
            }

            // join
            mv.visitLabel(join);

        } else {
            if (type.isTemplateCxxClass()) {
                mv.visitTypeInsn(CHECKCAST, type.getClassInfoForCxxObjectType().mapperType.getInternalName());
            }
            swapCxxObjectWithItsPeer(mv, true);
        }
        mv.visitInsn(LRETURN);
        return;
    }
    case CXX_JAVA_OBJECT: {
        CxxRuntime_getUIDForObject(mv);
        mv.visitInsn(LRETURN);
        return;
    }
    case PTR:
    case CONST_PTR:
    case REF:
    case CONST_REF:
        swapPtrWithItsPeer(mv);
        mv.visitInsn(LRETURN);
        return;
    default:
        returnPrimitiveType(mv, type);
    }
}

From source file:org.moe.natj.processor.cxx.BCGen.java

License:Apache License

/**
 * Generates code which pops the top Ptr on the stack and replaces it with:
 * {@code top == null ? 0L : top.getPeer().getPeer()}
 *
 * @param mv Method visitor/*  w w w  . j  a va  2  s.co m*/
 */
public static void swapPtrWithItsPeer(MethodVisitor mv) {
    final Label isNull = new Label();
    final Label join = new Label();

    // if non null
    mv.visitInsn(DUP);
    mv.visitJumpInsn(IFNULL, isNull);

    // is non null
    {
        mv.visitMethodInsn(INVOKEINTERFACE, CxxSupport.PTR_CONSTVOIDPTR_ITF.getInternalName(), "getPeer",
                Type.getMethodDescriptor(CxxSupport.PTR_POINTER_CLS), true);
        mv.visitMethodInsn(INVOKEVIRTUAL, CxxSupport.PTR_POINTER_CLS.getInternalName(), "getPeer",
                Type.getMethodDescriptor(Type.LONG_TYPE), false);
        mv.visitJumpInsn(GOTO, join);
    }

    // is null
    {
        mv.visitLabel(isNull);
        mv.visitInsn(POP);
        mv.visitInsn(LCONST_0);
    }

    // join
    mv.visitLabel(join);
}