Example usage for org.objectweb.asm Opcodes ACC_FINAL

List of usage examples for org.objectweb.asm Opcodes ACC_FINAL

  1. HOME
  2. Java
  3. org.objectweb.asm
  4. org.objectweb.asm.*
  5. Opcodes
  6. ACC_FINAL

Introduction

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

Prototype

int ACC_FINAL

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

Click Source Link

Usage

From source file:com.google.test.metric.asm.FieldVisitorBuilder.java

License:Apache License

public FieldVisitorBuilder(ClassInfo classInfo, int access, String name, String desc, String signature,
        Object value) {/*from   ww w.  j  av a 2s .  c o  m*/
    boolean isStatic = (access & Opcodes.ACC_STATIC) == Opcodes.ACC_STATIC;
    boolean isPrivate = JavaVisibility.valueFromJavaBytecode(access) == Visibility.PRIVATE;
    boolean isFinal = (access & Opcodes.ACC_FINAL) == Opcodes.ACC_FINAL;
    Type type = JavaType.fromDesc(desc);
    classInfo.addField(new FieldInfo(classInfo, name, type, isFinal, isStatic, isPrivate));
}

From source file:com.googlecode.ddom.weaver.ext.ModelExtensionFactoryImplementation.java

License:Apache License

public void accept(ClassVisitor classVisitor) {
    // Note: the name chosen here must match what is expected in ExtensionFactoryLocator
    String name = Util.classNameToInternalName(implementationInfo.getFactoryInterface().getName() + "$$Impl");
    String factoryInterfaceName = Util
            .classNameToInternalName(implementationInfo.getFactoryInterface().getName());
    classVisitor.visit(Opcodes.V1_5, Opcodes.ACC_PUBLIC, name, null, "java/lang/Object",
            new String[] { factoryInterfaceName });
    {//  ww  w .j  a  va 2s  .  c  o  m
        FieldVisitor fw = classVisitor.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL | Opcodes.ACC_STATIC,
                "INSTANCE", "L" + factoryInterfaceName + ";", null, null);
        if (fw != null) {
            fw.visitEnd();
        }
    }
    {
        FieldVisitor fw = classVisitor.visitField(Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL, "delegates",
                "Ljava/util/Map;", null, null);
        if (fw != null) {
            fw.visitEnd();
        }
    }
    {
        MethodVisitor mv = classVisitor.visitMethod(Opcodes.ACC_PRIVATE, "<init>", "()V", null, null);
        if (mv != null) {
            mv.visitCode();
            Label l0 = new Label();
            mv.visitLabel(l0);
            // Call constructor from superclass
            mv.visitVarInsn(Opcodes.ALOAD, 0);
            mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V");
            // Create delegates map
            mv.visitVarInsn(Opcodes.ALOAD, 0);
            mv.visitTypeInsn(Opcodes.NEW, "java/util/HashMap");
            mv.visitInsn(Opcodes.DUP);
            mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/util/HashMap", "<init>", "()V");
            mv.visitFieldInsn(Opcodes.PUTFIELD, name, "delegates", "Ljava/util/Map;");
            // Populate delegates map
            for (ModelExtensionInfo modelExtensionInfo : implementationInfo.getModelExtensions()) {
                for (ModelExtensionInterfaceInfo extensionInterface : modelExtensionInfo
                        .getExtensionInterfaces()) {
                    if (!extensionInterface.isAbstract()) {
                        // TODO: this is stupid; we should not recreate the info object here
                        ModelExtensionClassInfo modelExtensionClassInfo = new ModelExtensionClassInfo(
                                implementationInfo.getImplementation(), modelExtensionInfo.getRootInterface(),
                                extensionInterface);
                        String factoryDelegateImplName = Util.classNameToInternalName(
                                modelExtensionClassInfo.getFactoryDelegateImplementationClassName());
                        mv.visitVarInsn(Opcodes.ALOAD, 0);
                        mv.visitFieldInsn(Opcodes.GETFIELD, name, "delegates", "Ljava/util/Map;");
                        mv.visitLdcInsn(Type.getObjectType(Util.classNameToInternalName(
                                modelExtensionClassInfo.getExtensionInterface().getClassInfo().getName())));
                        mv.visitTypeInsn(Opcodes.NEW, factoryDelegateImplName);
                        mv.visitInsn(Opcodes.DUP);
                        mv.visitMethodInsn(Opcodes.INVOKESPECIAL, factoryDelegateImplName, "<init>", "()V");
                        mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, "java/util/Map", "put",
                                "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
                        mv.visitInsn(Opcodes.POP);
                    }
                }
            }
            mv.visitInsn(Opcodes.RETURN);
            Label l1 = new Label();
            mv.visitLabel(l1);
            mv.visitLocalVariable("this", "L" + name + ";", null, l0, l1, 0);
            mv.visitMaxs(4, 1);
            mv.visitEnd();
        }
    }
    String factoryDelegateInterfaceName = Util
            .classNameToInternalName(implementationInfo.getFactoryDelegateInterfaceName());
    String getDelegateDesc = "(Ljava/lang/Class;)L" + factoryDelegateInterfaceName + ";";
    {
        MethodVisitor mv = classVisitor.visitMethod(Opcodes.ACC_PRIVATE, "getDelegate", getDelegateDesc, null,
                null);
        if (mv != null) {
            mv.visitCode();
            Label l0 = new Label();
            mv.visitLabel(l0);
            mv.visitVarInsn(Opcodes.ALOAD, 0);
            mv.visitFieldInsn(Opcodes.GETFIELD, name, "delegates", "Ljava/util/Map;");
            mv.visitVarInsn(Opcodes.ALOAD, 1);
            mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, "java/util/Map", "get",
                    "(Ljava/lang/Object;)Ljava/lang/Object;");
            mv.visitTypeInsn(Opcodes.CHECKCAST, factoryDelegateInterfaceName);
            mv.visitInsn(Opcodes.ARETURN);
            Label l1 = new Label();
            mv.visitLabel(l1);
            mv.visitLocalVariable("this", "L" + name + ";", null, l0, l1, 0);
            mv.visitLocalVariable("extensionInterface", "Ljava/lang/Class;", null, l0, l1, 1);
            mv.visitMaxs(2, 2);
            mv.visitEnd();
        }
    }
    String implementationName = Util.classNameToInternalName(implementationInfo.getImplementation().getName());
    for (ConstructorInfo constructor : implementationInfo.getConstructors()) {
        Type[] constructorArgumentTypes = constructor.getArgumentTypes();
        Type[] argumentTypes = new Type[constructorArgumentTypes.length + 1];
        argumentTypes[0] = Type.getObjectType("java/lang/Class");
        System.arraycopy(constructorArgumentTypes, 0, argumentTypes, 1, constructorArgumentTypes.length);
        MethodVisitor mv = classVisitor.visitMethod(Opcodes.ACC_PUBLIC, "create",
                Type.getMethodDescriptor(Type.getObjectType(implementationName), argumentTypes), null, null);
        if (mv != null) {
            mv.visitCode();
            Label l0 = new Label();
            mv.visitLabel(l0);
            mv.visitVarInsn(Opcodes.ALOAD, 1);
            Label l1 = new Label();
            mv.visitJumpInsn(Opcodes.IFNONNULL, l1);
            mv.visitTypeInsn(Opcodes.NEW, implementationName);
            mv.visitInsn(Opcodes.DUP);
            for (int i = 0; i < constructorArgumentTypes.length; i++) {
                mv.visitVarInsn(constructorArgumentTypes[i].getOpcode(Opcodes.ILOAD), i + 2);
            }
            mv.visitMethodInsn(Opcodes.INVOKESPECIAL, implementationName, "<init>",
                    constructor.getDescriptor());
            mv.visitInsn(Opcodes.ARETURN);
            mv.visitLabel(l1);
            mv.visitVarInsn(Opcodes.ALOAD, 0);
            mv.visitVarInsn(Opcodes.ALOAD, 1);
            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, name, "getDelegate", getDelegateDesc);
            for (int i = 0; i < constructorArgumentTypes.length; i++) {
                mv.visitVarInsn(constructorArgumentTypes[i].getOpcode(Opcodes.ILOAD), i + 2);
            }
            mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, factoryDelegateInterfaceName, "create",
                    constructor.getFactoryDelegateMethodDescriptor());
            mv.visitInsn(Opcodes.ARETURN);
            Label l3 = new Label();
            mv.visitLabel(l3);
            mv.visitLocalVariable("this", "L" + name + ";", null, l0, l3, 0);
            mv.visitLocalVariable("extensionInterface", "Ljava/lang/Class;", null, l0, l3, 1);
            for (int i = 0; i < constructorArgumentTypes.length; i++) {
                mv.visitLocalVariable("arg" + i, constructorArgumentTypes[i].getDescriptor(), null, l0, l3,
                        i + 2);
            }
            mv.visitMaxs(argumentTypes.length + 1, argumentTypes.length + 1);
            mv.visitEnd();
        }
    }
    {
        MethodVisitor mv = classVisitor.visitMethod(Opcodes.ACC_STATIC, "<clinit>", "()V", null, null);
        if (mv != null) {
            mv.visitCode();
            mv.visitTypeInsn(Opcodes.NEW, name);
            mv.visitInsn(Opcodes.DUP);
            mv.visitMethodInsn(Opcodes.INVOKESPECIAL, name, "<init>", "()V");
            mv.visitFieldInsn(Opcodes.PUTSTATIC, name, "INSTANCE", "L" + factoryInterfaceName + ";");
            mv.visitInsn(Opcodes.RETURN);
            mv.visitMaxs(2, 0);
            mv.visitEnd();
        }
    }
    classVisitor.visitEnd();
}

From source file:com.googlecode.dex2jar.ir.ToStringUtil.java

License:Apache License

public static String getAccDes(int acc) {
    StringBuilder sb = new StringBuilder();
    if ((acc & Opcodes.ACC_PUBLIC) != 0) {
        sb.append("public ");
    }/*from   w w  w  .  j  av  a2  s.c o m*/
    if ((acc & Opcodes.ACC_PROTECTED) != 0) {
        sb.append("protected ");
    }
    if ((acc & Opcodes.ACC_PRIVATE) != 0) {
        sb.append("private ");
    }
    if ((acc & Opcodes.ACC_STATIC) != 0) {
        sb.append("static ");
    }
    if ((acc & Opcodes.ACC_ABSTRACT) != 0 && (acc & Opcodes.ACC_INTERFACE) == 0) {
        sb.append("abstract ");
    }
    if ((acc & Opcodes.ACC_ANNOTATION) != 0) {
        sb.append("annotation ");
    }
    if ((acc & Opcodes.ACC_BRIDGE) != 0) {
        sb.append("bridge ");
    }
    if ((acc & Opcodes.ACC_DEPRECATED) != 0) {
        sb.append("deprecated ");
    }
    if ((acc & Opcodes.ACC_ENUM) != 0) {
        sb.append("enum ");
    }
    if ((acc & Opcodes.ACC_FINAL) != 0) {
        sb.append("final ");
    }
    if ((acc & Opcodes.ACC_INTERFACE) != 0) {
        sb.append("interace ");
    }
    if ((acc & Opcodes.ACC_NATIVE) != 0) {
        sb.append("native ");
    }
    if ((acc & Opcodes.ACC_STRICT) != 0) {
        sb.append("strict ");
    }
    if ((acc & Opcodes.ACC_SYNCHRONIZED) != 0) {
        sb.append("synchronized ");
    }
    if ((acc & Opcodes.ACC_TRANSIENT) != 0) {
        sb.append("transient ");
    }
    if ((acc & Opcodes.ACC_VARARGS) != 0) {
        sb.append("varargs ");
    }
    if ((acc & Opcodes.ACC_VOLATILE) != 0) {
        sb.append("volatile ");
    }
    return sb.toString();
}

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

License:Apache License

static int str2acc(String s) {
    if (s == null) {
        return 0;
    }/*www  .j a  v  a  2 s.c o m*/
    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.JavaItem.java

License:Apache License

protected JavaItem(ClassDataLoader loader, ClassData owner, int access, String name) {
    this.setOwner(owner);
    this.setName(name);
    this.setVisibility(toScope(access));
    this.setAbstract((access & Opcodes.ACC_ABSTRACT) == Opcodes.ACC_ABSTRACT);
    this.setInterface((access & Opcodes.ACC_INTERFACE) == Opcodes.ACC_INTERFACE);
    this.setFinal((access & Opcodes.ACC_FINAL) == Opcodes.ACC_FINAL);
    this.setStatic((access & Opcodes.ACC_STATIC) == Opcodes.ACC_STATIC);
    this.setTransient((access & Opcodes.ACC_TRANSIENT) == Opcodes.ACC_TRANSIENT);
    this.setVariableArity((access & Opcodes.ACC_VARARGS) == Opcodes.ACC_VARARGS);
    this.setClassDataLoader(loader);
}

From source file:com.jcwhatever.nucleus.localizer.LanguageGenerator.java

License:MIT License

private List<LiteralInfo> parseClass(ClassNode classNode, Map<String, AnnotationInfo> annotations) {

    List<LiteralInfo> result = new ArrayList<>(10);

    // parse class annotations
    @SuppressWarnings("unchecked")
    List<AnnotationNode> classAnnotations = classNode.visibleAnnotations;
    if (classAnnotations != null) {

        for (AnnotationNode node : classAnnotations) {

            String nodeName = node.desc.substring(1, node.desc.length() - 1);

            AnnotationInfo info = annotations.get(nodeName);
            if (info == null)
                continue;

            result.addAll(parseAnnotationUsage(classNode, node));
        }//w w  w .ja va  2 s .c  om
    }

    // parse fields
    @SuppressWarnings("unchecked")
    List<FieldNode> fields = (List<FieldNode>) classNode.fields;
    if (fields == null)
        return new ArrayList<>(0);

    for (FieldNode node : fields) {

        @SuppressWarnings("unchecked")
        List<AnnotationNode> annotationNodes = node.visibleAnnotations;
        if (annotationNodes == null)
            continue;

        for (AnnotationNode annotation : annotationNodes) {
            if (!isLocalizableAnnotation(annotation.desc))
                continue;

            boolean isStatic = (node.access & Opcodes.ACC_STATIC) != 0;
            boolean isFinal = (node.access & Opcodes.ACC_FINAL) != 0;

            String desc = "FIELD: " + node.name + ' ' + classNode.name;

            if (!isStatic) {
                System.out.println("[IGNORED] @Localizable field found but isn't static: " + desc);
            }

            if (!isFinal) {
                System.out.println("[IGNORED] @Localizable field found but isn't final: " + desc);
            }

            if (!isStatic || !isFinal)
                continue;

            if (node.value instanceof String) {
                System.out.println("@Localizable field found: " + desc);

                result.add(new LiteralInfo((String) node.value, desc));
            } else {
                System.out.println(
                        "[IGNORED] @Localizable field found but did not contain a String value: " + desc);
            }
        }
    }

    return result;
}

From source file:com.liferay.portal.nio.intraband.proxy.IntrabandProxyUtil.java

License:Open Source License

protected static Class<? extends IntrabandProxySkeleton> generateSkeletonClass(ClassLoader classLoader,
        Class<?> clazz) {/*from  ww w  . j  a  va  2 s .c  om*/

    Type targetType = Type.getType(clazz);

    String internalName = targetType.getInternalName();

    ClassNode classNode = ASMUtil.loadAndRename(TemplateSkeleton.class, internalName.concat(SKELETON_POSTFIX));

    classNode.access &= ~Opcodes.ACC_ABSTRACT;
    classNode.access |= Opcodes.ACC_PUBLIC;

    FieldNode proxyMethodsMappingFieldNode = ASMUtil.findFieldNode(classNode.fields, "_PROXY_METHODS_MAPPING");

    proxyMethodsMappingFieldNode.access |= Opcodes.ACC_FINAL;

    FieldNode targetLocatorFieldNode = ASMUtil.findFieldNode(classNode.fields, "_targetLocator");

    targetLocatorFieldNode.access |= Opcodes.ACC_FINAL;

    MethodNode doDispatchMethodNode = ASMUtil.findMethodNode(classNode.methods, "doDispatch", Type.VOID_TYPE,
            _REGISTRATION_REFERENCE_TYPE, _DATAGRAM_TYPE, _DESERIALIZER_TYPE);

    doDispatchMethodNode.access &= ~Opcodes.ACC_ABSTRACT;

    MethodNodeGenerator methodNodeGenerator = new MethodNodeGenerator(doDispatchMethodNode);

    // T target = (T)_targetLocator.getTarget()

    methodNodeGenerator.loadThis();

    methodNodeGenerator.getField(Type.getObjectType(classNode.name), "_targetLocator", _TARGET_LOCATOR_TYPE);

    methodNodeGenerator.loadArg(2);

    deserializerRead(methodNodeGenerator, _STRING_TYPE);

    methodNodeGenerator.invokeInterface(_TARGET_LOCATOR_TYPE.getInternalName(), "getTarget", _OBJECT_TYPE,
            _STRING_TYPE);

    methodNodeGenerator.checkCast(targetType);

    int typedTargetIndex = methodNodeGenerator.newLocal(targetType);

    methodNodeGenerator.storeLocal(typedTargetIndex);

    // int index = deserializer.readInt();

    methodNodeGenerator.loadArg(2);

    deserializerRead(methodNodeGenerator, Type.INT_TYPE);

    methodNodeGenerator.dup();

    int indexIndex = methodNodeGenerator.newLocal(Type.INT_TYPE);

    methodNodeGenerator.storeLocal(indexIndex);

    // switch (index)

    MethodsBag methodsBag = extractMethods(clazz);

    List<Method> proxyMethods = methodsBag.proxyMethods;

    int[] keys = new int[proxyMethods.size()];

    for (int i = 0; i < keys.length; i++) {
        keys[i] = i;
    }

    methodNodeGenerator.tableSwitch(keys, new SkeletonDispatchTableSwitchGenerator(methodNodeGenerator,
            proxyMethods, classNode.name, typedTargetIndex, indexIndex), true);

    methodNodeGenerator.returnValue();

    methodNodeGenerator.endMethod();

    rewriteGetProxyMethodSignaturesMethodNode(classNode, methodsBag.proxyMethodSignatures);

    return (Class<? extends IntrabandProxySkeleton>) toClass(classNode, classLoader);
}

From source file:com.liferay.portal.nio.intraband.proxy.IntrabandProxyUtil.java

License:Open Source License

protected static Class<?> generateStubClass(ClassLoader classLoader, Class<?> clazz, String skeletonId) {

    String internalName = Type.getInternalName(clazz);

    ClassNode classNode = ASMUtil.loadAndRename(clazz, internalName.concat(STUB_POSTFIX));

    // Class modifiers and hierarchy

    classNode.access &= ~(Opcodes.ACC_ABSTRACT | Opcodes.ACC_INTERFACE);
    classNode.access |= Opcodes.ACC_PUBLIC;

    if (clazz.isInterface()) {
        List<String> interfaces = classNode.interfaces;

        interfaces.clear();/*  w ww  . j  a va  2s.c  o m*/

        interfaces.add(internalName);
    }

    // Clean up MethodNodes that are going to be generated

    List<MethodNode> methodNodes = classNode.methods;

    MethodNode defaultInitMethodNode = ASMUtil.removeMethodNode(methodNodes, "<init>", Type.VOID_TYPE);

    ASMUtil.removeMethodNodes(methodNodes, "<init>");
    ASMUtil.removeMethodNodes(methodNodes, Opcodes.ACC_ABSTRACT);
    ASMUtil.removeMethodNodes(methodNodes, _annotationDescriptors);

    // Apply template class

    ClassNode templateClassNode = ASMUtil.loadAndRename(TemplateStub.class, classNode.name);

    List<FieldNode> templateFieldNodes = templateClassNode.fields;

    FieldNode idFieldNode = ASMUtil.findFieldNode(templateFieldNodes, "_id");

    idFieldNode.access |= Opcodes.ACC_FINAL;

    FieldNode intrabandFieldNode = ASMUtil.findFieldNode(templateFieldNodes, "_intraband");

    intrabandFieldNode.access |= Opcodes.ACC_FINAL;

    FieldNode registrationReferenceFieldNode = ASMUtil.findFieldNode(templateFieldNodes,
            "_registrationReference");

    registrationReferenceFieldNode.access |= Opcodes.ACC_FINAL;

    ASMUtil.addFieldNodes(classNode.fields, templateFieldNodes);

    List<MethodNode> templateMethodNodes = templateClassNode.methods;

    MethodNode templateInitMethodNode = ASMUtil.findMethodNode(templateMethodNodes, "<init>", Type.VOID_TYPE,
            _STRING_TYPE, _REGISTRATION_REFERENCE_TYPE, _EXCEPTION_HANDLER_TYPE);

    if (defaultInitMethodNode != null) {
        ASMUtil.mergeMethods(templateInitMethodNode, defaultInitMethodNode, templateInitMethodNode);
    }

    MethodNode defaultClinitMethodNode = ASMUtil.removeMethodNode(methodNodes, "<clinit>", Type.VOID_TYPE);

    if (defaultClinitMethodNode != null) {
        MethodNode templateClinitMethodNode = ASMUtil.findMethodNode(templateMethodNodes, "<clinit>",
                Type.VOID_TYPE);

        ASMUtil.mergeMethods(templateClinitMethodNode, defaultClinitMethodNode, templateClinitMethodNode);
    }

    methodNodes.addAll(templateMethodNodes);

    Type stubType = Type.getType(classNode.name);

    // Id methods

    MethodsBag methodsBag = extractMethods(clazz);

    for (Method idMethod : methodsBag.idMethods) {
        MethodNodeGenerator methodNodeGenerator = new MethodNodeGenerator(idMethod);

        methodNodeGenerator.loadThis();

        methodNodeGenerator.getField(stubType, "_id", _STRING_TYPE);

        methodNodeGenerator.returnValue();

        methodNodeGenerator.endMethod();

        methodNodes.add(methodNodeGenerator.getMethodNode());
    }

    // Proxy methods

    List<Method> proxyMethods = methodsBag.proxyMethods;

    for (int i = 0; i < proxyMethods.size(); i++) {
        methodNodes.add(createProxyMethodNode(proxyMethods.get(i), i, skeletonId, stubType));
    }

    // Empty methods

    for (Method emptyMethod : methodsBag.emptyMethods) {
        MethodNodeGenerator methodNodeGenerator = new MethodNodeGenerator(emptyMethod);

        ASMUtil.addDefaultReturnInsns(methodNodeGenerator, Type.getType(emptyMethod.getReturnType()));

        methodNodeGenerator.endMethod();

        methodNodes.add(methodNodeGenerator.getMethodNode());
    }

    rewriteGetProxyMethodSignaturesMethodNode(classNode, methodsBag.proxyMethodSignatures);

    return toClass(classNode, classLoader);
}

From source file:com.masetta.spann.metadata.reader.asm3_2.ModifierImpl.java

License:Apache License

public boolean isFinal() {
    return (modifier & Opcodes.ACC_FINAL) != 0;
}

From source file:com.mebigfatguy.baremetal4j.Sourcifier.java

License:Apache License

public String accessString(int access) {
    String separator = "";
    StringBuilder sb = new StringBuilder(32);
    if ((access & Opcodes.ACC_PUBLIC) != 0) {
        sb.append("public");
        separator = " ";
    } else if ((access & Opcodes.ACC_PROTECTED) != 0) {
        sb.append("protected");
        separator = " ";
    } else if ((access & Opcodes.ACC_PRIVATE) != 0) {
        sb.append("private");
        separator = " ";
    }//from  ww w  .j  ava2s  .c om

    if ((access & Opcodes.ACC_STATIC) != 0) {
        sb.append(separator).append("static");
        separator = " ";
    }

    if ((access & Opcodes.ACC_FINAL) != 0) {
        sb.append(separator).append("final");
        separator = " ";
    }

    return sb.toString();
}