classfileprinter.java

出色的混淆器

    {
        println(visitorInfo(programMemberInfo) + " " +
                programClassFile.getCpString(programMemberInfo.u2nameIndex) + " " +
                programClassFile.getCpString(programMemberInfo.u2descriptorIndex));

        if (programMemberInfo.u2attributesCount > 0)
        {
            indent();
            println("Class member attributes (count = " + programMemberInfo.u2attributesCount + "):");
            programMemberInfo.attributesAccept(programClassFile, this);
            outdent();
        }
    }


    public void visitLibraryFieldInfo(LibraryClassFile libraryClassFile, LibraryFieldInfo libraryFieldInfo)
    {
        visitLibraryMemberInfo(libraryClassFile, libraryFieldInfo);
    }


    public void visitLibraryMethodInfo(LibraryClassFile libraryClassFile, LibraryMethodInfo libraryMethodInfo)
    {
        visitLibraryMemberInfo(libraryClassFile, libraryMethodInfo);
    }


    private void visitLibraryMemberInfo(LibraryClassFile libraryClassFile, LibraryMemberInfo libraryMemberInfo)
    {
        println(visitorInfo(libraryMemberInfo) + " " +
                libraryMemberInfo.getName(libraryClassFile) + " " +
                libraryMemberInfo.getDescriptor(libraryClassFile));
    }


    // Implementations for AttrInfoVisitor
    // Note that attributes are typically only referenced once, so we don't
    // test if they are marked already.

    public void visitUnknownAttrInfo(ClassFile classFile, UnknownAttrInfo unknownAttrInfo)
    {
        // Just ignore unknown attributes.
    }


    public void visitInnerClassesAttrInfo(ClassFile classFile, InnerClassesAttrInfo innerClassesAttrInfo)
    {
        println(visitorInfo(innerClassesAttrInfo) +
                " Inner classes attribute (count = " + innerClassesAttrInfo.u2numberOfClasses + ")");

        indent();
        innerClassesAttrInfo.innerClassEntriesAccept(classFile, this);
        outdent();
    }


    public void visitConstantValueAttrInfo(ClassFile classFile, ConstantValueAttrInfo constantValueAttrInfo)
    {
        println(visitorInfo(constantValueAttrInfo) +
                " Constant value attribute:");

        classFile.constantPoolEntryAccept(this, constantValueAttrInfo.u2constantValueIndex);
    }


    public void visitExceptionsAttrInfo(ClassFile classFile, ExceptionsAttrInfo exceptionsAttrInfo)
    {
        println(visitorInfo(exceptionsAttrInfo) +
                " Exceptions attribute (count = " + exceptionsAttrInfo.u2numberOfExceptions + ")");

        indent();
        exceptionsAttrInfo.exceptionEntriesAccept((ProgramClassFile)classFile, this);
        outdent();
    }


    public void visitCodeAttrInfo(ClassFile classFile, CodeAttrInfo codeAttrInfo)
    {
        println(visitorInfo(codeAttrInfo) +
                " Code attribute instructions (code length = "+
                codeAttrInfo.u4codeLength + "):");

        indent();
        indent();
        codeAttrInfo.instructionsAccept(classFile, this);
        outdent();

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

        indent();
        codeAttrInfo.exceptionsAccept(classFile, this);
        outdent();

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

        indent();
        codeAttrInfo.attributesAccept(classFile, this);
        outdent();
        outdent();
    }


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


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


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

        indent();
        classFile.constantPoolEntryAccept(this, sourceFileAttrInfo.u2sourceFileIndex);
        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");
    }


    // Implementations for InstructionVisitor

    public void visitInstruction(ClassFile classFile, Instruction instruction)
    {
        // Just ignore generic instructions.
    }


    public void visitCpInstruction(ClassFile classFile, CpInstruction cpInstruction)
    {
        Instruction in = (Instruction)cpInstruction;
        println("- CpInstruction ["+in.getOpcode()+
                "] at offset ["+in.getOffset()+
                "], wide = ["+in.isWide()+
                "], CpIndex = ["+cpInstruction.getCpIndex()+
                "]");
        //println("      - CpInstruction [" +
        //           cpInstruction.getCpIndex() + "]");
        indent();
        classFile.constantPoolEntryAccept(this, cpInstruction.getCpIndex());
        outdent();
    }


    // Implementations for ExceptionInfoVisitor

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

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


    // Implementations for InnerClassesInfoVisitor

    public void visitInnerClassesInfo(ClassFile classFile, InnerClassesInfo innerClassesInfo)
    {
        println(visitorInfo(innerClassesInfo) +
                " InnerClassesInfo:");
        indent();
        if (innerClassesInfo.u2innerClassInfoIndex != 0)
        {
            classFile.constantPoolEntryAccept(this, innerClassesInfo.u2innerClassInfoIndex);
        }

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

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


    // 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 ? "-" : "+";
    }
}