Java example source code file (ClassDump.java)

This example Java source code file (ClassDump.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

bad, chararraywriter, classdump, classreaderwriter, code, error, index, ioexception, length, method, printwriter, runtimeconstants, string, table, util

The ClassDump.java Java example source code

/*
 * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package ilib;

import java.io.IOException;
import java.io.File;
import java.io.FileOutputStream;
import java.io.DataOutputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.CharArrayWriter;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

public class ClassDump implements RuntimeConstants {

  public static void dump(Options opt,
                                       ClassLoader loader,
                                       String className,
                                       byte[] classfileBuffer) {
    ClassReaderWriter c = new ClassReaderWriter(classfileBuffer);
    (new ClassDump(className, c)).doit();
  }

    static boolean verbose = true;

    final String className;
    final ClassReaderWriter c;
    private final PrintStream output;

    int constantPoolCount;
    int methodsCount;

    ClassDump(String className, ClassReaderWriter c) {
        this.className = className;
        this.c = c;
        this.output = System.err;
    }

    void doit() {
        int i;
        c.copy(4 + 2 + 2); // magic min/maj version
        constantPoolCount = c.copyU2();
        // copy old constant pool
        c.copyConstantPool(constantPoolCount);

        traceln("ConstantPool size: " + constantPoolCount);

        c.copy(2 + 2 + 2);  // access, this, super
        int interfaceCount = c.copyU2();
        traceln("interfaceCount: " + interfaceCount);
        c.copy(interfaceCount * 2);
        copyFields(); // fields
        copyMethods(); // methods
        int attrCount = c.copyU2();
        traceln("class attrCount: " + attrCount);
        // copy the class attributes
        copyAttrs(attrCount);
    }


    void copyFields() {
        int count = c.copyU2();
        if (verbose) {
            System.out.println("fields count: " + count);
        }
        for (int i = 0; i < count; ++i) {
            c.copy(6); // access, name, descriptor
            int attrCount = c.copyU2();
            if (verbose) {
                System.out.println("field attr count: " + attrCount);
            }
            copyAttrs(attrCount);
        }
    }

    void copyMethods() {
        methodsCount = c.copyU2();
        if (verbose) {
            System.out.println("methods count: " + methodsCount);
        }
        for (int i = 0; i < methodsCount; ++i) {
            copyMethod();
        }
    }

    void copyMethod() {
        int accessFlags = c.copyU2();// access flags
        int nameIndex = c.copyU2();  // name
        checkIndex(nameIndex, "Method name");
        String methodName = c.constantPoolString(nameIndex);
        traceln("method: " + methodName);
        int descriptorIndex = c.copyU2();                  // descriptor
        checkIndex(descriptorIndex, "Method descriptor");
        int attrCount = c.copyU2();  // attribute count
        if (verbose) {
            System.out.println("method attr count: " + attrCount);
        }
        for (int i = 0; i < attrCount; ++i) {
            copyAttrForMethod(methodName, accessFlags);
        }
    }

    void copyAttrs(int attrCount) {
        for (int i = 0; i < attrCount; ++i) {
            copyAttr();
        }
    }

    void copyAttr() {
        c.copy(2);             // name
        int len = c.copyU4();  // attr len
        if (verbose) {
            System.out.println("attr len: " + len);
        }
        c.copy(len);           // attribute info
    }

    void copyAttrForMethod(String methodName, int accessFlags) {
        int nameIndex = c.copyU2();   // name
        // check for Code attr
        checkIndex(nameIndex, "Method attr name");
        if (nameIndex == c.codeAttributeIndex) {
            try {
                copyCodeAttr(methodName);
            } catch (IOException exc) {
                System.err.println("Code Exception - " + exc);
                System.exit(1);
            }
        } else {
            int len = c.copyU4();     // attr len
            traceln("method attr len: " + len);
            c.copy(len);              // attribute info
        }
    }

    void copyAttrForCode() throws IOException {
        int nameIndex = c.copyU2();   // name

        checkIndex(nameIndex, "Code attr name");
        int len = c.copyU4();     // attr len
        traceln("code attr len: " + len);
        c.copy(len);              // attribute info
    }

    void copyCodeAttr(String methodName) throws IOException {
        traceln("Code attr found");
        int attrLength = c.copyU4();        // attr len
        checkLength(attrLength, "Code attr length");
        int maxStack = c.readU2();          // max stack
        c.copyU2();                         // max locals
        int codeLength = c.copyU4();        // code length
        checkLength(codeLength, "Code length");

        copyExceptionTable();

        int attrCount = c.copyU2();
        checkLength(attrCount, "Code attr count");
        for (int i = 0; i < attrCount; ++i) {
            copyAttrForCode();
        }
    }

    /**
     * Copy the exception table for this method code
     */
    void copyExceptionTable() throws IOException {
        int tableLength = c.copyU2();   // exception table len
        checkLength(tableLength, "Exception Table length");
        if (tableLength > 0) {
            traceln();
            traceln("Exception table:");
            traceln(" from:old/new  to:old/new target:old/new type");
            for (int tcnt = tableLength; tcnt > 0; --tcnt) {
                int startPC = c.readU2();
                int endPC = c.readU2();
                int handlerPC = c.readU2();
                int catchType = c.copyU2();
                if (verbose) {
                    traceFixedWidthInt(startPC, 6);
                    traceFixedWidthInt(endPC, 6);
                    traceFixedWidthInt(handlerPC, 6);
                    trace("    ");
                    if (catchType == 0)
                        traceln("any");
                    else {
                        traceln("" + catchType);
                    }
                }
            }
        }
    }

    private void checkIndex(int index, String comment) {
        if (index > constantPoolCount) {
            output.println("ERROR BAD INDEX " + comment + " : " + index);
        } else {
            traceln(comment + " : " + index);
        }
    }

    private void checkLength(int length, String comment) {
        if (length > c.inputBytes().length) {
            output.println("ERROR BAD LENGTH " + comment + " : " + length);
        } else {
            traceln(comment + " : " + length);
        }
    }

    private void trace(String str) {
        if (verbose) {
            output.print(str);
        }
    }

    private void traceln(String str) {
        if (verbose) {
            output.println(str);
        }
    }

    private void traceln() {
        if (verbose) {
            output.println();
        }
    }

    private void trace(int i) {
        if (verbose) {
            output.print(i);
        }
    }

    /**
     * Print an integer so that it takes 'length' characters in
     * the output.  Temporary until formatting code is stable.
     */
    private void traceFixedWidthInt(int x, int length) {
        if (verbose) {
            CharArrayWriter baStream = new CharArrayWriter();
            PrintWriter pStream = new PrintWriter(baStream);
            pStream.print(x);
            String str = baStream.toString();
            for (int cnt = length - str.length(); cnt > 0; --cnt)
                trace(" ");
            trace(str);
        }
    }


}