libraryclassfile.java

proguard 3.5 java 混淆器 最新 免费 好用的 大家用用试一下吧 天行健-君子以自强不息 地势坤-君子以厚德载物

        return superClass != null &&
               superClass.extends_(classFile);
    }


    public boolean implements_(ClassFile classFile)
    {
        if (this.equals(classFile))
        {
            return true;
        }

        if (interfaceClasses != null)
        {
            for (int i = 0; i < interfaceClasses.length; i++)
            {
                ClassFile interfaceClass = interfaceClasses[i];
                if (interfaceClass != null &&
                    interfaceClass.implements_(classFile))
                {
                    return true;
                }
            }
        }

        return false;
    }


    public FieldInfo findField(String name, String descriptor)
    {
        for (int i = 0; i < fields.length; i++)
        {
            FieldInfo field = fields[i];
            if (field != null &&
                (name       == null || field.getName(this).equals(name)) &&
                (descriptor == null || field.getDescriptor(this).equals(descriptor)))
            {
                return field;
            }
        }

        return null;
    }


    public MethodInfo findMethod(String name, String descriptor)
    {
        for (int i = 0; i < methods.length; i++)
        {
            MethodInfo method = methods[i];
            if (method != null &&
                (name       == null || method.getName(this).equals(name)) &&
                (descriptor == null || method.getDescriptor(this).equals(descriptor)))
            {
                return method;
            }
        }

        return null;
    }


    public void accept(ClassFileVisitor classFileVisitor)
    {
        classFileVisitor.visitLibraryClassFile(this);
    }


    public void hierarchyAccept(boolean          visitThisClass,
                                boolean          visitSuperClass,
                                boolean          visitInterfaces,
                                boolean          visitSubclasses,
                                ClassFileVisitor classFileVisitor)
    {
        // First visit the current classfile.
        if (visitThisClass)
        {
            accept(classFileVisitor);
        }

        // Then visit its superclass, recursively.
        if (visitSuperClass)
        {
            if (superClass != null)
            {
                superClass.hierarchyAccept(true,
                                           true,
                                           visitInterfaces,
                                           false,
                                           classFileVisitor);
            }
        }

        // Then visit its interfaces, recursively.
        if (visitInterfaces)
        {
            if (interfaceClasses != null)
            {
                for (int i = 0; i < interfaceClasses.length; i++)
                {
                    ClassFile interfaceClass = interfaceClasses[i];
                    if (interfaceClass != null)
                    {
                        interfaceClass.hierarchyAccept(true,
                                                       true,
                                                       true,
                                                       false,
                                                       classFileVisitor);
                    }
                }
            }
        }

        // Then visit its subclasses, recursively.
        if (visitSubclasses)
        {
            if (subClasses != null)
            {
                for (int i = 0; i < subClasses.length; i++)
                {
                    ClassFile subClass = subClasses[i];
                    subClass.hierarchyAccept(true,
                                             false,
                                             false,
                                             true,
                                             classFileVisitor);
                }
            }
        }
    }


    public void constantPoolEntriesAccept(CpInfoVisitor cpInfoVisitor)
    {
        // This class doesn't keep references to its constant pool entries.
    }


    public void constantPoolEntryAccept(int index, CpInfoVisitor cpInfoVisitor)
    {
        // This class doesn't keep references to its constant pool entries.
    }


    public void fieldsAccept(MemberInfoVisitor memberInfoVisitor)
    {
        for (int i = 0; i < fields.length; i++)
        {
            if (fields[i] != null)
            {
                fields[i].accept(this, memberInfoVisitor);
            }
        }
    }


    public void fieldAccept(String name, String descriptor, MemberInfoVisitor memberInfoVisitor)
    {
        FieldInfo field = findField(name, descriptor);
        if (field != null)
        {
            field.accept(this, memberInfoVisitor);
        }
    }


    public void methodsAccept(MemberInfoVisitor memberInfoVisitor)
    {
        for (int i = 0; i < methods.length; i++)
        {
            if (methods[i] != null)
            {
                methods[i].accept(this, memberInfoVisitor);
            }
        }
    }


    public void methodAccept(String name, String descriptor, MemberInfoVisitor memberInfoVisitor)
    {
        MethodInfo method = findMethod(name, descriptor);
        if (method != null)
        {
            method.accept(this, memberInfoVisitor);
        }
    }


    public boolean mayHaveImplementations(MethodInfo methodInfo)
    {
        return
           (u2accessFlags & ClassConstants.INTERNAL_ACC_FINAL) == 0 &&
           (methodInfo == null ||
            ((methodInfo.getAccessFlags() & (ClassConstants.INTERNAL_ACC_PRIVATE |
                                             ClassConstants.INTERNAL_ACC_STATIC  |
                                             ClassConstants.INTERNAL_ACC_FINAL)) == 0 &&
             !methodInfo.getName(this).equals(ClassConstants.INTERNAL_METHOD_NAME_INIT)));
    }


    private boolean isSpecial(MethodInfo methodInfo)
    {
        return
            (methodInfo.getAccessFlags() & (ClassConstants.INTERNAL_ACC_PRIVATE |
                                            ClassConstants.INTERNAL_ACC_STATIC)) != 0 ||
            methodInfo.getName(this).equals(ClassConstants.INTERNAL_METHOD_NAME_INIT);
    }


    public void methodImplementationsAccept(MethodInfo        methodInfo,
                                            boolean           visitThisMethod,
                                            MemberInfoVisitor memberInfoVisitor)
    {
        methodImplementationsAccept(methodInfo.getName(this),
                                    methodInfo.getDescriptor(this),
                                    methodInfo,
                                    visitThisMethod,
                                    true,
                                    true,
                                    true,
                                    memberInfoVisitor);
    }


    public void methodImplementationsAccept(String            name,
                                            String            descriptor,
                                            boolean           visitThisMethod,
                                            MemberInfoVisitor memberInfoVisitor)
    {
        methodImplementationsAccept(name,
                                    descriptor,
                                    visitThisMethod,
                                    true,
                                    true,
                                    true,
                                    memberInfoVisitor);
    }


    public void methodImplementationsAccept(String            name,
                                            String            descriptor,
                                            boolean           visitThisMethod,
                                            boolean           visitSpecialMethods,
                                            boolean           visitSuperMethods,
                                            boolean           visitOverridingMethods,
                                            MemberInfoVisitor memberInfoVisitor)
    {
        methodImplementationsAccept(name,
                                    descriptor,
                                    findMethod(name, descriptor),
                                    visitThisMethod,
                                    visitSpecialMethods,
                                    visitSuperMethods,
                                    visitOverridingMethods,
                                    memberInfoVisitor);
    }


    public void methodImplementationsAccept(String            name,
                                            String            descriptor,
                                            MethodInfo        methodInfo,
                                            boolean           visitThisMethod,
                                            boolean           visitSpecialMethods,
                                            boolean           visitSuperMethods,
                                            boolean           visitOverridingMethods,
                                            MemberInfoVisitor memberInfoVisitor)
    {
        // Do we have the method in this class?
        if (methodInfo != null)
        {
            // Is it a special method?
            if (isSpecial(methodInfo))
            {
                // Visit the special method in this class, if allowed.
                if (visitSpecialMethods)
                {
                    methodInfo.accept(this, memberInfoVisitor);

                    // The method can't have any other implementations.
                    return;
                }
            }
            else
            {
                // Visit the method in this class, if allowed.
                if (visitThisMethod)
                {
                    methodInfo.accept(this, memberInfoVisitor);
                }

                // We don't have to look in subclasses if there can't be
                // any overriding implementations.
                if (!mayHaveImplementations(methodInfo))
                {
                    visitOverridingMethods = false;
                }

                // We don't have to look in superclasses if we have a concrete
                // implementation here.
                if ((methodInfo.getAccessFlags() & ClassConstants.INTERNAL_ACC_ABSTRACT) == 0)
                {
                    visitSuperMethods = false;
                }
            }
        }

        // Then visit the method in its subclasses, recursively.
        if (visitOverridingMethods)
        {
            // Go looking for implementations in all of the subclasses.
            if (subClasses != null)
            {
                for (int i = 0; i < subClasses.length; i++)
                {
                    ClassFile subClass = subClasses[i];
                    subClass.methodImplementationsAccept(name,
                                                         descriptor,
                                                         true,
                                                         false,
                                                         visitSuperMethods,
                                                         true,
                                                         memberInfoVisitor);
                }
            }

            // We don't have to look in superclasses right away if we dont't
            // have a concrete class here.
            if ((u2accessFlags & (ClassConstants.INTERNAL_ACC_INTERFACE |
                                  ClassConstants.INTERNAL_ACC_ABSTRACT)) != 0)
            {
                visitSuperMethods = false;
            }
        }

        // Then visit the method in its superclass, recursively.
        if (visitSuperMethods)
        {
            ClassFile superClass = getSuperClass();
            if (superClass != null)
            {
                superClass.methodImplementationsAccept(name,
                                                       descriptor,
                                                       true,
                                                       false,
                                                       true,
                                                       false,
                                                       memberInfoVisitor);
            }
        }
    }


    public void attributesAccept(AttrInfoVisitor attrInfoVisitor)
    {
        // This class doesn't keep references to its attributes.
    }


    // Implementations for VisitorAccepter.

    public Object getVisitorInfo()
    {
        return visitorInfo;
    }

    public void setVisitorInfo(Object visitorInfo)
    {
        this.visitorInfo = visitorInfo;
    }
}