Example usage for org.objectweb.asm Opcodes ACC

Introduction

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

Prototype

int ACC_ANNOTATION

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

Click Source Link

Usage

From source file:com.googlecode.dex2jar.tools.JarAccessCmd.java

License:Apache License

static int str2acc(String s) {
    if (s == null) {
        return 0;
    }/*from  w w  w. j  a va  2  s  . c  om*/
    int result = 0;
    s = s.toLowerCase();
    if (s.contains("public")) {
        result |= Opcodes.ACC_PUBLIC;
    }
    if (s.contains("private")) {
        result |= Opcodes.ACC_PRIVATE;
    }
    if (s.contains("protected")) {
        result |= Opcodes.ACC_PROTECTED;
    }
    if (s.contains("final")) {
        result |= Opcodes.ACC_FINAL;
    }
    if (s.contains("static")) {
        result |= Opcodes.ACC_STATIC;
    }
    if (s.contains("super")) {
        result |= Opcodes.ACC_SUPER;
    }
    if (s.contains("synchronized")) {
        result |= Opcodes.ACC_SYNCHRONIZED;
    }
    if (s.contains("volatile")) {
        result |= Opcodes.ACC_VOLATILE;
    }
    if (s.contains("bridge")) {
        result |= Opcodes.ACC_BRIDGE;
    }
    if (s.contains("transient")) {
        result |= Opcodes.ACC_TRANSIENT;
    }
    if (s.contains("varargs")) {
        result |= Opcodes.ACC_VARARGS;
    }
    if (s.contains("native")) {
        result |= Opcodes.ACC_NATIVE;
    }
    if (s.contains("strict")) {
        result |= Opcodes.ACC_STRICT;
    }
    if (s.contains("interface")) {
        result |= Opcodes.ACC_INTERFACE;
    }
    if (s.contains("abstract")) {
        result |= Opcodes.ACC_ABSTRACT;
    }
    if (s.contains("synthetic")) {
        result |= Opcodes.ACC_SYNTHETIC;
    }
    if (s.contains("annotation")) {
        result |= Opcodes.ACC_ANNOTATION;
    }
    if (s.contains("enum")) {
        result |= Opcodes.ACC_ENUM;
    }
    if (s.contains("deprecated")) {
        result |= Opcodes.ACC_DEPRECATED;
    }
    return result;
}

From source file:com.googlecode.japi.checker.model.ClassData.java

License:Apache License

public boolean isAnnotation() {
    return (this.getAccess() & Opcodes.ACC_ANNOTATION) == Opcodes.ACC_ANNOTATION;
}

From source file:com.helger.meta.tools.codeingstyleguide.MainCheckCodingStyleguide.java

License:Apache License

private static void _checkClass(@Nonnull final IProject eProject, @Nonnull final ClassNode cn) {
    final String sClassLocalName = CGStringHelper.getClassLocalName(CGStringHelper.getClassFromPath(cn.name));
    final boolean bIsSpecialCase = sClassLocalName.equals("package-info");
    if (bIsSpecialCase)
        return;//from  ww  w . ja  v  a  2 s.  c  o m

    String sInnerClassLocalName = StringHelper.getFromLastExcl(sClassLocalName, '$');
    if (sInnerClassLocalName == null)
        sInnerClassLocalName = sClassLocalName;
    else if (StringParser.isUnsignedInt(sInnerClassLocalName)) {
        // It's an anonymous inner class - use the full name
        sInnerClassLocalName = sClassLocalName;
    }

    final String sPrefix = "[" + sClassLocalName + "] ";
    final boolean bClassIsAbstract = Modifier.isAbstract(cn.access);
    final boolean bClassIsAnnotation = (cn.access & Opcodes.ACC_ANNOTATION) != 0;
    final boolean bClassIsEnum = (cn.access & Opcodes.ACC_ENUM) != 0;
    final boolean bClassIsInterface = Modifier.isInterface(cn.access);

    if (bClassIsInterface) {
        if (bClassIsAnnotation) {
            // TODO
        } else {
            if (sInnerClassLocalName.startsWith("I")) {
                if (sInnerClassLocalName.length() > 1 && !Character.isUpperCase(sInnerClassLocalName.charAt(1)))
                    _warn(eProject, sPrefix + "Interface names should have an upper case second letter");
            } else if (!sInnerClassLocalName.startsWith("I") && !sClassLocalName.endsWith("MBean"))
                _warn(eProject, sPrefix + "Interface names should start with an uppercase 'I'");
        }
    } else {
        if (bClassIsEnum) {
            if (!sInnerClassLocalName.startsWith("E"))
                _warn(eProject, sPrefix + "enum classes should start with 'E'");
        } else {
            if (bClassIsAbstract) {
                if (!sInnerClassLocalName.startsWith("Abstract") && !sInnerClassLocalName.contains("Singleton"))
                    _warn(eProject, sPrefix + "Abstract classes should start with 'Abstract'");
            }
        }
    }
}

From source file:com.igormaznitsa.jute.TestClassProcessor.java

License:Apache License

@Override
public void visit(final int version, final int access, final String name, final String signature,
        final String superName, final String[] interfaces) {
    this.className = name.replace('/', '.');
    this.inappropriateClass = (access
            & (Opcodes.ACC_INTERFACE | Opcodes.ACC_ABSTRACT | Opcodes.ACC_ANNOTATION | Opcodes.ACC_ENUM)) != 0;
}

From source file:com.mebigfatguy.deadmethods.ClassInfo.java

License:Apache License

public boolean isAnnotation() {
    return (classAccess & Opcodes.ACC_ANNOTATION) != 0;
}

From source file:com.navercorp.pinpoint.profiler.instrument.ASMClassNodeAdapter.java

License:Apache License

public boolean isAnnotation() {
    return (classNode.access & Opcodes.ACC_ANNOTATION) != 0;
}

From source file:graph.Modifier.java

License:Apache License

/**
 * Returns an integer bit field for the EnumSet, where the bit values are
 * defined as in the class file format./*from w  w  w  .  ja v a  2 s .  c o  m*/
 *
 * @param  set   Set of modifiers to convert to a bit field.
 * @return       Integer bit field.
 */
public static int getBitField(EnumSet<Modifier> set) {
    int access = 0;

    if (set.contains(PUBLIC)) {
        access |= Opcodes.ACC_PUBLIC;
    }

    if (set.contains(PROTECTED)) {
        access |= Opcodes.ACC_PROTECTED;
    }

    if (set.contains(PRIVATE)) {
        access |= Opcodes.ACC_PRIVATE;
    }

    if (set.contains(STATIC)) {
        access |= Opcodes.ACC_STATIC;
    }

    if (set.contains(FINAL)) {
        access |= Opcodes.ACC_FINAL;
    }

    if (set.contains(SUPER)) {
        access |= Opcodes.ACC_SUPER;
    }

    if (set.contains(INTERFACE)) {
        access |= Opcodes.ACC_INTERFACE;
    }

    if (set.contains(ABSTRACT)) {
        access |= Opcodes.ACC_ABSTRACT;
    }

    if (set.contains(SYNTHETIC)) {
        access |= Opcodes.ACC_SYNTHETIC;
    }

    if (set.contains(ANNOTATION)) {
        access |= Opcodes.ACC_ANNOTATION;
    }

    if (set.contains(ENUM)) {
        access |= Opcodes.ACC_ENUM;
    }

    if (set.contains(VOLATILE)) {
        access |= Opcodes.ACC_VOLATILE;
    }

    if (set.contains(TRANSIENT)) {
        access |= Opcodes.ACC_TRANSIENT;
    }

    if (set.contains(SYNCHRONIZED)) {
        access |= Opcodes.ACC_SYNCHRONIZED;
    }

    if (set.contains(BRIDGE)) {
        access |= Opcodes.ACC_BRIDGE;
    }

    if (set.contains(VARARGS)) {
        access |= Opcodes.ACC_VARARGS;
    }

    if (set.contains(NATIVE)) {
        access |= Opcodes.ACC_NATIVE;
    }

    return access;
}

From source file:graph.Modifier.java

License:Apache License

/**
 * Returns an EnumSet of the modifiers, based on the given bit field (where
 * the bit values are defined as in the class file format).
 *
 * @param access Integer bit field giving access modifiers.
 * @return       Set of modifiers./*from ww  w .j a  va2s .  c  o m*/
 */
public static EnumSet<Modifier> getSet(int access) {
    EnumSet<Modifier> modifiers = EnumSet.noneOf(Modifier.class);

    if ((access & Opcodes.ACC_PUBLIC) != 0) {
        modifiers.add(Modifier.PUBLIC);
    }

    if ((access & Opcodes.ACC_PROTECTED) != 0) {
        modifiers.add(Modifier.PROTECTED);
    }

    if ((access & Opcodes.ACC_PRIVATE) != 0) {
        modifiers.add(Modifier.PRIVATE);
    }

    if ((access & Opcodes.ACC_STATIC) != 0) {
        modifiers.add(Modifier.STATIC);
    }

    if ((access & Opcodes.ACC_FINAL) != 0) {
        modifiers.add(Modifier.FINAL);
    }

    if ((access & Opcodes.ACC_SUPER) != 0) {
        modifiers.add(Modifier.SUPER);
    }

    if ((access & Opcodes.ACC_INTERFACE) != 0) {
        modifiers.add(Modifier.INTERFACE);
    }

    if ((access & Opcodes.ACC_ABSTRACT) != 0) {
        modifiers.add(Modifier.ABSTRACT);
    }

    if ((access & Opcodes.ACC_SYNTHETIC) != 0) {
        modifiers.add(Modifier.SYNTHETIC);
    }

    if ((access & Opcodes.ACC_ANNOTATION) != 0) {
        modifiers.add(Modifier.ANNOTATION);
    }

    if ((access & Opcodes.ACC_ENUM) != 0) {
        modifiers.add(Modifier.ENUM);
    }

    if ((access & Opcodes.ACC_VOLATILE) != 0) {
        modifiers.add(Modifier.VOLATILE);
    }

    if ((access & Opcodes.ACC_TRANSIENT) != 0) {
        modifiers.add(Modifier.TRANSIENT);
    }

    if ((access & Opcodes.ACC_SYNCHRONIZED) != 0) {
        modifiers.add(Modifier.SYNCHRONIZED);
    }

    if ((access & Opcodes.ACC_BRIDGE) != 0) {
        modifiers.add(Modifier.BRIDGE);
    }

    if ((access & Opcodes.ACC_VARARGS) != 0) {
        modifiers.add(Modifier.VARARGS);
    }

    if ((access & Opcodes.ACC_NATIVE) != 0) {
        modifiers.add(Modifier.NATIVE);
    }

    if ((access & Opcodes.ACC_STRICT) != 0) {
        modifiers.add(Modifier.STRICT);
    }

    return modifiers;
}

From source file:jp.co.dgic.testing.common.virtualmock.asm.AsmClassChecker.java

License:Open Source License

public void visit(int version, int access, String name, String signature, String superName,
        String[] interfaces) {// w  w  w.j  a v a  2 s .  com
    _className = name.replace('/', '.');
    _superClassName = superName;
    _interfaces = interfaces;

    isInterface = (access & Opcodes.ACC_INTERFACE) > 0;
    isAnnotation = (access & Opcodes.ACC_ANNOTATION) > 0;
    isEnum = (access & Opcodes.ACC_ENUM) > 0;

    if (isInterface && interfaces != null && interfaces.length > 0) {
        _superClassName = interfaces[0];
    }
    if (_superClassName != null) {
        _superClassName = _superClassName.replace('/', '.');
    }

    InternalMockObjectManager.printConsole(
            "[AsmClassChecker] " + _className + ".class is " + (isInterface ? "<INTERFACE>" : "<CLASS>"));

    collectSuperClassInfo();
}

From source file:org.adjective.stout.writer.ByteCodeWriter.java

License:Apache License

private int getModifierCode(Set<ElementModifier> modifiers, MemberType type) {
    int code = getModifierCode(modifiers, (Sort) null);
    int illegal = Opcodes.ACC_ANNOTATION | Opcodes.ACC_BRIDGE | Opcodes.ACC_ENUM | Opcodes.ACC_INTERFACE
            | Opcodes.ACC_SUPER;// w ww  . j ava 2s  .  c o m
    switch (type) {
    case FIELD:
        illegal |= Opcodes.ACC_ABSTRACT | Opcodes.ACC_NATIVE | Opcodes.ACC_STRICT | Opcodes.ACC_SYNCHRONIZED;
        break;
    case METHOD:
        if (isBitSet(Opcodes.ACC_ABSTRACT, code)) {
            illegal |= Opcodes.ACC_NATIVE | Opcodes.ACC_STRICT | Opcodes.ACC_SYNCHRONIZED | Opcodes.ACC_STATIC
                    | Opcodes.ACC_FINAL;
        }
        break;
    }
    if (isBitSet(illegal, code)) {
        throw new IllegalStateException(
                "Illegal combination of modifier codes: " + code + " (illegal codes: " + illegal + ")");
    }
    return code;
}

Example usage for org.objectweb.asm Opcodes ACC_ANNOTATION

Introduction

Prototype

Usage