ClassReader.java

/*
 * Copyright (c) 2010, 2013, 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.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * 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 xmlkit; // -*- mode: java; indent-tabs-mode: nil -*-

import com.sun.tools.classfile.AccessFlags;
import com.sun.tools.classfile.Annotation;
import com.sun.tools.classfile.Annotation.*;
import com.sun.tools.classfile.AnnotationDefault_attribute;
import com.sun.tools.classfile.Attribute;
import com.sun.tools.classfile.Attributes;
import com.sun.tools.classfile.BootstrapMethods_attribute;
import com.sun.tools.classfile.CharacterRangeTable_attribute;
import com.sun.tools.classfile.ClassFile;
import com.sun.tools.classfile.Code_attribute;
import com.sun.tools.classfile.CompilationID_attribute;
import com.sun.tools.classfile.ConstantPool;
import com.sun.tools.classfile.ConstantPool.*;
import com.sun.tools.classfile.ConstantPoolException;
import com.sun.tools.classfile.ConstantValue_attribute;
import com.sun.tools.classfile.DefaultAttribute;
import com.sun.tools.classfile.Deprecated_attribute;
import com.sun.tools.classfile.Descriptor.InvalidDescriptor;
import com.sun.tools.classfile.EnclosingMethod_attribute;
import com.sun.tools.classfile.Exceptions_attribute;
import com.sun.tools.classfile.Field;
import com.sun.tools.classfile.InnerClasses_attribute;
import com.sun.tools.classfile.InnerClasses_attribute.Info;
import com.sun.tools.classfile.Instruction;
import com.sun.tools.classfile.Instruction.TypeKind;
import com.sun.tools.classfile.LineNumberTable_attribute;
import com.sun.tools.classfile.LocalVariableTable_attribute;
import com.sun.tools.classfile.LocalVariableTypeTable_attribute;
import com.sun.tools.classfile.Method;
import com.sun.tools.classfile.MethodParameters_attribute;
import com.sun.tools.classfile.Opcode;
import com.sun.tools.classfile.RuntimeInvisibleAnnotations_attribute;
import com.sun.tools.classfile.RuntimeInvisibleParameterAnnotations_attribute;
import com.sun.tools.classfile.RuntimeInvisibleTypeAnnotations_attribute;
import com.sun.tools.classfile.RuntimeVisibleAnnotations_attribute;
import com.sun.tools.classfile.RuntimeVisibleParameterAnnotations_attribute;
import com.sun.tools.classfile.RuntimeVisibleTypeAnnotations_attribute;
import com.sun.tools.classfile.Signature_attribute;
import com.sun.tools.classfile.SourceDebugExtension_attribute;
import com.sun.tools.classfile.SourceFile_attribute;
import com.sun.tools.classfile.SourceID_attribute;
import com.sun.tools.classfile.StackMapTable_attribute;
import com.sun.tools.classfile.StackMapTable_attribute.*;
import com.sun.tools.classfile.StackMap_attribute;
import com.sun.tools.classfile.Synthetic_attribute;
import com.sun.tools.classfile.TypeAnnotation;
import com.sun.tools.classfile.TypeAnnotation.Position;
import static com.sun.tools.classfile.TypeAnnotation.TargetType.THROWS;
import java.util.*;
import java.io.*;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import xmlkit.XMLKit.Element;

/*
 * @author jrose, ksrini
 */
public class ClassReader {

    private static final CommandLineParser CLP = new CommandLineParser(""
            + "-source:     +> = \n"
            + "-dest:       +> = \n"
            + "-encoding:   +> = \n"
            + "-jcov           $ \n   -nojcov         !-jcov        \n"
            + "-verbose        $ \n   -noverbose      !-verbose     \n"
            + "-keepPath       $ \n   -nokeepPath     !-keepPath    \n"
            + "-keepCP         $ \n   -nokeepCP       !-keepCP      \n"
            + "-keepOrder      $ \n   -nokeepOrder    !-keepOrder   \n"
            + "-continue       $ \n   -nocontinue     !-continue    \n"
            + "-@         >-@  . \n"
            + "-              +? \n"
            + "\n");


    // Protected state for representing the class file.
    protected Element cfile;          // <ClassFile ...>
    protected Element cpool;          // <ConstantPool ...>
    protected Element klass;          // <Class ...>
    protected List<String> thePool;    // stringified flattened Constant Pool

    public static void main(String[] ava) throws IOException {
        ArrayList<String> av = new ArrayList<>(Arrays.asList(ava));
        HashMap<String, String> props = new HashMap<>();
        props.put("-encoding:", "UTF8");  // default
        props.put("-keepOrder", null);    // CLI default
        props.put("-pretty", "1");     // CLI default
        props.put("-continue", "1");     // CLI default
        CLP.parse(av, props);
        //System.out.println(props+" ++ "+av);
        File source = asFile(props.get("-source:"));
        File dest = asFile(props.get("-dest:"));
        String encoding = props.get("-encoding:");
        boolean contError = props.containsKey("-continue");
        ClassReader options = new ClassReader();
        options.copyOptionsFrom(props);
        /*
        if (dest == null && av.size() > 1) {
        dest = File.createTempFile("TestOut", ".dir", new File("."));
        dest.delete();
        if (!dest.mkdir())
        throw new RuntimeException("Cannot create "+dest);
        System.out.println("Writing results to "+dest);
        }
         */
        if (av.isEmpty()) {
            av.add("");  //to enter this loop
        }
        boolean readList = false;
        for (String a : av) {
            if (readList) {
                readList = false;
                InputStream fin;
                if (a.equals("-")) {
                    fin = System.in;
                } else {
                    fin = new FileInputStream(a);
                }

                BufferedReader files = makeReader(fin, encoding);
                for (String file; (file = files.readLine()) != null;) {
                    doFile(file, source, dest, options, encoding, contError);
                }
                if (fin != System.in) {
                    fin.close();
                }
            } else if (a.equals("-@")) {
                readList = true;
            } else if (a.startsWith("-")) {
                throw new RuntimeException("Bad flag argument: " + a);
            } else if (source.getName().endsWith(".jar")) {
                doJar(a, source, dest, options, encoding, contError);
            } else {
                doFile(a, source, dest, options, encoding, contError);
            }
        }
    }

    private static File asFile(String str) {
        return (str == null) ? null : new File(str);
    }

    private static void doFile(String a,
            File source, File dest,
            ClassReader options, String encoding,
            boolean contError) throws IOException  {
        if (!contError) {
            doFile(a, source, dest, options, encoding);
        } else {
            try {
                doFile(a, source, dest, options, encoding);
            } catch (Exception ee) {
                System.out.println("Error processing " + source + ": " + ee);
                ee.printStackTrace();
            }
        }
    }

    private static void doJar(String a, File source, File dest,
                              ClassReader options, String encoding,
                              Boolean contError) throws IOException {
        try {
            JarFile jf = new JarFile(source);
            for (JarEntry je : Collections.list(jf.entries())) {
                String name = je.getName();
                if (!name.endsWith(".class")) {
                    continue;
                }
                try {
                    doStream(name, jf.getInputStream(je), dest, options, encoding);
                } catch (Exception e) {
                    if (contError) {
                        System.out.println("Error processing " + source + ": " + e);
                        e.printStackTrace();
                        continue;
                    }
                }
            }
        } catch (IOException ioe) {
            throw ioe;
        }
    }

    private static void doStream(String a, InputStream in, File dest,
                                 ClassReader options, String encoding) throws IOException {

        File f = new File(a);
        ClassReader cr = new ClassReader(options);
        Element e;
        if (options.verbose) {
            System.out.println("Reading " + f);
        }
        e = cr.readFrom(in);

        OutputStream out;
        if (dest == null) {
            out = System.out;
        } else {
            File outf = new File(dest, f.isAbsolute() ? f.getName() : f.getPath());
            String outName = outf.getName();
            File outSubdir = outf.getParentFile();
            outSubdir.mkdirs();
            int extPos = outName.lastIndexOf('.');
            if (extPos > 0) {
                outf = new File(outSubdir, outName.substring(0, extPos) + ".xml");
            }
            out = new FileOutputStream(outf);
        }

        Writer outw = makeWriter(out, encoding);
        if (options.pretty || !options.keepOrder) {
            e.writePrettyTo(outw);
        } else {
            e.writeTo(outw);
        }
        if (out == System.out) {
            outw.write("\n");
            outw.flush();
        } else {
            outw.close();
        }
    }

    private static void doFile(String a,
            File source, File dest,
            ClassReader options, String encoding) throws IOException {
        File inf = new File(source, a);
        if (dest != null && options.verbose) {
            System.out.println("Reading " + inf);
        }

        BufferedInputStream in = new BufferedInputStream(new FileInputStream(inf));

        doStream(a, in, dest, options, encoding);

    }

    public static BufferedReader makeReader(InputStream in,
                                            String encoding) throws IOException {
        Reader inw;
        in = new BufferedInputStream(in);  // add buffering
        if (encoding == null) {
            inw = new InputStreamReader(in);
        } else {
            inw = new InputStreamReader(in, encoding);
        }
        return new BufferedReader(inw);  // add buffering
    }

    public static Writer makeWriter(OutputStream out,
                                    String encoding) throws IOException {
        Writer outw;
        if (encoding == null) {
            outw = new OutputStreamWriter(out);
        } else {
            outw = new OutputStreamWriter(out, encoding);
        }
        return new BufferedWriter(outw);  // add buffering
    }

    public Element result() {
        return cfile;
    }

    protected InputStream in;
    protected ByteArrayOutputStream buf = new ByteArrayOutputStream(1024);
    // input options
    public boolean pretty = false;
    public boolean verbose = false;
    public boolean keepPath = false;
    public boolean keepCP = false;
    public boolean keepBytes = false;
    public boolean parseBytes = true;
    public boolean resolveRefs = true;
    public boolean keepOrder = true;
    public boolean keepSizes = false;

    public ClassReader() {
        cfile = new Element("ClassFile");
    }

    public ClassReader(ClassReader options) {
        this();
        copyOptionsFrom(options);
    }

    public void copyOptionsFrom(ClassReader options) {
        pretty = options.pretty;
        verbose = options.verbose;
        keepPath = options.keepPath;
        keepCP = options.keepCP;
        keepOrder = options.keepOrder;
    }

    public void copyOptionsFrom(Map<String, String> options) {
        if (options.containsKey("-pretty")) {
            pretty = (options.get("-pretty") != null);
        }
        if (options.containsKey("-verbose")) {
            verbose = (options.get("-verbose") != null);
        }
        if (options.containsKey("-keepPath")) {
            keepPath = (options.get("-keepPath") != null);
        }
        if (options.containsKey("-keepCP")) {
            keepCP = (options.get("-keepCP") != null);
        }
        if (options.containsKey("-keepOrder")) {
            keepOrder = (options.get("-keepOrder") != null);
        }
    }

    protected String getCpString(int i) {
        return thePool.get(i);
    }

    public Element readFrom(InputStream in) throws IOException {
        try {
            this.in = in;
            ClassFile c = ClassFile.read(in);
            // read the file header
            if (c.magic != 0xCAFEBABE) {
                throw new RuntimeException("bad magic number " +
                        Integer.toHexString(c.magic));
            }
            cfile.setAttr("magic", "" + c.magic);
            int minver = c.minor_version;
            int majver = c.major_version;
            cfile.setAttr("minver", "" + minver);
            cfile.setAttr("majver", "" + majver);
            readCP(c);
            readClass(c);
            return result();
        } catch (InvalidDescriptor | ConstantPoolException ex) {
            throw new IOException("Fatal error", ex);
        }
    }

    public Element readFrom(File file) throws IOException {
        try (InputStream strm = new FileInputStream(file)) {
            Element e = readFrom(new BufferedInputStream(strm));
            if (keepPath) {
                e.setAttr("path", file.toString());
            }
            return e;
        }
    }

    private void readClass(ClassFile c) throws IOException,
                                               ConstantPoolException,
                                               InvalidDescriptor {
        klass = new Element("Class");
        cfile.add(klass);
        String thisk = c.getName();

        klass.setAttr("name", thisk);

        AccessFlags af = new AccessFlags(c.access_flags.flags);
        klass.setAttr("flags", flagString(af, klass));
        if (!"java/lang/Object".equals(thisk)) {
            klass.setAttr("super", c.getSuperclassName());
        }
        for (int i : c.interfaces) {
            klass.add(new Element("Interface", "name", getCpString(i)));
        }
        readFields(c, klass);
        readMethods(c, klass);
        readAttributesFor(c, c.attributes, klass);
        klass.trimToSize();
    }

    private void readFields(ClassFile c, Element klass) throws IOException {
        int len = c.fields.length;
        Element fields = new Element(len);
        for (Field f : c.fields) {
            Element field = new Element("Field");
            field.setAttr("name", getCpString(f.name_index));
            field.setAttr("type", getCpString(f.descriptor.index));
            field.setAttr("flags", flagString(f.access_flags.flags, field));
            readAttributesFor(c, f.attributes, field);

            field.trimToSize();
            fields.add(field);
        }
        if (!keepOrder) {
            fields.sort();
        }
        klass.addAll(fields);
    }


    private void readMethods(ClassFile c, Element klass) throws IOException {
        int len = c.methods.length;
        Element methods = new Element(len);
        for (Method m : c.methods) {
            Element member = new Element("Method");
            member.setAttr("name", getCpString(m.name_index));
            member.setAttr("type", getCpString(m.descriptor.index));
            member.setAttr("flags", flagString(m.access_flags.flags, member));
            readAttributesFor(c, m.attributes, member);

            member.trimToSize();
            methods.add(member);
        }
        if (!keepOrder) {
            methods.sort();
        }
        klass.addAll(methods);
    }

    private AccessFlags.Kind getKind(Element e) {
        switch(e.getName()) {
            case "Class":
                return AccessFlags.Kind.Class;
            case "InnerClass":
                return AccessFlags.Kind.InnerClass;
            case "Field":
                return AccessFlags.Kind.Field ;
            case "Method":
                return AccessFlags.Kind.Method;
            default: throw new RuntimeException("should not reach here");
        }
    }

    protected String flagString(int flags, Element holder) {
        return flagString(new AccessFlags(flags), holder);
    }
    protected String flagString(AccessFlags af, Element holder) {
        return flagString(af, holder.getName());
    }
    protected String flagString(int flags, String kind) {
        return flagString(new AccessFlags(flags), kind);
    }
    protected String flagString(AccessFlags af, String kind) {
        Set<String> mods = null;
        switch (kind) {
            case "Class":
                mods = af.getClassFlags();
                break;
            case "InnerClass":
                mods = af.getInnerClassFlags();
                break;
            case "Field":
                mods = af.getFieldFlags();
                break;
            case "Method":
                mods = af.getMethodFlags();
                break;
            default:
                throw new RuntimeException("should not reach here");
        }
        StringBuilder sb = new StringBuilder();
        for (String x : mods) {
            sb.append(x.substring(x.indexOf('_') + 1).toLowerCase()).append(" ");
        }
        return sb.toString().trim();
    }


    protected  void readAttributesFor(ClassFile c, Attributes attrs, Element x) {
        Element container = new Element();
        AttributeVisitor av = new AttributeVisitor(this, c);
        for (Attribute a : attrs) {
            av.visit(a, container);
        }
        if (!keepOrder) {
            container.sort();
        }
        x.addAll(container);
    }

    private int fileSize = 0;
    private HashMap<String, int[]> attrSizes = new HashMap<>();

    private void attachTo(Element x, Object aval0) {
        if (aval0 == null) {
            return;
        }
        if (!(aval0 instanceof Element)) {
            x.add(aval0);
            return;
        }
        Element aval = (Element) aval0;
        if (!aval.isAnonymous()) {
            x.add(aval);
            return;
        }
        for (int imax = aval.attrSize(), i = 0; i < imax; i++) {
            //%%
            attachAttrTo(x, aval.getAttrName(i), aval.getAttr(i));
        }
        x.addAll(aval);
    }

    private void attachAttrTo(Element x, String aname, String aval) {
        String aval0 = x.getAttr(aname);
        if (aval0 != null) {
            aval = aval0 + " " + aval;
        }
        x.setAttr(aname, aval);
    }

    private void readCP(ClassFile c) throws IOException {
        cpool = new Element("ConstantPool", c.constant_pool.size());
        ConstantPoolVisitor cpv = new ConstantPoolVisitor(cpool, c,
                c.constant_pool.size());
        for (int i = 1 ; i < c.constant_pool.size() ; i++) {
            try {
                cpv.visit(c.constant_pool.get(i), i);
            } catch (InvalidIndex ex) {
                // can happen periodically when accessing doubles etc. ignore it
                // ex.printStackTrace();
            }
        }
        thePool = cpv.getPoolList();
        if (verbose) {
            for (int i = 0; i < thePool.size(); i++) {
                System.out.println("[" + i + "]: " + thePool.get(i));
            }
        }
        if (keepCP) {
            cfile.add(cpool);
        }
    }
}

class ConstantPoolVisitor implements ConstantPool.Visitor<String, Integer> {
    final List<String> slist;
    final Element xpool;
    final ClassFile cf;
    final ConstantPool cfpool;
    final List<String> bsmlist;


    public ConstantPoolVisitor(Element xpool, ClassFile cf, int size) {
        slist = new ArrayList<>(size);
        for (int i = 0 ; i < size; i++) {
            slist.add(null);
        }
        this.xpool = xpool;
        this.cf = cf;
        this.cfpool = cf.constant_pool;
        bsmlist = readBSM();
    }

    public List<String> getPoolList() {
        return Collections.unmodifiableList(slist);
    }

    public List<String> getBSMList() {
        return Collections.unmodifiableList(bsmlist);
    }

    public String visit(CPInfo c, int index) {
        return c.accept(this, index);
    }

    private List<String> readBSM() {
        BootstrapMethods_attribute bsmAttr =
                (BootstrapMethods_attribute) cf.getAttribute(Attribute.BootstrapMethods);
        if (bsmAttr != null) {
            List<String> out =
                    new ArrayList<>(bsmAttr.bootstrap_method_specifiers.length);
            for (BootstrapMethods_attribute.BootstrapMethodSpecifier bsms :
                    bsmAttr.bootstrap_method_specifiers) {
                int index = bsms.bootstrap_method_ref;
                try {
                    String value = slist.get(index);
                    String bsmStr = value;
                    if (value == null) {
                        value = visit(cfpool.get(index), index);
                        slist.set(index, value);
                    }
                    bsmStr = value;
                    for (int idx : bsms.bootstrap_arguments) {
                        value = slist.get(idx);
                        if (value == null) {
                            value = visit(cfpool.get(idx), idx);
                            slist.set(idx, value);
                        }
                        bsmStr = bsmStr.concat("," + value);
                    }
                    out.add(bsmStr);
                } catch (InvalidIndex ex) {
                    ex.printStackTrace();
                }
            }
            return out;
        }
        return new ArrayList<>(0);
    }

    @Override
    public String visitClass(CONSTANT_Class_info c, Integer p) {
        String value = slist.get(p);
        if (value == null) {
            try {
                value = visit(cfpool.get(c.name_index), c.name_index);
                slist.set(p, value);
                xpool.add(new Element("CONSTANT_Class",
                        new String[]{"id", p.toString()},
                        value));
            } catch (ConstantPoolException ex) {
                ex.printStackTrace();
            }
        }
        return value;
    }

    @Override
    public String visitDouble(CONSTANT_Double_info c, Integer p) {
        String value = slist.get(p);
        if (value == null) {
            value = Double.toString(c.value);
            slist.set(p, value);
            xpool.add(new Element("CONSTANT_Double",
                      new String[]{"id", p.toString()},
                      value));
        }
        return value;
    }

    @Override
    public String visitFieldref(CONSTANT_Fieldref_info c, Integer p) {
    String value = slist.get(p);
        if (value == null) {
            try {
                value = visit(cfpool.get(c.class_index), c.class_index);
                value = value.concat(" " + visit(cfpool.get(c.name_and_type_index),
                                     c.name_and_type_index));
                slist.set(p, value);
                xpool.add(new Element("CONSTANT_Fieldref",
                          new String[]{"id", p.toString()},
                          value));
            } catch (ConstantPoolException ex) {
                ex.printStackTrace();
            }
        }
        return value;
    }

    @Override
    public String visitFloat(CONSTANT_Float_info c, Integer p) {
        String value = slist.get(p);
        if (value == null) {
            value = Float.toString(c.value);
            slist.set(p, value);
            xpool.add(new Element("CONSTANT_Float",
                      new String[]{"id", p.toString()},
                      value));
        }
        return value;
    }

    @Override
    public String visitInteger(CONSTANT_Integer_info cnstnt, Integer p) {
        String value = slist.get(p);
        if (value == null) {
            value = Integer.toString(cnstnt.value);
            slist.set(p, value);
            xpool.add(new Element("CONSTANT_Integer",
                      new String[]{"id", p.toString()},
                      value));
        }
        return value;
    }

    @Override
    public String visitInterfaceMethodref(CONSTANT_InterfaceMethodref_info c,
                                          Integer p) {
        String value = slist.get(p);
        if (value == null) {
            try {
                value = visit(cfpool.get(c.class_index), c.class_index);
                value = value.concat(" " +
                                     visit(cfpool.get(c.name_and_type_index),
                                     c.name_and_type_index));
                slist.set(p, value);
                xpool.add(new Element("CONSTANT_InterfaceMethodref",
                          new String[]{"id", p.toString()},
                          value));

            } catch (ConstantPoolException ex) {
                ex.printStackTrace();
            }
        }
        return value;
    }

    @Override
    public String visitInvokeDynamic(CONSTANT_InvokeDynamic_info c, Integer p) {
        String value = slist.get(p);
        if (value == null) {
            try {
                value = bsmlist.get(c.bootstrap_method_attr_index) + " "
                        + visit(cfpool.get(c.name_and_type_index), c.name_and_type_index);
                slist.set(p, value);
                xpool.add(new Element("CONSTANT_InvokeDynamic",
                          new String[]{"id", p.toString()},
                          value));

            } catch (ConstantPoolException ex) {
                ex.printStackTrace();
            }
        }
        return value;
    }

    @Override
    public String visitLong(CONSTANT_Long_info c, Integer p) {
        String value = slist.get(p);
        if (value == null) {
            value = Long.toString(c.value);
            slist.set(p, value);
            xpool.add(new Element("CONSTANT_Long",
                      new String[]{"id", p.toString()},
                      value));
        }
        return value;
    }

    @Override
    public String visitNameAndType(CONSTANT_NameAndType_info c, Integer p) {
        String value = slist.get(p);
        if (value == null) {
            try {
                value = visit(cfpool.get(c.name_index), c.name_index);
                value = value.concat(" " +
                        visit(cfpool.get(c.type_index), c.type_index));
                slist.set(p, value);
                xpool.add(new Element("CONSTANT_NameAndType",
                          new String[]{"id", p.toString()},
                          value));
            } catch (InvalidIndex ex) {
                ex.printStackTrace();
            }
        }
        return value;
    }

    @Override
    public String visitMethodref(CONSTANT_Methodref_info c, Integer p) {
        String value = slist.get(p);
        if (value == null) {
            try {
                value = visit(cfpool.get(c.class_index), c.class_index);
                value = value.concat(" " +
                                     visit(cfpool.get(c.name_and_type_index),
                                     c.name_and_type_index));
                slist.set(p, value);
                xpool.add(new Element("CONSTANT_Methodref",
                          new String[]{"id", p.toString()},
                          value));

            } catch (ConstantPoolException ex) {
                ex.printStackTrace();
            }
        }
        return value;
    }

    @Override
    public String visitMethodHandle(CONSTANT_MethodHandle_info c, Integer p) {
    String value = slist.get(p);
        if (value == null) {
            try {
                value = c.reference_kind.name();
                value = value.concat(" "
                        + visit(cfpool.get(c.reference_index), c.reference_index));
                slist.set(p, value);
                xpool.add(new Element("CONSTANT_MethodHandle",
                          new String[]{"id", p.toString()},
                          value));

            } catch (ConstantPoolException ex) {
                ex.printStackTrace();
            }
        }
        return value;
    }

    @Override
    public String visitMethodType(CONSTANT_MethodType_info c, Integer p) {
        String value = slist.get(p);
        if (value == null) {
            try {
                value = visit(cfpool.get(c.descriptor_index), c.descriptor_index);
                slist.set(p, value);
                xpool.add(new Element("CONSTANT_MethodType",
                          new String[]{"id", p.toString()},
                          value));
            } catch (ConstantPoolException ex) {
                ex.printStackTrace();
            }
        }
        return value;
    }

    @Override
    public String visitString(CONSTANT_String_info c, Integer p) {
        try {

            String value = slist.get(p);
            if (value == null) {
                value = c.getString();
                slist.set(p, value);
                xpool.add(new Element("CONSTANT_String",
                          new String[]{"id", p.toString()},
                          value));
            }
            return value;
        } catch (ConstantPoolException ex) {
            throw new RuntimeException("Fatal error", ex);
        }
    }

    @Override
    public String  visitUtf8(CONSTANT_Utf8_info cnstnt, Integer p) {
        String value = slist.get(p);
        if (value == null) {
            value = cnstnt.value;
            slist.set(p, value);
            xpool.add(new Element("CONSTANT_Utf8",
                      new String[]{"id", p.toString()},
                      value));
        }
        return value;

    }
}


class AttributeVisitor implements Attribute.Visitor<Element, Element> {
    final ClassFile cf;
    final ClassReader x;
    final AnnotationsElementVisitor aev;
    final InstructionVisitor iv;

    public AttributeVisitor(ClassReader x, ClassFile cf) {
        this.x = x;
        this.cf = cf;
        iv =  new InstructionVisitor(x, cf);
        aev = new AnnotationsElementVisitor(x, cf);
    }

    public void visit(Attribute a, Element parent) {
        a.accept(this, parent);
    }

    @Override
    public Element visitBootstrapMethods(BootstrapMethods_attribute bm, Element p) {
        Element e = new Element(x.getCpString(bm.attribute_name_index));
        for (BootstrapMethods_attribute.BootstrapMethodSpecifier bsm : bm.bootstrap_method_specifiers) {
            Element be = new Element("BootstrapMethodSpecifier");
            be.setAttr("ref", x.getCpString(bsm.bootstrap_method_ref));
            if (bsm.bootstrap_arguments.length > 0) {
                Element bme = new Element("MethodArguments");
                for (int index : bsm.bootstrap_arguments) {
                    bme.add(x.getCpString(index));
                }
                bme.trimToSize();
                be.add(bme);
            }
            be.trimToSize();
            e.add(be);
        }
        e.trimToSize();
        if (!x.keepOrder) {
            e.sort();
        }
        p.add(e);
        return null;
    }

    @Override
    public Element visitDefault(DefaultAttribute da, Element p) {
        Element e = new Element(x.getCpString(da.attribute_name_index));
        StringBuilder sb = new StringBuilder();
        for (byte x : da.info) {
            sb.append("0x").append(Integer.toHexString(x)).append(" ");
        }
        e.setAttr("bytes", sb.toString().trim());
        e.trimToSize();
        p.add(e);
        return null;
    }

    @Override
    public Element visitAnnotationDefault(AnnotationDefault_attribute ad, Element p) {
        Element e = new Element(x.getCpString(ad.attribute_name_index));
        e.setAttr("tag", "" + ad.default_value.tag);
        Element child = aev.visit(ad.default_value, e);
        if (child != null) {
            e.add(child);
        }
        e.trimToSize();
        p.add(e);
        return null;
    }

    @Override
    public Element visitCharacterRangeTable(CharacterRangeTable_attribute crt,
                                            Element p) {
        Element e = new Element(x.getCpString(crt.attribute_name_index));
        for (CharacterRangeTable_attribute.Entry ce : crt.character_range_table) {
            e.setAttr("start_pc", "" + ce.start_pc);
            e.setAttr("end_pc", "" + ce.end_pc);
            e.setAttr("range_start", "" + ce.character_range_start);
            e.setAttr("range_end", "" + ce.character_range_end);
            e.setAttr("flags", x.flagString(ce.flags, "Method"));
        }
        e.trimToSize();
        p.add(e);
        return null;
    }

    private Element instructions(Element code, Code_attribute c) {
        Element ielement = new Element("Instructions");
        for (Instruction ins : c.getInstructions()) {
            ielement.add(iv.visit(ins));
        }
        ielement.trimToSize();
        return ielement;
    }

    @Override
    public Element visitCode(Code_attribute c, Element p) {
        Element e = null;

        e = new Element(x.getCpString(c.attribute_name_index),
                "stack", "" + c.max_stack,
                "local", "" + c.max_locals);

        e.add(instructions(e, c));

        for (Code_attribute.Exception_data edata : c.exception_table) {
            e.add(new Element("Handler",
                    "start", "" + edata.start_pc,
                    "end", "" + edata.end_pc,
                    "catch", "" + edata.handler_pc,
                    "class", x.getCpString(edata.catch_type)));

        }
        this.x.readAttributesFor(cf, c.attributes, e);
        e.trimToSize();
        p.add(e);
        return null;
    }

    @Override
    public Element visitCompilationID(CompilationID_attribute cid, Element p) {
        Element e = new Element(x.getCpString(cid.attribute_name_index),
                x.getCpString(cid.compilationID_index));
        p.add(e);
        return null;
    }

    @Override
    public Element visitConstantValue(ConstantValue_attribute cv, Element p) {
        Element e = new Element(x.getCpString(cv.attribute_name_index));
        e.add(x.getCpString(cv.constantvalue_index));
        p.add(e);
        return null;
    }

    @Override
    public Element visitDeprecated(Deprecated_attribute d, Element p) {
        Element e = new Element(x.getCpString(d.attribute_name_index));
        p.add(e);
        return null;
    }

    @Override
    public Element visitEnclosingMethod(EnclosingMethod_attribute em, Element p) {
        Element e = new Element(x.getCpString(em.attribute_name_index));
        e.setAttr("class", x.getCpString(em.class_index));
        e.setAttr("desc", x.getCpString(em.method_index));
        e.trimToSize();
        p.add(e);
        return null;
    }

    @Override
    public Element visitExceptions(Exceptions_attribute e, Element p) {
        Element ee = new Element(x.getCpString(e.attribute_name_index));
        for (int idx : e.exception_index_table) {
            Element n = new Element("Item");
            n.setAttr("class", x.getCpString(idx));
            ee.add(n);
        }
        ee.trimToSize();
        p.add(ee);
        return null;
    }

    @Override
    public Element visitInnerClasses(InnerClasses_attribute ic, Element p) {
        for (Info info : ic.classes) {
            Element e = new Element(x.getCpString(ic.attribute_name_index));
            e.setAttr("class", x.getCpString(info.inner_class_info_index));
            e.setAttr("outer", x.getCpString(info.outer_class_info_index));
            e.setAttr("name", x.getCpString(info.inner_name_index));
            e.setAttr("flags", x.flagString(info.inner_class_access_flags,
                    "InnerClass"));
            e.trimToSize();
            p.add(e);
        }
        return null;
    }

    @Override
    public Element visitLineNumberTable(LineNumberTable_attribute lnt, Element p) {
        String name = x.getCpString(lnt.attribute_name_index);
        for (LineNumberTable_attribute.Entry e : lnt.line_number_table) {
            Element l = new Element(name);
            l.setAttr("bci", "" + e.start_pc);
            l.setAttr("line", "" + e.line_number);
            l.trimToSize();
            p.add(l);
        }
        return null; // already added to parent
    }

    @Override
    public Element visitLocalVariableTable(LocalVariableTable_attribute lvt,
                                                Element p) {
        String name = x.getCpString(lvt.attribute_name_index);
        for (LocalVariableTable_attribute.Entry e : lvt.local_variable_table) {
            Element l = new Element(name);
            l.setAttr("bci", "" + e.start_pc);
            l.setAttr("span", "" + e.length);
            l.setAttr("name", x.getCpString(e.name_index));
            l.setAttr("type", x.getCpString(e.descriptor_index));
            l.setAttr("slot", "" + e.index);
            l.trimToSize();
            p.add(l);
        }
        return null; // already added to parent
    }

    @Override
    public Element visitLocalVariableTypeTable(LocalVariableTypeTable_attribute lvtt,
                                                    Element p) {
        String name = x.getCpString(lvtt.attribute_name_index);
        for (LocalVariableTypeTable_attribute.Entry e : lvtt.local_variable_table) {
            Element l = new Element(name);
            l.setAttr("bci", "" + e.start_pc);
            l.setAttr("span", "" + e.length);
            l.setAttr("name", x.getCpString(e.name_index));
            l.setAttr("type", x.getCpString(e.signature_index));
            l.setAttr("slot", "" + e.index);
            l.trimToSize();
            p.add(l);
        }
        return null; // already added to parent
    }

    @Override
    public Element visitMethodParameters(MethodParameters_attribute mp, Element p) {
        String name = x.getCpString(mp.attribute_name_index);
        for (MethodParameters_attribute.Entry e : mp.method_parameter_table) {
            Element l = new Element(name);
            l.setAttr("name", x.getCpString(e.name_index));
            l.setAttr("flag", "" + e.flags);
            l.trimToSize();
            p.add(l);
        }
        return null; // already added to parent
    }
    private void parseAnnotation(Annotation anno, Element p) {
        Element ea = new Element("Annotation");
        ea.setAttr("name", "" + x.getCpString(anno.type_index));
        for (Annotation.element_value_pair evp : anno.element_value_pairs) {
            Element evpe = new Element("Element");
            evpe.setAttr("tag", "" + evp.value.tag);
            evpe.setAttr("value", x.getCpString(evp.element_name_index));
            Element child = aev.visit(evp.value, evpe);
            if (child != null) {
                evpe.add(child);
            }
            ea.add(evpe);
        }
        ea.trimToSize();
        p.add(ea);
    }

    private void parseAnnotations(Annotation[] ra, Element p) {
        for (Annotation anno : ra) {
            parseAnnotation(anno, p);
        }
    }

    @Override
    public Element visitRuntimeVisibleAnnotations(RuntimeVisibleAnnotations_attribute rva,
                                                  Element p) {
        Element e = new Element(x.getCpString(rva.attribute_name_index));
        parseAnnotations(rva.annotations, e);
        e.trimToSize();
        p.add(e);
        return null;
    }

    @Override
    public Element visitRuntimeInvisibleAnnotations(RuntimeInvisibleAnnotations_attribute ria,
                                                    Element p) {
        Element e = new Element(x.getCpString(ria.attribute_name_index));
        parseAnnotations(ria.annotations, e);
        e.trimToSize();
        p.add(e);
        return null;
    }

    @Override
    public Element visitRuntimeVisibleParameterAnnotations(RuntimeVisibleParameterAnnotations_attribute rvpa,
                                                           Element p) {
        Element e = new Element(x.getCpString(rvpa.attribute_name_index));
        for (Annotation[] pa : rvpa.parameter_annotations) {
           parseAnnotations(pa, e);
        }
        p.add(e);
        return null;
    }

    @Override
    public Element visitRuntimeInvisibleParameterAnnotations(RuntimeInvisibleParameterAnnotations_attribute ripa,
                                                             Element p) {
        Element e = new Element(x.getCpString(ripa.attribute_name_index));
        for (Annotation[] pa : ripa.parameter_annotations) {
            parseAnnotations(pa, e);
        }
        p.add(e);
        return null;
    }

    private void parsePosition(Position ap, Element p) {
        Element te = new Element();
        switch (ap.type) {
            case CLASS_TYPE_PARAMETER: // 0x00
                te.setName("CLASS_TYPE_PARAMETER");
                te.setAttr("idx", "" + ap.parameter_index);
                break;
            case METHOD_TYPE_PARAMETER: // 0x01
                te.setName("METHOD_TYPE_PARAMETER");
                te.setAttr("idx", "" + ap.parameter_index);
                break;
            case CLASS_EXTENDS: // 0x10
                te.setName("CLASS_EXTENDS");
                te.setAttr("idx", "" + ap.type_index);
                break;
            case CLASS_TYPE_PARAMETER_BOUND: // 0x11
                te.setName("CLASS_TYPE_PARAMETER_BOUND");
                te.setAttr("idx1", "" + ap.parameter_index);
                te.setAttr("idx2", "" + ap.bound_index);
                break;
            case METHOD_TYPE_PARAMETER_BOUND: // 0x12
                te.setName("METHOD_TYPE_PARAMETER_BOUND");
                te.setAttr("idx1", "" + ap.parameter_index);
                te.setAttr("idx2", "" + ap.bound_index);
                break;
            case FIELD: // 0x13
                te.setName("FIELD");
                break;
            case METHOD_RETURN: // 0x14
                te.setName("METHOD_RETURN");
                break;
            case METHOD_RECEIVER: // 0x15
                te.setName("METHOD_RECEIVER");
                break;
            case METHOD_FORMAL_PARAMETER: // 0x16
                te.setName("METHOD_FORMAL_PARAMETER");
                te.setAttr("idx", "" + ap.parameter_index);
                break;
            case THROWS: // 0x17
                te.setName("THROWS");
                te.setAttr("idx", "" + ap.type_index);
                break;
            case LOCAL_VARIABLE: // 0x40
                te.setName("LOCAL_VARIABLE");
                for (int i = 0; i < ap.lvarIndex.length; i++) {
                    te.setAttr("lvar_idx_" + i, "" + ap.lvarIndex[i]);
                    te.setAttr("lvar_len_" + i, "" + ap.lvarLength[i]);
                    te.setAttr("lvar_off_" + i, "" + ap.lvarOffset[i]);
                }
                break;
            case RESOURCE_VARIABLE: // 0x41
                te.setName("RESOURCE_VARIABLE");
                for (int i = 0; i < ap.lvarIndex.length ; i++) {
                    te.setAttr("lvar_idx_" + i, "" + ap.lvarIndex[i]);
                    te.setAttr("lvar_len_" + i, "" + ap.lvarLength[i]);
                    te.setAttr("lvar_off_" + i, "" + ap.lvarOffset[i]);
                }
                break;
            case EXCEPTION_PARAMETER: // 0x42
                te.setName("EXCEPTION_PARAMETER");
                te.setAttr("idx", "" + ap.exception_index);
                break;
            case INSTANCEOF: // 0x43
                te.setName("INSTANCE_OF");
                te.setAttr("off", "" + ap.offset);
                break;
            case NEW: // 0x44
                te.setName("NEW");
                te.setAttr("off", "" + ap.offset);
                break;
            case CONSTRUCTOR_REFERENCE: // 0x45
                te.setName("CONSTRUCTOR_REFERENCE_RECEIVER");
                te.setAttr("off", "" + ap.offset);
                break;
            case METHOD_REFERENCE: // 0x46
                te.setName("METHOD_REFERENCE_RECEIVER");
                te.setAttr("off", "" + ap.offset);
                break;
            case CAST: // 0x47
                te.setName("CAST");
                te.setAttr("off", "" + ap.offset);
                te.setAttr("idx", "" + ap.type_index);
                break;
            case CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT: // 0x48
                te.setName("CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT");
                te.setAttr("off", "" + ap.offset);
                te.setAttr("idx", "" + ap.type_index);
                break;
            case METHOD_INVOCATION_TYPE_ARGUMENT: // 0x49
                te.setName("METHOD_INVOCATION_TYPE_ARGUMENT");
                te.setAttr("off", "" + ap.offset);
                te.setAttr("idx", "" + ap.type_index);
                break;
            case CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT: // 0x4A
                te.setName("CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT");
                te.setAttr("off", "" + ap.offset);
                te.setAttr("idx", "" + ap.type_index);
                break;
            case METHOD_REFERENCE_TYPE_ARGUMENT: // 0x4B
                te.setName("METHOD_REFERENCE_TYPE_ARGUMENT");
                te.setAttr("off", "" + ap.offset);
                te.setAttr("idx", "" + ap.type_index);
                break;
            default:
                throw new RuntimeException("not implemented");
        }
        te.trimToSize();
        p.add(te);
    }
    private void parseTypeAnnotations(TypeAnnotation pa, Element p) {
        Element pta = new Element("RuntimeVisibleTypeAnnotation");
        p.add(pta);
        Position pos = pa.position;
        parsePosition(pos, pta);
        parseAnnotation(pa.annotation, pta);
    }

    @Override
    public Element visitRuntimeVisibleTypeAnnotations(RuntimeVisibleTypeAnnotations_attribute rvta, Element p) {
        Element e = new Element(x.getCpString(rvta.attribute_name_index));
        for (TypeAnnotation pa : rvta.annotations) {
            parseTypeAnnotations(pa, e);
        }
        e.sort();
        p.add(e);
        return null;
    }

    @Override
    public Element visitRuntimeInvisibleTypeAnnotations(RuntimeInvisibleTypeAnnotations_attribute rita, Element p) {
        Element e = new Element(x.getCpString(rita.attribute_name_index));
        for (TypeAnnotation pa : rita.annotations) {
            parseTypeAnnotations(pa, e);
        }
        e.sort();
        p.add(e);
        return null;
    }

    @Override
    public Element visitSignature(Signature_attribute s, Element p) {
        String aname = x.getCpString(s.attribute_name_index);
        String sname = x.getCpString(s.signature_index);
        Element se = new Element(aname);
        se.add(sname);
        se.trimToSize();
        p.add(se);
        return null;
    }

    @Override
    public Element visitSourceDebugExtension(SourceDebugExtension_attribute sde,
                                                Element p) {
        String aname = x.getCpString(sde.attribute_name_index);
        Element se = new Element(aname);
        se.setAttr("val", sde.getValue());
        se.trimToSize();
        p.add(se);
        return null;
    }

    @Override
    public Element visitSourceFile(SourceFile_attribute sf, Element p) {
        String aname = x.getCpString(sf.attribute_name_index);
        String sname = x.getCpString(sf.sourcefile_index);
        Element se = new Element(aname);
        se.add(sname);
        se.trimToSize();
        p.add(se);
        return null;
    }

    @Override
    public Element visitSourceID(SourceID_attribute sid, Element p) {
        Element e = new Element(x.getCpString(sid.attribute_name_index));
        e.add(x.getCpString(sid.sourceID_index));
        e.trimToSize();
        p.add(e);
        return null;
    }

    @Override
    public Element visitStackMap(StackMap_attribute sm, Element p) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public Element visitStackMapTable(StackMapTable_attribute smt, Element p) {
        Element stackmap = new Element(x.getCpString(smt.attribute_name_index));
        for (StackMapTable_attribute.stack_map_frame f : smt.entries) {
           StackMapVisitor smv = new StackMapVisitor(x, cf, stackmap);
           stackmap.add(smv.visit(f));
        }
        stackmap.trimToSize();
        p.add(stackmap);
        return null;
    }

    @Override
    public Element visitSynthetic(Synthetic_attribute s, Element p) {
        Element e = new Element(x.getCpString(s.attribute_name_index));
        e.trimToSize();
        p.add(e);
        return null;
    }
}

class StackMapVisitor implements StackMapTable_attribute.stack_map_frame.Visitor<Element, Void> {

    final ClassFile cf;
    final ClassReader x;
    final Element parent;

    public StackMapVisitor(ClassReader x, ClassFile cf, Element parent) {
        this.x = x;
        this.cf = cf;
        this.parent = parent;
    }

    public Element visit(StackMapTable_attribute.stack_map_frame frame) {
        return frame.accept(this, null);
    }

    @Override
    public Element visit_same_frame(same_frame sm_frm, Void p) {
        Element e = new Element("SameFrame");
        e.setAttr("tag", "" + sm_frm.frame_type);
        return e;
    }

    @Override
    public Element visit_same_locals_1_stack_item_frame(same_locals_1_stack_item_frame s, Void p) {
        Element e = new Element("SameLocals1StackItemFrame");
        e.setAttr("tag", "" + s.frame_type);
        e.addAll(getVerificationTypeInfo("Stack", s.stack));
        e.trimToSize();
        return e;
    }

    @Override
    public Element visit_same_locals_1_stack_item_frame_extended(same_locals_1_stack_item_frame_extended s, Void p) {
        Element e = new Element("SameLocals1StackItemFrameExtended");
        e.setAttr("tag", "" + s.frame_type);
        e.addAll(getVerificationTypeInfo("Stack", s.stack));
        e.trimToSize();
        return e;
    }

    @Override
    public Element visit_chop_frame(chop_frame c, Void p) {
        Element e = new Element("Chop" + (251 - c.frame_type));
        e.setAttr("tag", "" + c.frame_type);
        e.setAttr("offset", "" + c.offset_delta);
        return e;
    }

    @Override
    public Element visit_same_frame_extended(same_frame_extended s, Void p) {
        Element e = new Element("SameFrameExtended");
        e.setAttr("tag", "" + s.frame_type);
        e.setAttr("offset", "" + s.offset_delta);
        return e;
    }

    @Override
    public Element visit_append_frame(append_frame a, Void p) {
       Element e = new Element("AppendFrame" + (a.frame_type - 251));
       e.setAttr("tag", "" + a.frame_type);
       e.addAll(getVerificationTypeInfo("Local", a.locals));
       e.trimToSize();
       return e;
    }

    @Override
    public Element visit_full_frame(full_frame fl_frm, Void p) {
         Element e = new Element("FullFrame");
         e.setAttr("tag", "" + fl_frm.frame_type);
         e.addAll(getVerificationTypeInfo("Local", fl_frm.locals));
         e.trimToSize();
         return e;
    }

    private Element getVerificationTypeInfo(String kind,
            StackMapTable_attribute.verification_type_info velems[]) {
        Element container = new Element(velems.length);
        for (StackMapTable_attribute.verification_type_info v : velems) {
            Element ve = null;
            int offset = 0;
            int index = 0;
            switch (v.tag) {
                case StackMapTable_attribute.verification_type_info.ITEM_Top:
                    ve = new Element("ITEM_Top");
                    break;
                case StackMapTable_attribute.verification_type_info.ITEM_Integer:
                    ve = new Element("ITEM_Integer");
                    break;
                case StackMapTable_attribute.verification_type_info.ITEM_Float:
                    ve = new Element("ITEM_Float");
                    break;
                case StackMapTable_attribute.verification_type_info.ITEM_Long:
                    ve = new Element("ITEM_Long");
                    break;
                case StackMapTable_attribute.verification_type_info.ITEM_Double:
                    ve = new Element("ITEM_Double");
                    break;
                case StackMapTable_attribute.verification_type_info.ITEM_Null:
                    ve = new Element("ITEM_Null");
                    break;
                case StackMapTable_attribute.verification_type_info.ITEM_Uninitialized:
                    ve = new Element("ITEM_Uninitialized");
                    offset = ((StackMapTable_attribute.Uninitialized_variable_info) v).offset;
                    ve.setAttr("offset", "" + offset);
                    break;
                case StackMapTable_attribute.verification_type_info.ITEM_UninitializedThis:
                    ve = new Element("ITEM_UnitializedtThis");
                    break;
                case StackMapTable_attribute.verification_type_info.ITEM_Object:
                    ve = new Element("ITEM_Object");
                    index = ((StackMapTable_attribute.Object_variable_info) v).cpool_index;
                    ve.setAttr("class", x.getCpString(index));
                    break;
                default:
                    ve = new Element("Unknown");
            }
            Element kindE = new Element(kind);
            kindE.setAttr("tag", "" + v.tag);
            container.add(kindE);
            kindE.add(ve);
        }
        container.trimToSize();
        return container;
    }
}

class InstructionVisitor implements Instruction.KindVisitor<Element, Void> {

    final ClassReader x;
    final ClassFile cf;

    public InstructionVisitor(ClassReader x, ClassFile cf) {
        this.x = x;
        this.cf = cf;
    }

    public Element visit(Instruction i) {
        Element ie =  i.accept(this, null);
        ie.trimToSize();
        return ie;
    }

    @Override
    public Element visitNoOperands(Instruction i, Void p) {
        Opcode o = i.getOpcode();
        Element e = new Element(i.getMnemonic());
        if (o.opcode > 0xab && o.opcode <= 0xb1) {
            e.setAttr("pc", "" + i.getPC());
        }
        return e;
    }

    @Override
    public Element visitArrayType(Instruction i, TypeKind tk, Void p) {
        Element ie = new Element(i.getMnemonic());
        ie.setAttr("num", "" + tk.value);
        ie.setAttr("val", tk.name);
        return ie;
    }

    @Override
    public Element visitBranch(Instruction i, int i1, Void p) {
        Element ie = new Element(i.getMnemonic());
        ie.setAttr("lab", "" + (i.getPC() + i1));
        return ie;
    }

    @Override
    public Element visitConstantPoolRef(Instruction i, int i1, Void p) {
        Element ie = new Element(i.getMnemonic());
        ie.setAttr("ref", x.getCpString(i1));
        return ie;
    }

    @Override
    public Element visitConstantPoolRefAndValue(Instruction i, int i1, int i2, Void p) {
        // workaround for a potential bug in classfile
        Element ie = new Element(i.getMnemonic());
        if (i.getOpcode().equals(Opcode.IINC_W)) {
            ie.setAttr("loc", "" + i1);
            ie.setAttr("num", "" + i2);
        } else {
            ie.setAttr("ref", x.getCpString(i1));
            ie.setAttr("val", "" + i2);
        }
        return ie;
    }

    @Override
    public Element visitLocal(Instruction i, int i1, Void p) {
        Element ie = new Element(i.getMnemonic());
        ie.setAttr("loc", "" + i1);
        return ie;
    }

    @Override
    public Element visitLocalAndValue(Instruction i, int i1, int i2, Void p) {
        Element ie = new Element(i.getMnemonic());
        ie.setAttr("loc", "" + i1);
        ie.setAttr("num", "" + i2);
        return ie;
    }

    @Override
    public Element visitLookupSwitch(Instruction i, int i1, int i2, int[] ints,
                                     int[] ints1, Void p) {
        Element ie = new Element(i.getMnemonic());
        int pc = i.getPC();
        ie.setAttr("lab", "" + (pc + i1));
        for (int k = 0 ; k < i2 ; k++) {
            Element c = new Element("Case");
            c.setAttr("num", "" + (ints[k]));
            c.setAttr("lab", "" + (pc + ints1[k]));
            c.trimToSize();
            ie.add(c);
        }
        return ie;
    }

    @Override
    public Element visitTableSwitch(Instruction i, int i1, int i2, int i3,
                                    int[] ints, Void p) {
        Element ie = new Element(i.getMnemonic());
        int pc = i.getPC();
        ie.setAttr("lab", "" + (pc + i1));
        for (int k : ints) {
            Element c = new Element("Case");
            c.setAttr("num", "" + (k + i2));
            c.setAttr("lab", "" + (pc + k));
            c.trimToSize();
            ie.add(c);
        }
        return ie;
    }

    @Override
    public Element visitValue(Instruction i, int i1, Void p) {
        Element ie = new Element(i.getMnemonic());
        ie.setAttr("num", "" + i1);
        return ie;
    }

    @Override
    public Element visitUnknown(Instruction i, Void p) {
        Element e = new Element(i.getMnemonic());
        e.setAttr("pc", "" + i.getPC());
        e.setAttr("opcode", "" + i.getOpcode().opcode);
        return e;
    }
}

class AnnotationsElementVisitor implements Annotation.element_value.Visitor<Element, Element> {
    final ClassReader x;
    final ClassFile cf;

    public AnnotationsElementVisitor(ClassReader x, ClassFile cf) {
        this.x = x;
        this.cf = cf;
    }

    public Element visit(Annotation.element_value v, Element p) {
        return v.accept(this, p);
    }

    @Override
    public Element visitPrimitive(Primitive_element_value e, Element p) {
        Element el = new Element("String");
        el.setAttr("val", x.getCpString(e.const_value_index));
        el.trimToSize();
        return el;
    }

    @Override
    public Element visitEnum(Enum_element_value e, Element p) {
        Element el = new Element("Enum");
        el.setAttr("name", x.getCpString(e.const_name_index));
        el.setAttr("type", x.getCpString(e.type_name_index));
        el.trimToSize();
        return el;
    }

    @Override
    public Element visitClass(Class_element_value c, Element p) {
        Element el = new Element("Class");
        el.setAttr("name", x.getCpString(c.class_info_index));
        el.trimToSize();
        return el;
    }

    @Override
    public Element visitAnnotation(Annotation_element_value a, Element p) {
        Element el = new Element("Annotation");
        Annotation anno = a.annotation_value;
        for (Annotation.element_value_pair evp : anno.element_value_pairs) {
            Element child = visit(evp.value, el);
            if (child != null) {
                el.add(child);
            }
        }
        el.trimToSize();
        return el;
    }

    @Override
    public Element visitArray(Array_element_value a, Element p) {
     Element el = new Element("Array");
        for (Annotation.element_value v : a.values) {
           Element child = visit(v, el);
           if (child != null) {
               el.add(child);
           }
        }
        el.trimToSize();
        return el;
    }
}