Example usage for org.objectweb.asm TypeReference NEW

Introduction

In this page you can find the example usage for org.objectweb.asm TypeReference NEW.

Prototype

int NEW

To view the source code for org.objectweb.asm TypeReference NEW.

Click Source Link

Document

The sort of type references that target the type of the object created by a 'new' instruction.

Usage

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

License:Open Source License

private boolean applyOperationAnnotation(@Nonnull final A a, final int typeRef,
        @Nullable final TypePath typePath, final boolean logError) {
    final Op op = this.ops.get(this.ops.size() - 1);
    final TypeReference typeReference = new TypeReference(typeRef);
    switch (typeReference.getSort()) {
    case TypeReference.CAST: {
        if (op instanceof CAST) {
            ((CAST) op).setToT(annotateT(((CAST) op).getToT(), a, typePath));
            return true;
        }//from   w w w.j a va2 s . com
        if (logError) {
            log.warn(getM() + ": Wrong operation '" + op + "' for type annotation ref sort 'CAST' : " + typeRef
                    + " : " + typePath + " : " + a);
        }
        return false;
    }
    case TypeReference.CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT:
    case TypeReference.METHOD_INVOCATION_TYPE_ARGUMENT: {
        if (op instanceof INVOKE) {
            log.warn(getM()
                    + ": Missing bytecode info, cannot really apply type annotation ref sort 'CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT' or 'METHOD_INVOCATION_TYPE_ARGUMENT' : "
                    + typeRef + " : " + typePath + " : " + a);
            return true;
        }
        if (logError) {
            log.warn(getM() + ": Wrong operation '" + op
                    + "' for type annotation ref sort 'CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT' or 'METHOD_INVOCATION_TYPE_ARGUMENT' : "
                    + typeRef + " : " + typePath + " : " + a);
        }
        return false;
    }
    case TypeReference.CONSTRUCTOR_REFERENCE:
    case TypeReference.METHOD_REFERENCE: {
        if (op instanceof INVOKE) {
            final Object[] bsArgs = ((INVOKE) op).getBsArgs();
            if (bsArgs != null && bsArgs.length > 1) {
                final Object bsArg = bsArgs[1];
                if (bsArg instanceof M) {
                    bsArgs[1] = annotateM((M) bsArg, a, typePath);
                    return true;
                }
            }
        }
        if (logError) {
            log.warn(getM() + ": Wrong operation '" + op
                    + "' for type annotation ref sort 'CONSTRUCTOR_REFERENCE' or 'METHOD_REFERENCE' : "
                    + typeRef + " : " + typePath + " : " + a);
        }
        return false;
    }
    case TypeReference.CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT:
    case TypeReference.METHOD_REFERENCE_TYPE_ARGUMENT: {
        if (op instanceof INVOKE) {
            final Object[] bsArgs = ((INVOKE) op).getBsArgs();
            if (bsArgs != null && bsArgs.length > 1 && bsArgs[1] instanceof M) {
                log.warn(getM()
                        + ": Missing bytecode info, cannot really apply type annotation ref sort 'CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT' or 'METHOD_REFERENCE_TYPE_ARGUMENT' : "
                        + typeRef + " : " + typePath + " : " + a);
                return true;
            }
        }
        if (logError) {
            log.warn(getM() + ": Wrong operation '" + op
                    + "' for type annotation ref sort 'CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT' or 'METHOD_REFERENCE_TYPE_ARGUMENT' : "
                    + typeRef + " : " + typePath + " : " + a);
        }
        return false;
    }
    case TypeReference.NEW: {
        if (op instanceof NEW || op instanceof NEWARRAY) {
            ((TypedOp) op).setT(annotateT(((TypedOp) op).getT(), a, typePath));
            return true;
        }
        if (logError) {
            log.warn(getM() + ": Wrong operation '" + op + "' for type annotation ref sort 'NEW' : " + typeRef
                    + " : " + typePath + " : " + a);
        }
        return false;
    }
    default:
        log.warn(
                getM() + ": Unknown type annotation ref sort '0x" + Integer.toHexString(typeReference.getSort())
                        + "' : " + typeRef + " : " + typePath + " : " + a);
    }
    return false;
}

---