programclassfile.java

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

    // Implementations for ClassFile.

    public int getAccessFlags()
    {
        return u2accessFlags;
    }

    public String getName()
    {
        return getCpClassNameString(u2thisClass);
    }

    public String getSuperName()
    {
        return u2superClass == 0 ? null : getCpClassNameString(u2superClass);
    }

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

    public int getCpTag(int cpIndex)
    {
        return constantPool[cpIndex].getTag();
    }

    public String getCpString(int cpIndex)
    {
        return ((Utf8CpInfo)constantPool[cpIndex]).getString();
    }

    public String getCpClassNameString(int cpIndex)
    {
        ClassCpInfo classEntry = (ClassCpInfo)constantPool[cpIndex];
        Utf8CpInfo  nameEntry  = (Utf8CpInfo)constantPool[classEntry.getNameIndex()];

        return nameEntry.getString();
    }

    public String getCpNameString(int cpIndex)
    {
        return ((NameAndTypeCpInfo)constantPool[cpIndex]).getName(this);
    }

    public String getCpTypeString(int cpIndex)
    {
        return ((NameAndTypeCpInfo)constantPool[cpIndex]).getType(this);
    }


    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 u2superClass != 0 ?
            ((ClassCpInfo)constantPool[u2superClass]).referencedClassFile :
            null;
    }


    public ClassFile getInterface(int index)
    {
        return ((ClassCpInfo)constantPool[u2interfaces[index]]).referencedClassFile;
    }


    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;
        }

        for (int i = 0; i < u2interfacesCount; i++)
        {
            ClassFile interfaceClass = getInterface(i);
            if (interfaceClass != null &&
                interfaceClass.implements_(classFile))
            {
                return true;
            }
        }

        return false;
    }


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


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


    public void accept(ClassFileVisitor classFileVisitor)
    {
        classFileVisitor.visitProgramClassFile(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)
        {
            ClassFile superClass = getSuperClass();
            if (superClass != null)
            {
                superClass.hierarchyAccept(true,
                                           true,
                                           visitInterfaces,
                                           false,
                                           classFileVisitor);
            }
        }

        // Then visit its interfaces, recursively.
        if (visitInterfaces)
        {
            for (int i = 0; i < u2interfacesCount; 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)
    {
        for (int i = 1; i < u2constantPoolCount; i++)
        {
            if (constantPool[i] != null)
            {
                constantPool[i].accept(this, cpInfoVisitor);
            }
        }
    }

    public void constantPoolEntryAccept(int index, CpInfoVisitor cpInfoVisitor)
    {
        constantPool[index].accept(this, cpInfoVisitor);
    }

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

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

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

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

    public void attributesAccept(AttrInfoVisitor attrInfoVisitor)
    {
        for (int i = 0; i < u2attributesCount; i++)
        {
            attributes[i].accept(this, attrInfoVisitor);
        }
    }


    // Implementations for VisitorAccepter.

    public Object getVisitorInfo()
    {
        return visitorInfo;
    }

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