Example usage for org.objectweb.asm Opcodes ACC_STATIC

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

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

Introduction

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

Prototype

int ACC_STATIC

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

Click Source Link

Usage

From source file:asmlib.InfoField.java

License:Open Source License

public boolean isStatic() {
    return (access() & Opcodes.ACC_STATIC) != 0;
}

From source file:blue.origami.asm.OAnno.java

License:Apache License

public void add(String spec) {
    String[] annos = spec.split(",");
    for (String s : annos) {
        s = s.toLowerCase();/*from   w w w.ja  v  a2  s. c o m*/
        switch (s) {
        case "public":
            acc |= Opcodes.ACC_PUBLIC;
            acc &= ~Opcodes.ACC_PROTECTED;
            acc &= ~Opcodes.ACC_PRIVATE;
            break;
        case "protected":
            acc |= Opcodes.ACC_PROTECTED;
            acc &= ~Opcodes.ACC_PUBLIC;
            acc &= ~Opcodes.ACC_PRIVATE;
            break;
        case "private":
            acc |= Opcodes.ACC_PRIVATE;
            acc &= ~Opcodes.ACC_PUBLIC;
            acc &= ~Opcodes.ACC_PROTECTED;
            break;
        case "static":
            acc |= Opcodes.ACC_STATIC;
            break;
        case "abstract":
            acc |= Opcodes.ACC_ABSTRACT;
            break;
        case "interface":
            acc |= Opcodes.ACC_INTERFACE;
            break;
        case "final":
            acc |= Opcodes.ACC_FINAL;
            break;
        case "native":
            acc |= Opcodes.ACC_NATIVE;
            break;
        case "synchronized":
            acc |= Opcodes.ACC_SYNCHRONIZED;
            break;
        case "strictfp":
            acc |= Opcodes.ACC_STRICT;
            break;
        }
    }
}

From source file:blue.origami.asm.OAnno.java

License:Apache License

public final boolean isStatic() {
    return ((acc & Opcodes.ACC_STATIC) == Opcodes.ACC_STATIC);
}

From source file:blue.origami.asm.OGeneratorAdapter.java

License:Apache License

public OGeneratorAdapter(MethodVisitor mv, int acc, String name, String methodDesc) {
    super(Opcodes.ASM5, mv, acc, name, methodDesc);
    int startIndex = 0;
    if ((acc & Opcodes.ACC_STATIC) != Opcodes.ACC_STATIC) {
        startIndex = 1;/* w  w w .jav a2s  .  c o m*/
    }
    this.varScopes = new VarScopes(startIndex);
}

From source file:bndtools.diff.FieldInfo.java

License:Open Source License

public boolean isStatic() {
    return ((fieldNode.access & Opcodes.ACC_STATIC) == Opcodes.ACC_STATIC);
}

From source file:bndtools.diff.MethodInfo.java

License:Open Source License

public boolean isStatic() {
    return ((methodNode.access & Opcodes.ACC_STATIC) == Opcodes.ACC_STATIC);
}

From source file:br.ufpr.gres.core.MethodInfo.java

License:Apache License

public boolean isStatic() {
    return ((this.access & Opcodes.ACC_STATIC) != 0);
}

From source file:br.usp.each.saeg.badua.test.validation.MaxTest.java

License:Open Source License

@Override
@Before/*  w w w . ja  v a 2  s .co m*/
public void setUp() throws Exception {
    super.setUp();

    final int classVersion = Opcodes.V1_6;
    final int classAccessor = Opcodes.ACC_PUBLIC | Opcodes.ACC_SUPER;
    final String className = "Max";
    final String superName = "java/lang/Object";

    final int methodAccessor = Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC;
    final String methodName = "max";
    final String methodDesc = "([II)I";

    final ClassWriter cw = new ClassWriter(0);
    final MethodVisitor mw;

    cw.visit(classVersion, classAccessor, className, null, superName, null);
    mw = cw.visitMethod(methodAccessor, methodName, methodDesc, null, null);
    mw.visitCode();
    // block 0 (definitions {0, 1, 2, 3})
    mw.visitInsn(Opcodes.ICONST_0);
    mw.visitVarInsn(Opcodes.ISTORE, 2);
    mw.visitVarInsn(Opcodes.ALOAD, 0);
    mw.visitVarInsn(Opcodes.ILOAD, 2);
    mw.visitIincInsn(2, 1);
    mw.visitInsn(Opcodes.IALOAD);
    mw.visitVarInsn(Opcodes.ISTORE, 3);
    // block 1 (p-uses {1, 2})
    final Label backLoop = new Label();
    mw.visitLabel(backLoop);
    mw.visitVarInsn(Opcodes.ILOAD, 2);
    mw.visitVarInsn(Opcodes.ILOAD, 1);
    final Label breakLoop = new Label();
    mw.visitJumpInsn(Opcodes.IF_ICMPGE, breakLoop);
    // block 3 (p-uses {0, 2, 3})
    mw.visitVarInsn(Opcodes.ALOAD, 0);
    mw.visitVarInsn(Opcodes.ILOAD, 2);
    mw.visitInsn(Opcodes.IALOAD);
    mw.visitVarInsn(Opcodes.ILOAD, 3);
    final Label jump = new Label();
    mw.visitJumpInsn(Opcodes.IF_ICMPLE, jump);
    // block 5 (definitions {3}, uses {0, 2})
    mw.visitVarInsn(Opcodes.ALOAD, 0);
    mw.visitVarInsn(Opcodes.ILOAD, 2);
    mw.visitInsn(Opcodes.IALOAD);
    mw.visitVarInsn(Opcodes.ISTORE, 3);
    // block 4 (definitions {2}, uses {2})
    mw.visitLabel(jump);
    mw.visitIincInsn(2, 1);
    mw.visitJumpInsn(Opcodes.GOTO, backLoop);
    // block 2 ( uses {3})
    mw.visitLabel(breakLoop);
    mw.visitVarInsn(Opcodes.ILOAD, 3);
    mw.visitInsn(Opcodes.IRETURN);
    mw.visitMaxs(2, 4);
    mw.visitEnd();
    cw.visitEnd();

    final byte[] bytes = cw.toByteArray();
    klass = addClass(className, bytes);
    method = klass.getMethod(methodName, int[].class, int.class);
    classId = CRC64.checksum(bytes);

    RT.init(new RuntimeData());
}

From source file:ca.weblite.asm.JavaExtendedStubCompiler.java

License:Apache License

public Map<String, byte[]> compile(List<Type> types, File sourceFile) throws IOException {
    final Map<String, byte[]> outMap = new HashMap<>();
    final Set<String> typeNames = (types == null) ? null : new HashSet<String>();
    if (types != null) {
        for (Type type : types) {
            typeNames.add(type.getInternalName());
        }/*www .j a  v  a2  s .  c om*/
    }
    JavaCompiler compiler = JavacTool.create();
    MyFileObject[] fos = new MyFileObject[] { new MyFileObject(sourceFile) };

    JavacTask task = (JavacTask) compiler.getTask(null, null, null, null, null, Arrays.asList(fos));
    Iterable<? extends CompilationUnitTree> asts = task.parse();
    TreePathScanner scanner;

    final LinkedList<ClassFinder> scopeStack = new LinkedList<>();
    scanner = new TreePathScanner() {

        String packageName;
        ClassNode superClass;
        LinkedList<String> stack = new LinkedList<>();
        LinkedList<ClassInfo> classInfoStack = new LinkedList<>();
        LinkedList<ClassWriter> cwStack = new LinkedList<>();
        LinkedList<List<? extends TypeParameterTree>> typeParametersStack = new LinkedList<>();

        @Override
        public Object visitCompilationUnit(CompilationUnitTree cut, Object p) {

            packageName = cut.getPackageName().toString();
            ClassFinder scope = new ClassFinder(context.get(ClassLoader.class), null);
            scopeStack.push(scope);
            scope.addImport(packageName + ".*");
            return super.visitCompilationUnit(cut, p);
        }

        private String getThisInternalName(String simpleName) {
            simpleName = simpleName.replaceAll("\\.", "$");
            StringBuilder sb = new StringBuilder();
            Iterator<String> it = stack.descendingIterator();
            sb.append(packageName.replaceAll("\\.", "/"));
            sb.append("/");

            while (it.hasNext()) {
                sb.append(it.next()).append("$");
            }
            sb.append(simpleName);
            return sb.toString();
        }

        @Override
        public Object visitImport(ImportTree it, Object p) {
            if (!it.isStatic()) {
                String path = it.getQualifiedIdentifier().toString();
                scopeStack.peek().addImport(path);
            }
            return super.visitImport(it, p);
        }

        Object visitConstructor(final MethodTree mt, Object p) {
            ClassWriter classWriter = cwStack.peek();
            List<Type> argTypes = new ArrayList<Type>();
            boolean isVarArgs = false;
            for (VariableTree v : mt.getParameters()) {

                if (v.toString().endsWith("... " + v.getName())) {
                    isVarArgs = true;
                }
                String type = v.getType().toString();
                String fullType = type;
                String signature = null;
                try {
                    signature = TypeUtil.getTypeSignature(type, scopeStack.peek());
                } catch (Throwable t) {
                    System.out.println("Failed to find signature for type");
                }
                if (type.indexOf("<") != -1) {
                    type = type.substring(0, type.indexOf("<"));
                }
                int dim = 0;
                if (TypeUtil.isArrayType(type)) {
                    dim = TypeUtil.getArrayTypeDimension(type);
                    type = TypeUtil.getArrayElementType(type);
                }
                if (TypeUtil.isPrimitiveType(type)) {
                    String descriptor = TypeUtil.getDescriptor(type);
                    argTypes.add(Type.getType(TypeUtil.getArrayDescriptor(descriptor, dim)));
                } else {
                    ClassNode stub = scopeStack.peek().findStub(type);
                    assert stub != null;
                    argTypes.add(Type.getObjectType(stub.name));
                }

            }

            String methodDescriptor = null;
            String methodSignature = null;
            if (argTypes.isEmpty()) {
                methodDescriptor = Type.getMethodDescriptor(Type.getType("V"));
            } else {
                methodDescriptor = Type.getMethodDescriptor(Type.getType("V"), argTypes.toArray(new Type[0]));

            }

            int flags = getFlags(mt.getModifiers().getFlags());
            if (isVarArgs) {
                flags |= Opcodes.ACC_VARARGS;

            }
            classWriter.visitMethod(flags, mt.getName().toString(), methodDescriptor, null, null);
            classInfoStack.peek().numConstructors++;
            return null;
        }

        @Override
        public Object visitMethod(MethodTree mt, Object p) {
            if (mt.getReturnType() == null) {
                // It's a constructor
                return visitConstructor(mt, p);
            } else {
                boolean isVarArgs = false;
                ClassWriter classWriter = cwStack.peek();

                List<Type> argTypes = new ArrayList<>();
                List<String> sigArgTypes = new ArrayList<>();
                for (VariableTree v : mt.getParameters()) {
                    String type = v.getType().toString();
                    if (v.toString().endsWith("... " + v.getName())) {
                        isVarArgs = true;
                    }
                    sigArgTypes.add(type);
                    int dim = 0;
                    if (TypeUtil.isArrayType(type)) {
                        dim = TypeUtil.getArrayTypeDimension(type);
                        type = TypeUtil.getArrayElementType(type);
                    }
                    if (TypeUtil.isPrimitiveType(type)) {
                        String descriptor = TypeUtil.getDescriptor(type);
                        argTypes.add(Type.getType(TypeUtil.getArrayDescriptor(descriptor, dim)));
                    } else {

                        if (isGenericType(type)) {
                            type = "Object";
                        }

                        int arrowPos = type.indexOf("<");
                        if (arrowPos != -1) {
                            type = type.substring(0, arrowPos);
                        }
                        ClassNode stub = scopeStack.peek().findStub(type);
                        if (stub == null) {
                            throw new RuntimeException("Could not find class for " + type);
                        }
                        Type argType = Type.getObjectType(stub.name);
                        argType = Type.getType(TypeUtil.getArrayDescriptor(argType.getInternalName(), dim));
                        argTypes.add(argType);
                    }

                }

                String returnType = mt.getReturnType().toString();
                if (isGenericType(returnType)) {
                    returnType = "Object";
                }

                String methodSignature = null;
                try {
                    methodSignature = TypeUtil.getMethodSignature(scopeStack.peek(), returnType,
                            sigArgTypes.toArray(new String[0]));
                } catch (Exception ex) {
                    System.out.println(
                            "Failed to get signature for method " + mt + " message: " + ex.getMessage());
                }
                int dim = 0;

                Type returnTypeType = null;
                if (TypeUtil.isArrayType(returnType)) {
                    dim = TypeUtil.getArrayTypeDimension(returnType);
                    returnType = TypeUtil.getArrayElementType(returnType);
                    if (isGenericType(returnType)) {
                        returnType = "Object";
                    }

                }
                if (TypeUtil.isPrimitiveType(returnType)) {
                    String descriptor = TypeUtil.getDescriptor(returnType);
                    returnTypeType = Type.getType(TypeUtil.getArrayDescriptor(descriptor, dim));

                } else {
                    int arrowPos = returnType.indexOf("<");
                    if (arrowPos != -1) {
                        returnType = returnType.substring(0, arrowPos);
                    }
                    ClassNode stub = scopeStack.peek().findStub(returnType);
                    if (stub == null) {
                        System.out.println("Type params is " + mt.getTypeParameters());
                        System.out.println("Type kind is " + mt.getReturnType().getKind());
                        throw new RuntimeException("Could not find class for " + returnType);
                    }

                    returnTypeType = Type.getObjectType(stub.name);
                    returnTypeType = Type
                            .getType(TypeUtil.getArrayDescriptor(returnTypeType.getInternalName(), dim));

                }

                String methodDescriptor = null;
                if (argTypes.isEmpty()) {
                    methodDescriptor = Type.getMethodDescriptor(returnTypeType);
                } else {
                    methodDescriptor = Type.getMethodDescriptor(returnTypeType, argTypes.toArray(new Type[0]));
                }

                int flags = getFlags(mt.getModifiers().getFlags());
                if (isVarArgs) {
                    flags |= Opcodes.ACC_VARARGS;
                    //System.out.println("VarArgs "+flags);
                }
                classWriter.visitMethod(flags, mt.getName().toString(), methodDescriptor, methodSignature,
                        null);

            }
            //methodStack.push(mt);
            //Object out= super.visitMethod(mt, p); 
            //methodStack.pop();
            return null;
        }

        //private boolean LinkedList<MethodTree> methodStack  =new LinkedList<>();
        @Override
        public Object visitVariable(VariableTree vt, Object p) {

            ClassWriter classWriter = cwStack.peek();

            String varType = vt.getType().toString();
            if (isGenericType(varType)) {
                varType = "Object";
            }
            String signature = null;
            try {
                signature = TypeUtil.getTypeSignature(varType, scopeStack.peek());
            } catch (Exception ex) {
                System.out.println("Failed to generate signature for type " + varType);
            }
            int dim = 0;

            Type varTypeType = null;
            if (TypeUtil.isArrayType(varType)) {
                dim = TypeUtil.getArrayTypeDimension(varType);
                varType = TypeUtil.getArrayElementType(varType);

            }
            if (TypeUtil.isPrimitiveType(varType)) {
                String descriptor = TypeUtil.getDescriptor(varType);
                varTypeType = Type.getType(TypeUtil.getArrayDescriptor(descriptor, dim));

            } else {
                int arrowPos = varType.indexOf("<");
                if (arrowPos != -1) {
                    varType = varType.substring(0, arrowPos);
                }
                ClassNode stub = scopeStack.peek().findStub(varType);
                if (stub == null) {
                    throw new RuntimeException("Could not find class for " + varType);
                }

                varTypeType = Type.getObjectType(stub.name);
                varTypeType = Type.getType(TypeUtil.getArrayDescriptor(varTypeType.getInternalName(), dim));

            }

            classWriter.visitField(getFlags(vt.getModifiers().getFlags()), vt.getName().toString(),
                    varTypeType.toString(), signature, null);

            return super.visitVariable(vt, p); //To change body of generated methods, choose Tools | Templates.
        }

        boolean isGenericType(String type) {
            for (List<? extends TypeParameterTree> types : typeParametersStack) {
                for (TypeParameterTree tree : types) {
                    if (type.equals(tree.getName().toString())) {
                        return true;
                    }
                }
            }
            return false;
        }

        /**
         * Converts modifier flags from Javac Tree into int flags usable in 
         * TypeMirror
         * @param mods
         * @return 
         */
        int getFlags(Set<Modifier> mods) {
            int flags = 0;
            for (Modifier m : mods) {
                switch (m) {
                case ABSTRACT:
                    flags |= Opcodes.ACC_ABSTRACT;
                    break;
                case FINAL:
                    flags |= Opcodes.ACC_FINAL;
                    break;
                case PRIVATE:
                    flags |= Opcodes.ACC_PRIVATE;
                    break;
                case PROTECTED:
                    flags |= Opcodes.ACC_PROTECTED;
                    break;
                case PUBLIC:

                    flags |= Opcodes.ACC_PUBLIC;
                    break;
                case STATIC:
                    flags |= Opcodes.ACC_STATIC;
                    break;

                }
            }

            return flags;
        }

        @Override
        public Object visitClass(ClassTree ct, Object p) {
            //System.out.println("Visiting class "+ct);
            //System.out.println("Type parameters: "+ct.getTypeParameters());
            typeParametersStack.push(ct.getTypeParameters());
            String simpleName = ct.getSimpleName().toString();
            String internalName = getThisInternalName(simpleName);
            int lastDollar = internalName.lastIndexOf("$");
            String externalName = lastDollar == -1 ? null : internalName.substring(0, lastDollar);
            String supername = "java.lang.Object";
            String[] interfaces = null;
            boolean targetClass = false;
            if (!cwStack.isEmpty()) {
                cwStack.peek().visitInnerClass(internalName, externalName, simpleName,
                        getFlags(ct.getModifiers().getFlags()));
            }

            targetClass = true;
            // This is the one that we'
            //String supername = "java.lang.Object";
            if (ct.getExtendsClause() != null) {
                supername = ct.getExtendsClause().toString().trim();
            }
            String unresolvedSuperName = supername;

            int bracketPos = supername.indexOf("<");
            supername = bracketPos == -1 ? supername : supername.substring(0, bracketPos);
            ClassNode node = scopeStack.peek().findStub(supername);
            if (node == null) {
                throw new RuntimeException("Could not find super stub " + supername);
            }
            supername = node.name;

            String impl = ct.getImplementsClause().toString();
            String[] unresolvedInterfaces = null;
            if (impl != null && !"".equals(impl)) {
                interfaces = impl.split(",");
                unresolvedInterfaces = new String[interfaces.length];
                for (int i = 0; i < interfaces.length; i++) {

                    String iface = interfaces[i];
                    unresolvedInterfaces[i] = interfaces[i];
                    iface = iface.trim();
                    ClassNode inode = scopeStack.peek().findStub(iface);
                    assert inode != null;
                    if (inode == null) {
                        throw new RuntimeException("Could not find stub for interface " + iface);
                    }
                    System.out.println("interface " + iface);
                    interfaces[i] = inode.name;
                }
            }
            String signature = TypeUtil.getClassSignature(scopeStack.peek(), null, unresolvedSuperName,
                    unresolvedInterfaces);
            int flags = getFlags(ct.getModifiers().getFlags());

            switch (ct.getKind()) {
            case INTERFACE:
                flags |= Opcodes.ACC_INTERFACE;
                break;

            case ENUM:
                flags |= Opcodes.ACC_ENUM;
                break;

            }

            ClassWriter classWriter = new ClassWriter(49);
            classWriter.visit(49, flags, internalName, signature, supername, interfaces

            );
            cwStack.push(classWriter);
            classInfoStack.push(new ClassInfo());
            stack.push(simpleName);
            ClassFinder scope = new ClassFinder(context.get(ClassLoader.class), scopeStack.peek());

            scope.addImport(internalName.replaceAll("/", ".").replaceAll("\\$", ".") + ".*"

            );
            scope.addImport(internalName.replaceAll("/", ".").replaceAll("\\$", "."));
            scope.addImport(supername.replaceAll("/", ".").replaceAll("\\$", ".") + ".*"

            );
            scope.addImport(supername.replaceAll("/", ".").replaceAll("\\$", "."));

            if (interfaces != null) {
                for (int i = 0; i < interfaces.length; i++) {
                    scope.addImport(interfaces[i].replaceAll("/", ".").replaceAll("\\$", ".") + ".*"

                    );
                    scope.addImport(interfaces[i].replaceAll("/", ".").replaceAll("\\$", "."));
                }
            }
            for (TypeParameterTree tpTree : ct.getTypeParameters()) {
                //System.out.println("Name: "+tpTree.getName());
                //System.out.println("Kind: "+tpTree.getKind().name());
                //System.out.println("Bounds: "+tpTree.getBounds());
                String bounds = (tpTree.getBounds() != null && !tpTree.getBounds().isEmpty())
                        ? tpTree.getBounds().get(0).toString()
                        : "java.lang.Object";
                scope.addTypeParameter(tpTree.getName().toString(), bounds);
            }
            scopeStack.push(scope);
            Object out = super.visitClass(ct, p);
            stack.pop();
            scopeStack.pop();
            ClassInfo classInfo = classInfoStack.pop();
            if (classInfo.numConstructors == 0) {
                // there are no declared constructors in this class 
                // we need to add a default constructor.
                cwStack.peek().visitMethod(Opcodes.ACC_PUBLIC, "<init>",
                        Type.getMethodDescriptor(Type.getType("V")), null, null);
                classInfo.numConstructors++;
            }

            if (targetClass) {
                byte[] bytes = cwStack.peek().toByteArray();
                outMap.put(internalName, bytes);
                cwStack.pop();
            }

            typeParametersStack.pop();

            return out;
        }

    };
    scanner.scan(asts, null);
    return outMap;
}

From source file:ca.weblite.asm.TypeUtil.java

/**
 * Converts modifier flags from Javac Tree into int flags usable in TypeMirror
 * @param mods//from  w w w  .java 2  s.c  o  m
 * @return 
 */
public static int getFlags(Set<Modifier> mods) {
    int flags = 0;
    for (Modifier m : mods) {
        switch (m) {
        case ABSTRACT:
            flags |= Opcodes.ACC_ABSTRACT;
            break;
        case FINAL:
            flags |= Opcodes.ACC_FINAL;
            break;
        case PRIVATE:
            flags |= Opcodes.ACC_PRIVATE;
            break;
        case PROTECTED:
            flags |= Opcodes.ACC_PROTECTED;
            break;
        case PUBLIC:

            flags |= Opcodes.ACC_PUBLIC;
            break;
        case STATIC:
            flags |= Opcodes.ACC_STATIC;
            break;

        }
    }

    return flags;
}