libraryclassfile.java

j2me 混淆包,用于混淆j2me的原代码用的

        }

        return null;
    }


    /**
     * Returns the method with the given name and descriptor.
     */
    private LibraryMethodInfo findLibraryMethod(String name, String descriptor)
    {
        for (int i = 0; i < methods.length; i++)
        {
            LibraryMethodInfo method = methods[i];
            if (method != null &&
                (name       == null || method.getName(this).equals(name)) &&
                (descriptor == null || method.getDescriptor(this).equals(descriptor)))
            {
                return method;
            }
        }

        return null;
    }


    // Implementations for ClassFile.

    public int getAccessFlags()
    {
        return u2accessFlags;
    }

    public String getName()
    {
        return thisClassName;
    }

    public String getSuperName()
    {
        // This may be java/lang/Object, in which case there is no super.
        return superClassName;
    }

    public String getInterfaceName(int index)
    {
        return interfaceNames[index];
    }

    public int getCpTag(int cpIndex)
    {
        return -1;
    }

    public String getCpString(int cpIndex)
    {
        return null;
    }

    public String getCpClassNameString(int cpIndex)
    {
        return null;
    }

    public String getCpNameString(int cpIndex)
    {
        return null;
    }

    public String getCpTypeString(int cpIndex)
    {
        return null;
    }


    public void addSubClass(ClassFile classFile)
    {
        if (subClasses == null)
        {
            subClasses = new ClassFile[1];
        }
        else
        {
            // Copy the old elements into new larger array.
            ClassFile[] temp = new ClassFile[subClasses.length+1];
            System.arraycopy(subClasses, 0, temp, 0, subClasses.length);
            subClasses = temp;
        }

        subClasses[subClasses.length-1] = classFile;
    }


    public ClassFile getSuperClass()
    {
        return superClass;
    }


    public ClassFile getInterface(int index)
    {
        return interfaceClasses[index];
    }


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

        ClassFile superClass = getSuperClass();
        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 = getInterface(i);
                if (interfaceClass != null &&
                    interfaceClass.implements_(classFile))
                {
                    return true;
                }
            }
        }

        return false;
    }


    public FieldInfo findField(String name, String descriptor)
    {
        return findLibraryField(name, descriptor);
    }


    public MethodInfo findMethod(String name, String descriptor)
    {
        return findLibraryMethod(name, descriptor);
    }


    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 = getInterface(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)
    {
        LibraryMemberInfo libraryMemberInfo = findLibraryField(name, descriptor);
        if (libraryMemberInfo != null)
        {
            libraryMemberInfo.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)
    {
        LibraryMemberInfo libraryMemberInfo = findLibraryMethod(name, descriptor);
        if (libraryMemberInfo != null)
        {
            libraryMemberInfo.accept(this, 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;
    }
}