classfilereferenceinitializer.java

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

    public void visitSyntheticAttrInfo(ClassFile classFile, SyntheticAttrInfo syntheticAttrInfo) {}


    public void visitEnclosingMethodAttrInfo(ClassFile classFile, EnclosingMethodAttrInfo enclosingMethodAttrInfo)
    {
        String className = enclosingMethodAttrInfo.getClassName(classFile);

        // See if we can find the referenced class file.
        ClassFile referencedClassFile = findClass(className);

        if (referencedClassFile == null)
        {
            // We couldn't find the enclosing class.
            if (warn)
            {
                warningCount++;
                System.err.println("Warning: " +
                                   ClassUtil.externalClassName(classFile.getName()) +
                                   ": can't find enclosing class " +
                                   ClassUtil.externalClassName(className));
            }

            return;
        }

        // Make sure there is actually an enclosed method.
        if (enclosingMethodAttrInfo.u2nameAndTypeIndex == 0)
        {
            return;
        }

        String name = enclosingMethodAttrInfo.getName(classFile);
        String type = enclosingMethodAttrInfo.getType(classFile);

        // See if we can find the method in the referenced class.
        MethodInfo referencedMethodInfo = referencedClassFile.findMethod(name, type);

        if (referencedMethodInfo == null)
        {
            // We couldn't find the enclosing method.
            if (warn)
            {
                warningCount++;
                System.err.println("Warning: " +
                                   ClassUtil.externalClassName(classFile.getName()) +
                                   ": can't find enclosing method '" +
                                   ClassUtil.externalFullMethodDescription(className, 0, name, type) +
                                   "' in class " +
                                   ClassUtil.externalClassName(className));
            }

            return;
        }

        // Save the references.
        enclosingMethodAttrInfo.referencedClassFile  = referencedClassFile;
        enclosingMethodAttrInfo.referencedMethodInfo = referencedMethodInfo;
    }


    public void visitCodeAttrInfo(ClassFile classFile, MethodInfo methodInfo, CodeAttrInfo codeAttrInfo)
    {
        codeAttrInfo.instructionsAccept(classFile, methodInfo, classFileClassForNameReferenceInitializer);
    }


    public void visitSignatureAttrInfo(ClassFile classFile, SignatureAttrInfo signatureAttrInfo)
    {
        signatureAttrInfo.referencedClassFiles =
            findReferencedClasses(classFile.getCpString(signatureAttrInfo.u2signatureIndex));
    }


    public void visitRuntimeVisibleAnnotationAttrInfo(ClassFile classFile, RuntimeVisibleAnnotationsAttrInfo runtimeVisibleAnnotationsAttrInfo)
    {
        // Initialize the annotations.
        runtimeVisibleAnnotationsAttrInfo.annotationsAccept(classFile, this);
    }


    public void visitRuntimeInvisibleAnnotationAttrInfo(ClassFile classFile, RuntimeInvisibleAnnotationsAttrInfo runtimeInvisibleAnnotationsAttrInfo)
    {
        // Initialize the annotations.
        runtimeInvisibleAnnotationsAttrInfo.annotationsAccept(classFile, this);
    }


    public void visitRuntimeVisibleParameterAnnotationAttrInfo(ClassFile classFile, RuntimeVisibleParameterAnnotationsAttrInfo runtimeVisibleParameterAnnotationsAttrInfo)
    {
        // Initialize the annotations.
        runtimeVisibleParameterAnnotationsAttrInfo.annotationsAccept(classFile, this);
    }


    public void visitRuntimeInvisibleParameterAnnotationAttrInfo(ClassFile classFile, RuntimeInvisibleParameterAnnotationsAttrInfo runtimeInvisibleParameterAnnotationsAttrInfo)
    {
        // Initialize the annotations.
        runtimeInvisibleParameterAnnotationsAttrInfo.annotationsAccept(classFile, this);
    }


    public void visitAnnotationDefaultAttrInfo(ClassFile classFile, AnnotationDefaultAttrInfo annotationDefaultAttrInfo)
    {
        // Initialize the annotation.
        annotationDefaultAttrInfo.defaultValueAccept(classFile, this);
    }


    // Implementations for LocalVariableInfoVisitor.

    public void visitLocalVariableInfo(ClassFile classFile, MethodInfo methodInfo, CodeAttrInfo codeAttrInfo, LocalVariableInfo localVariableInfo)
    {
        localVariableInfo.referencedClassFile =
            findClass(classFile.getCpString(localVariableInfo.u2descriptorIndex));
    }


    // Implementations for LocalVariableTypeInfoVisitor.

    public void visitLocalVariableTypeInfo(ClassFile classFile, MethodInfo methodInfo, CodeAttrInfo codeAttrInfo, LocalVariableTypeInfo localVariableTypeInfo)
    {
        localVariableTypeInfo.referencedClassFiles =
            findReferencedClasses(classFile.getCpString(localVariableTypeInfo.u2signatureIndex));
    }


    // Implementations for AnnotationVisitor.

    public void visitAnnotation(ClassFile classFile, Annotation annotation)
    {
        annotation.referencedClassFiles =
            findReferencedClasses(classFile.getCpString(annotation.u2typeIndex));

        // Initialize the element values.
        annotation.elementValuesAccept(classFile, this);
    }


    // Implementations for ElementValueVisitor.

    public void visitConstantElementValue(ClassFile classFile, Annotation annotation, ConstantElementValue constantElementValue)
    {
        initializeElementValue(classFile, annotation, constantElementValue);
    }


    public void visitEnumConstantElementValue(ClassFile classFile, Annotation annotation, EnumConstantElementValue enumConstantElementValue)
    {
        initializeElementValue(classFile, annotation, enumConstantElementValue);

        enumConstantElementValue.referencedClassFiles =
            findReferencedClasses(classFile.getCpString(enumConstantElementValue.u2typeNameIndex));
    }


    public void visitClassElementValue(ClassFile classFile, Annotation annotation, ClassElementValue classElementValue)
    {
        initializeElementValue(classFile, annotation, classElementValue);

        classElementValue.referencedClassFiles =
            findReferencedClasses(classFile.getCpString(classElementValue.u2classInfoIndex));
    }


    public void visitAnnotationElementValue(ClassFile classFile, Annotation annotation, AnnotationElementValue annotationElementValue)
    {
        initializeElementValue(classFile, annotation, annotationElementValue);

        // Initialize the annotation.
        annotationElementValue.annotationAccept(classFile, this);
    }


    public void visitArrayElementValue(ClassFile classFile, Annotation annotation, ArrayElementValue arrayElementValue)
    {
        initializeElementValue(classFile, annotation, arrayElementValue);

        // Initialize the element values.
        arrayElementValue.elementValuesAccept(classFile, annotation, this);
    }


    /**
     * Initializes the referenced method of an element value, if any.
     */
    private void initializeElementValue(ClassFile classFile, Annotation annotation, ElementValue elementValue)
    {
        // See if we have a referenced class file.
        if (annotation                      != null &&
            annotation.referencedClassFiles != null &&
            elementValue.u2elementName      != 0)
        {
            // See if we can find the method in the referenced class
            // (ignoring the descriptor).
            String name = classFile.getCpString(elementValue.u2elementName);
            
            elementValue.referencedMethodInfo =
                annotation.referencedClassFiles[0].findMethod(name, null);
        }
    }


    // Small utility methods.

    /**
     * Returns an array of class files referenced by the given descriptor, or
     * <code>null</code> if there aren't any useful references.
     */
    private ClassFile[] findReferencedClasses(String descriptor)
    {
        DescriptorClassEnumeration enumeration =
            new DescriptorClassEnumeration(descriptor);

        int classCount = enumeration.classCount();
        if (classCount > 0)
        {
            ClassFile[] referencedClassFiles = new ClassFile[classCount];

            boolean foundReferencedClassFiles = false;

            for (int index = 0; index < classCount; index++)
            {
                String name = enumeration.nextClassName();

                ClassFile referencedClassFile = findClass(name);

                if (referencedClassFile != null)
                {
                    referencedClassFiles[index] = referencedClassFile;
                    foundReferencedClassFiles = true;
                }
            }

            if (foundReferencedClassFiles)
            {
                return referencedClassFiles;
            }
        }

        return null;
    }


    /**
     * Returns the class with the given name, either for the program class pool
     * or from the library class pool, or <code>null</code> if it can't be found.
     */
    private ClassFile findClass(String name)
    {
        // First look for the class in the program class pool.
        ClassFile classFile = programClassPool.getClass(name);

        // Otherwise look for the class in the library class pool.
        if (classFile == null)
        {
            classFile = libraryClassPool.getClass(name);
        }

        return classFile;
    }
}