classfileprinter.java

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

                ", stack = "+ codeAttrInfo.u2maxStack + "):");

        indent();

        codeAttrInfo.instructionsAccept(classFile, methodInfo, this);

        println("Code attribute exceptions (count = " +
                codeAttrInfo.u2exceptionTableLength + "):");

        codeAttrInfo.exceptionsAccept(classFile, methodInfo, this);

        println("Code attribute attributes (attribute count = " +
                codeAttrInfo.u2attributesCount + "):");

        codeAttrInfo.attributesAccept(classFile, methodInfo, this);

        outdent();
    }


    public void visitLineNumberTableAttrInfo(ClassFile classFile, MethodInfo methodInfo, CodeAttrInfo codeAttrInfo, LineNumberTableAttrInfo lineNumberTableAttrInfo)
    {
        println(visitorInfo(lineNumberTableAttrInfo) +
                " Line number table attribute (count = " +
                lineNumberTableAttrInfo.u2lineNumberTableLength + ")");
        // ...
    }


    public void visitLocalVariableTableAttrInfo(ClassFile classFile, MethodInfo methodInfo, CodeAttrInfo codeAttrInfo, LocalVariableTableAttrInfo localVariableTableAttrInfo)
    {
        println(visitorInfo(localVariableTableAttrInfo) +
                " Local variable table attribute (count = " +
                localVariableTableAttrInfo.u2localVariableTableLength + ")");
        // ...
    }


    public void visitLocalVariableTypeTableAttrInfo(ClassFile classFile, MethodInfo methodInfo, CodeAttrInfo codeAttrInfo, LocalVariableTypeTableAttrInfo localVariableTypeTableAttrInfo)
    {
        println(visitorInfo(localVariableTypeTableAttrInfo) +
                " Local variable type table attribute (count = "+
                localVariableTypeTableAttrInfo.u2localVariableTypeTableLength + ")");
        // ...
    }


    public void visitSourceFileAttrInfo(ClassFile classFile, SourceFileAttrInfo sourceFileAttrInfo)
    {
        println(visitorInfo(sourceFileAttrInfo) +
                " Source file attribute:");

        indent();
        classFile.constantPoolEntryAccept(sourceFileAttrInfo.u2sourceFileIndex, this);
        outdent();
    }


    public void visitSourceDirAttrInfo(ClassFile classFile, SourceDirAttrInfo sourceDirAttrInfo)
    {
        println(visitorInfo(sourceDirAttrInfo) +
                " Source dir attribute:");

        indent();
        classFile.constantPoolEntryAccept(sourceDirAttrInfo.u2sourceDirIndex, this);
        outdent();
    }


    public void visitDeprecatedAttrInfo(ClassFile classFile, DeprecatedAttrInfo deprecatedAttrInfo)
    {
        println(visitorInfo(deprecatedAttrInfo) +
                " Deprecated attribute");
    }


    public void visitSyntheticAttrInfo(ClassFile classFile, SyntheticAttrInfo syntheticAttrInfo)
    {
        println(visitorInfo(syntheticAttrInfo) +
                " Synthetic attribute");
    }


    public void visitSignatureAttrInfo(ClassFile classFile, SignatureAttrInfo signatureAttrInfo)
    {
        println(visitorInfo(signatureAttrInfo) +
                " Signature attribute:");

        indent();
        classFile.constantPoolEntryAccept(signatureAttrInfo.u2signatureIndex, this);
        outdent();
    }


    public void visitRuntimeVisibleAnnotationAttrInfo(ClassFile classFile, RuntimeVisibleAnnotationsAttrInfo runtimeVisibleAnnotationsAttrInfo)
    {
        println(visitorInfo(runtimeVisibleAnnotationsAttrInfo) +
                " Runtime visible annotation attribute:");

        indent();
        runtimeVisibleAnnotationsAttrInfo.annotationsAccept(classFile, this);
        outdent();
    }


    public void visitRuntimeInvisibleAnnotationAttrInfo(ClassFile classFile, RuntimeInvisibleAnnotationsAttrInfo runtimeInvisibleAnnotationsAttrInfo)
    {
        println(visitorInfo(runtimeInvisibleAnnotationsAttrInfo) +
                " Runtime invisible annotation attribute:");

        indent();
        runtimeInvisibleAnnotationsAttrInfo.annotationsAccept(classFile, this);
        outdent();
    }


    public void visitRuntimeVisibleParameterAnnotationAttrInfo(ClassFile classFile, RuntimeVisibleParameterAnnotationsAttrInfo runtimeVisibleParameterAnnotationsAttrInfo)
    {
        println(visitorInfo(runtimeVisibleParameterAnnotationsAttrInfo) +
                " Runtime visible parameter annotation attribute:");

        indent();
        runtimeVisibleParameterAnnotationsAttrInfo.annotationsAccept(classFile, this);
        outdent();
    }


    public void visitRuntimeInvisibleParameterAnnotationAttrInfo(ClassFile classFile, RuntimeInvisibleParameterAnnotationsAttrInfo runtimeInvisibleParameterAnnotationsAttrInfo)
    {
        println(visitorInfo(runtimeInvisibleParameterAnnotationsAttrInfo) +
                " Runtime invisible parameter annotation attribute:");

        indent();
        runtimeInvisibleParameterAnnotationsAttrInfo.annotationsAccept(classFile, this);
        outdent();
    }


    public void visitAnnotationDefaultAttrInfo(ClassFile classFile, AnnotationDefaultAttrInfo annotationDefaultAttrInfo)
    {
        println(visitorInfo(annotationDefaultAttrInfo) +
                " Annotation default attribute:");

        indent();
        annotationDefaultAttrInfo.defaultValueAccept(classFile, this);
        outdent();
    }


    // Implementations for InnerClassesInfoVisitor.

    public void visitInnerClassesInfo(ClassFile classFile, InnerClassesInfo innerClassesInfo)
    {
        println(visitorInfo(innerClassesInfo) +
                " InnerClassesInfo:");

        indent();
        if (innerClassesInfo.u2innerClassInfoIndex != 0)
        {
            classFile.constantPoolEntryAccept(innerClassesInfo.u2innerClassInfoIndex, this);
        }

        if (innerClassesInfo.u2outerClassInfoIndex != 0)
        {
            classFile.constantPoolEntryAccept(innerClassesInfo.u2outerClassInfoIndex, this);
        }

        if (innerClassesInfo.u2innerNameIndex != 0)
        {
            classFile.constantPoolEntryAccept(innerClassesInfo.u2innerNameIndex, this);
        }
        outdent();
    }


    // Implementations for AnnotationVisitor.

    public void visitAnnotation(ClassFile classFile, Annotation annotation)
    {
        println(visitorInfo(annotation) +
                " Annotation [" + classFile.getCpString(annotation.u2typeIndex) + "]:");

        indent();
        annotation.elementValuesAccept(classFile, this);
        outdent();
    }


    // Implementations for ElementValueVisitor.

    public void visitConstantElementValue(ClassFile classFile, Annotation annotation, ConstantElementValue constantElementValue)
    {
        println(visitorInfo(constantElementValue) +
                " Constant element value [" +
                (constantElementValue.u2elementName == 0 ? "(default)" :
                classFile.getCpString(constantElementValue.u2elementName)) + "]");

        indent();
        classFile.constantPoolEntryAccept(constantElementValue.u2constantValueIndex, this);
        outdent();
    }


    public void visitEnumConstantElementValue(ClassFile classFile, Annotation annotation, EnumConstantElementValue enumConstantElementValue)
    {
        println(visitorInfo(enumConstantElementValue) +
                " Enum constant element value [" +
                (enumConstantElementValue.u2elementName == 0 ? "(default)" :
                classFile.getCpString(enumConstantElementValue.u2elementName)) + ", " +
                classFile.getCpString(enumConstantElementValue.u2typeNameIndex)  + ", " +
                classFile.getCpString(enumConstantElementValue.u2constantNameIndex) + "]");
    }


    public void visitClassElementValue(ClassFile classFile, Annotation annotation, ClassElementValue classElementValue)
    {
        println(visitorInfo(classElementValue) +
                " Class element value [" +
                (classElementValue.u2elementName == 0 ? "(default)" :
                classFile.getCpString(classElementValue.u2elementName)) + ", " +
                classFile.getCpString(classElementValue.u2classInfoIndex) + "]");
    }


    public void visitAnnotationElementValue(ClassFile classFile, Annotation annotation, AnnotationElementValue annotationElementValue)
    {
        println(visitorInfo(annotationElementValue) +
                " Annotation element value [" +
                (annotationElementValue.u2elementName == 0 ? "(default)" :
                classFile.getCpString(annotationElementValue.u2elementName)) + "]:");

        indent();
        annotationElementValue.annotationAccept(classFile, this);
        outdent();
    }


    public void visitArrayElementValue(ClassFile classFile, Annotation annotation, ArrayElementValue arrayElementValue)
    {
        println(visitorInfo(arrayElementValue) +
                " Array element value [" +
                (arrayElementValue.u2elementName == 0 ? "(default)" :
                classFile.getCpString(arrayElementValue.u2elementName)) + "]:");

        indent();
        arrayElementValue.elementValuesAccept(classFile, annotation, this);
        outdent();
    }


    // Implementations for InstructionVisitor.

    public void visitSimpleInstruction(ClassFile classFile, MethodInfo methodInfo, CodeAttrInfo codeAttrInfo, int offset, SimpleInstruction simpleInstruction)
    {
        println(InstructionFactory.create(codeAttrInfo.code, offset).toString(offset));
    }


    public void visitVariableInstruction(ClassFile classFile, MethodInfo methodInfo, CodeAttrInfo codeAttrInfo, int offset, VariableInstruction variableInstruction)
    {
        println(InstructionFactory.create(codeAttrInfo.code, offset).toString(offset));
    }


    public void visitCpInstruction(ClassFile classFile, MethodInfo methodInfo, CodeAttrInfo codeAttrInfo, int offset, CpInstruction cpInstruction)
    {
        println(InstructionFactory.create(codeAttrInfo.code, offset).toString(offset));

        indent();
        classFile.constantPoolEntryAccept(cpInstruction.cpIndex, this);
        outdent();
    }


    public void visitBranchInstruction(ClassFile classFile, MethodInfo methodInfo, CodeAttrInfo codeAttrInfo, int offset, BranchInstruction branchInstruction)
    {
        println(InstructionFactory.create(codeAttrInfo.code, offset).toString(offset));
    }

    public void visitTableSwitchInstruction(ClassFile classFile, MethodInfo methodInfo, CodeAttrInfo codeAttrInfo, int offset, TableSwitchInstruction tableSwitchInstruction)
    {
        println(InstructionFactory.create(codeAttrInfo.code, offset).toString(offset));
    }


    public void visitLookUpSwitchInstruction(ClassFile classFile, MethodInfo methodInfo, CodeAttrInfo codeAttrInfo, int offset, LookUpSwitchInstruction lookUpSwitchInstruction)
    {
        println(InstructionFactory.create(codeAttrInfo.code, offset).toString(offset));
    }


    // Implementations for ExceptionInfoVisitor.

    public void visitExceptionInfo(ClassFile classFile, MethodInfo methodInfo, CodeAttrInfo codeAttrInfo, ExceptionInfo exceptionInfo)
    {
        println(visitorInfo(exceptionInfo) +
                " ExceptionInfo:");

        if (exceptionInfo.u2catchType != 0)
        {
            classFile.constantPoolEntryAccept(exceptionInfo.u2catchType, this);
        }
    }


    // Small utility methods.

    private void indent()
    {
        indentation++;
    }

    private void outdent()
    {
        indentation--;
    }

    private void println()
    {
        ps.println();
    }

    private void println(String string)
    {
        for (int i = 0; i < indentation; i++)
        {
            ps.print(INDENTATION);
        }

        ps.println(string);
    }


    private String visitorInfo(VisitorAccepter visitorAccepter)
    {
        return visitorAccepter.getVisitorInfo() == null ? "-" : "+";
    }
}