Mercurial > jdk8-mips64-public > langtools / changeset

     1.1 --- a/make/build.properties	Fri May 30 11:08:40 2008 +0100
     1.2 +++ b/make/build.properties	Tue Jun 03 13:26:47 2008 -0700
     1.3 @@ -66,7 +66,7 @@
     1.4  # set the following to -version to verify the versions of javac being used
     1.5  javac.version.opt = 
     1.6  # in time, there should be no exceptions to -Xlint:all
     1.7 -javac.lint.opts = -Xlint:all,-unchecked,-deprecation,-fallthrough,-cast,-serial -Werror
     1.8 +javac.lint.opts = -Xlint:all,-deprecation,-fallthrough,-serial -Werror
     1.9  
    1.10  # options for the <javadoc> task for javac
    1.11  javadoc.jls3.url=http://java.sun.com/docs/books/jls/
    1.12 @@ -120,6 +120,8 @@
    1.13  	tools/javah/
    1.14  
    1.15  javap.includes = \
    1.16 +	com/sun/tools/classfile/ \
    1.17 +	com/sun/tools/javap/ \
    1.18  	sun/tools/javap/
    1.19  
    1.20  javap.tests = \

     2.1 --- a/make/build.xml	Fri May 30 11:08:40 2008 +0100
     2.2 +++ b/make/build.xml	Tue Jun 03 13:26:47 2008 -0700
     2.3 @@ -136,7 +136,7 @@
     2.4              <arg value="-html:${findbugs.home}/src/xsl/fancy.xsl"/>
     2.5              <arg value="${dist.findbugs.dir}/findbugs.xml"/>
     2.6              <redirector output="${dist.findbugs.dir}/findbugs.html"/>
     2.7 -        </exec>
     2.8 +        </exec>
     2.9      </target>
    2.10  
    2.11      <target name="coverage" depends="-def-cobertura,build-all-classes,instrument-classes,jtreg,coverage-report"/>
    2.12 @@ -301,14 +301,15 @@
    2.13                                jarmainclass="sun.tools.javap.Main"/>
    2.14      </target>
    2.15      
    2.16 -    <target name="build-classes-javap" depends="build-bootstrap-javac">
    2.17 +    <target name="build-classes-javap" depends="build-classes-javac">
    2.18          <build-classes name="javap" includes="${javap.includes}"/>
    2.19      </target>
    2.20      
    2.21 -    <target name="build-javap" depends="build-bootstrap-javac">
    2.22 +    <target name="build-javap" depends="build-javac">
    2.23          <build-tool name="javap"
    2.24                      includes="${javap.includes}"
    2.25 -                    jarmainclass="sun.tools.javap.Main"/>
    2.26 +                    jarmainclass="sun.tools.javap.Main"
    2.27 +                    jarclasspath="javac.jar"/>
    2.28      </target>
    2.29      
    2.30      <!-- (no javadoc for javap) -->
    2.31 @@ -480,7 +481,7 @@
    2.32                            destdir="@{gensrc.dir}"
    2.33                            includes="@{includes}"/>
    2.34                  <copy todir="@{gensrc.dir}">
    2.35 -                    <fileset dir="${src.classes.dir}" includes="${javac.includes}"/>
    2.36 +                    <fileset dir="${src.classes.dir}" includes="@{includes}"/>
    2.37                      <globmapper from="*.properties-template" to="*.properties"/>
    2.38                      <filterset begintoken="$(" endtoken=")">
    2.39                          <filter token="JDK_VERSION" value="${jdk.version}"/>

     3.1 --- a/make/netbeans/common/standard-ide-actions-no-javadoc.ent	Fri May 30 11:08:40 2008 +0100
     3.2 +++ b/make/netbeans/common/standard-ide-actions-no-javadoc.ent	Tue Jun 03 13:26:47 2008 -0700
     3.3 @@ -157,5 +157,5 @@
     3.4  </action>
     3.5  
     3.6  <action name="javadoc">
     3.7 -    <target>javadoc-nb</target>
     3.8 +    <target>-javadoc-nb</target>
     3.9  </action>

     4.1 --- a/make/netbeans/common/standard-ide-actions.ent	Fri May 30 11:08:40 2008 +0100
     4.2 +++ b/make/netbeans/common/standard-ide-actions.ent	Tue Jun 03 13:26:47 2008 -0700
     4.3 @@ -157,5 +157,5 @@
     4.4  </action>
     4.5  
     4.6  <action name="javadoc">
     4.7 -    <target>javadoc-nb</target>
     4.8 +    <target>-javadoc-nb</target>
     4.9  </action>

     5.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.2 +++ b/src/share/classes/com/sun/tools/classfile/AccessFlags.java	Tue Jun 03 13:26:47 2008 -0700
     5.3 @@ -0,0 +1,254 @@
     5.4 +/*
     5.5 + * Copyright 2007 Sun Microsystems, Inc.  All Rights Reserved.
     5.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     5.7 + *
     5.8 + * This code is free software; you can redistribute it and/or modify it
     5.9 + * under the terms of the GNU General Public License version 2 only, as
    5.10 + * published by the Free Software Foundation.  Sun designates this
    5.11 + * particular file as subject to the "Classpath" exception as provided
    5.12 + * by Sun in the LICENSE file that accompanied this code.
    5.13 + *
    5.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
    5.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    5.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    5.17 + * version 2 for more details (a copy is included in the LICENSE file that
    5.18 + * accompanied this code).
    5.19 + *
    5.20 + * You should have received a copy of the GNU General Public License version
    5.21 + * 2 along with this work; if not, write to the Free Software Foundation,
    5.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
    5.23 + *
    5.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
    5.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
    5.26 + * have any questions.
    5.27 + */
    5.28 +
    5.29 +package com.sun.tools.classfile;
    5.30 +
    5.31 +import java.io.IOException;
    5.32 +import java.util.LinkedHashSet;
    5.33 +import java.util.Set;
    5.34 +
    5.35 +/**
    5.36 + * See JVMS3, sections 4.2, 4.6, 4.7.
    5.37 + *
    5.38 + *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
    5.39 + *  you write code that depends on this, you do so at your own risk.
    5.40 + *  This code and its internal interfaces are subject to change or
    5.41 + *  deletion without notice.</b>
    5.42 + */
    5.43 +public class AccessFlags {
    5.44 +    public static final int ACC_PUBLIC        = 0x0001; // class, inner, field, method
    5.45 +    public static final int ACC_PRIVATE       = 0x0002; //        inner, field, method
    5.46 +    public static final int ACC_PROTECTED     = 0x0004; //        inner, field, method
    5.47 +    public static final int ACC_STATIC        = 0x0008; //        inner, field, method
    5.48 +    public static final int ACC_FINAL         = 0x0010; // class, inner, field, method
    5.49 +    public static final int ACC_SUPER         = 0x0020; // class
    5.50 +    public static final int ACC_SYNCHRONIZED  = 0x0020; //                      method
    5.51 +    public static final int ACC_VOLATILE      = 0x0040; //               field
    5.52 +    public static final int ACC_BRIDGE        = 0x0040; //                      method
    5.53 +    public static final int ACC_TRANSIENT     = 0x0080; //               field
    5.54 +    public static final int ACC_VARARGS       = 0x0080; //                      method
    5.55 +    public static final int ACC_NATIVE        = 0x0100; //                      method
    5.56 +    public static final int ACC_INTERFACE     = 0x0200; // class, inner
    5.57 +    public static final int ACC_ABSTRACT      = 0x0400; // class, inner,        method
    5.58 +    public static final int ACC_STRICT        = 0x0800; //                      method
    5.59 +    public static final int ACC_SYNTHETIC     = 0x1000; // class, inner, field, method
    5.60 +    public static final int ACC_ANNOTATION    = 0x2000; // class, inner
    5.61 +    public static final int ACC_ENUM          = 0x4000; // class, inner, field
    5.62 +    public static final int ACC_MODULE        = 0x8000; // class, inner, field, method
    5.63 +
    5.64 +    private static enum Type { Class, InnerClass, Field, Method};
    5.65 +
    5.66 +    AccessFlags(ClassReader cr) throws IOException {
    5.67 +        this(cr.readUnsignedShort());
    5.68 +    }
    5.69 +
    5.70 +    public AccessFlags(int flags) {
    5.71 +        this.flags = flags;
    5.72 +    }
    5.73 +
    5.74 +    public AccessFlags ignore(int mask) {
    5.75 +        return new AccessFlags(flags & ~mask);
    5.76 +    }
    5.77 +
    5.78 +    public boolean is(int mask) {
    5.79 +        return (flags & mask) != 0;
    5.80 +    }
    5.81 +
    5.82 +    private static final int[] classModifiers = {
    5.83 +        ACC_PUBLIC, ACC_FINAL, ACC_ABSTRACT, ACC_MODULE
    5.84 +    };
    5.85 +
    5.86 +    private static final int[] classFlags = {
    5.87 +        ACC_PUBLIC, ACC_FINAL, ACC_SUPER, ACC_INTERFACE, ACC_ABSTRACT,
    5.88 +        ACC_SYNTHETIC, ACC_ANNOTATION, ACC_ENUM, ACC_MODULE
    5.89 +    };
    5.90 +
    5.91 +    public Set<String> getClassModifiers() {
    5.92 +        int f = ((flags & ACC_INTERFACE) != 0 ? flags & ~ACC_ABSTRACT : flags);
    5.93 +        return getModifiers(f, classModifiers, Type.Class);
    5.94 +    }
    5.95 +
    5.96 +    public Set<String> getClassFlags() {
    5.97 +        return getFlags(classFlags, Type.Class);
    5.98 +    }
    5.99 +
   5.100 +    private static final int[] innerClassModifiers = {
   5.101 +        ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL,
   5.102 +        ACC_ABSTRACT, ACC_MODULE
   5.103 +    };
   5.104 +
   5.105 +    private static final int[] innerClassFlags = {
   5.106 +        ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL, ACC_SUPER,
   5.107 +        ACC_INTERFACE, ACC_ABSTRACT, ACC_SYNTHETIC, ACC_ANNOTATION, ACC_ENUM, ACC_MODULE
   5.108 +    };
   5.109 +
   5.110 +    public Set<String> getInnerClassModifiers() {
   5.111 +        int f = ((flags & ACC_INTERFACE) != 0 ? flags & ~ACC_ABSTRACT : flags);
   5.112 +        return getModifiers(f, innerClassModifiers, Type.InnerClass);
   5.113 +    }
   5.114 +
   5.115 +    public Set<String> getInnerClassFlags() {
   5.116 +        return getFlags(innerClassFlags, Type.InnerClass);
   5.117 +    }
   5.118 +
   5.119 +    private static final int[] fieldModifiers = {
   5.120 +        ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL,
   5.121 +        ACC_VOLATILE, ACC_TRANSIENT, ACC_MODULE
   5.122 +    };
   5.123 +
   5.124 +    private static final int[] fieldFlags = {
   5.125 +        ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL,
   5.126 +        ACC_VOLATILE, ACC_TRANSIENT, ACC_SYNTHETIC, ACC_ENUM, ACC_MODULE
   5.127 +    };
   5.128 +
   5.129 +    public Set<String> getFieldModifiers() {
   5.130 +        return getModifiers(fieldModifiers, Type.Field);
   5.131 +    }
   5.132 +
   5.133 +    public Set<String> getFieldFlags() {
   5.134 +        return getFlags(fieldFlags, Type.Field);
   5.135 +    }
   5.136 +
   5.137 +    private static final int[] methodModifiers = {
   5.138 +        ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL,
   5.139 +        ACC_SYNCHRONIZED, ACC_NATIVE, ACC_ABSTRACT, ACC_STRICT, ACC_MODULE
   5.140 +    };
   5.141 +
   5.142 +    private static final int[] methodFlags = {
   5.143 +        ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL,
   5.144 +        ACC_SYNCHRONIZED, ACC_BRIDGE, ACC_VARARGS, ACC_NATIVE, ACC_ABSTRACT,
   5.145 +        ACC_STRICT, ACC_SYNTHETIC, ACC_MODULE
   5.146 +    };
   5.147 +
   5.148 +    public Set<String> getMethodModifiers() {
   5.149 +        return getModifiers(methodModifiers, Type.Method);
   5.150 +    }
   5.151 +
   5.152 +    public Set<String> getMethodFlags() {
   5.153 +        return getFlags(methodFlags, Type.Method);
   5.154 +    }
   5.155 +
   5.156 +    private Set<String> getModifiers(int[] modifierFlags, Type t) {
   5.157 +        return getModifiers(flags, modifierFlags, t);
   5.158 +    }
   5.159 +
   5.160 +    private static Set<String> getModifiers(int flags, int[] modifierFlags, Type t) {
   5.161 +        Set<String> s = new LinkedHashSet<String>();
   5.162 +        for (int m: modifierFlags) {
   5.163 +            if ((flags & m) != 0)
   5.164 +                s.add(flagToModifier(m, t));
   5.165 +        }
   5.166 +        return s;
   5.167 +    }
   5.168 +
   5.169 +    private Set<String> getFlags(int[] expectedFlags, Type t) {
   5.170 +        Set<String> s = new LinkedHashSet<String>();
   5.171 +        int f = flags;
   5.172 +        for (int e: expectedFlags) {
   5.173 +            if ((f & e) != 0) {
   5.174 +                s.add(flagToName(e, t));
   5.175 +                f = f & ~e;
   5.176 +            }
   5.177 +        }
   5.178 +        while (f != 0) {
   5.179 +            int bit = Integer.highestOneBit(f);
   5.180 +            s.add("0x" + Integer.toHexString(bit));
   5.181 +            f = f & ~bit;
   5.182 +        }
   5.183 +        return s;
   5.184 +    }
   5.185 +
   5.186 +    private static String flagToModifier(int flag, Type t) {
   5.187 +        switch (flag) {
   5.188 +            case ACC_PUBLIC:
   5.189 +                return "public";
   5.190 +            case ACC_PRIVATE:
   5.191 +                return "private";
   5.192 +            case ACC_PROTECTED:
   5.193 +                return "protected";
   5.194 +            case ACC_STATIC:
   5.195 +                return "static";
   5.196 +            case ACC_FINAL:
   5.197 +                return "final";
   5.198 +            case ACC_SYNCHRONIZED:
   5.199 +                return "synchronized";
   5.200 +            case 0x80:
   5.201 +                return (t == Type.Field ? "transient" : null);
   5.202 +            case ACC_VOLATILE:
   5.203 +                return "volatile";
   5.204 +            case ACC_NATIVE:
   5.205 +                return "native";
   5.206 +            case ACC_ABSTRACT:
   5.207 +                return "abstract";
   5.208 +            case ACC_STRICT:
   5.209 +                return "strictfp";
   5.210 +            case ACC_MODULE:
   5.211 +                return "module";
   5.212 +            default:
   5.213 +                return null;
   5.214 +        }
   5.215 +    }
   5.216 +
   5.217 +    private static String flagToName(int flag, Type t) {
   5.218 +        switch (flag) {
   5.219 +        case ACC_PUBLIC:
   5.220 +            return "ACC_PUBLIC";
   5.221 +        case ACC_PRIVATE:
   5.222 +            return "ACC_PRIVATE";
   5.223 +        case ACC_PROTECTED:
   5.224 +            return "ACC_PROTECTED";
   5.225 +        case ACC_STATIC:
   5.226 +            return "ACC_STATIC";
   5.227 +        case ACC_FINAL:
   5.228 +            return "ACC_FINAL";
   5.229 +        case 0x20:
   5.230 +            return (t == Type.Class ? "ACC_SUPER" : "ACC_SYNCHRONIZED");
   5.231 +        case 0x40:
   5.232 +            return (t == Type.Field ? "ACC_VOLATILE" : "ACC_BRIDGE");
   5.233 +        case 0x80:
   5.234 +            return (t == Type.Field ? "ACC_TRANSIENT" : "ACC_VARARGS");
   5.235 +        case ACC_NATIVE:
   5.236 +            return "ACC_NATIVE";
   5.237 +        case ACC_INTERFACE:
   5.238 +            return "ACC_INTERFACE";
   5.239 +        case ACC_ABSTRACT:
   5.240 +            return "ACC_ABSTRACT";
   5.241 +        case ACC_STRICT:
   5.242 +            return "ACC_STRICT";
   5.243 +        case ACC_SYNTHETIC:
   5.244 +            return "ACC_SYNTHETIC";
   5.245 +        case ACC_ANNOTATION:
   5.246 +            return "ACC_ANNOTATION";
   5.247 +        case ACC_ENUM:
   5.248 +            return "ACC_ENUM";
   5.249 +        case ACC_MODULE:
   5.250 +            return "ACC_MODULE";
   5.251 +        default:
   5.252 +            return null;
   5.253 +        }
   5.254 +    }
   5.255 +
   5.256 +    final int flags;
   5.257 +}

     6.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.2 +++ b/src/share/classes/com/sun/tools/classfile/Annotation.java	Tue Jun 03 13:26:47 2008 -0700
     6.3 @@ -0,0 +1,243 @@
     6.4 +/*
     6.5 + * Copyright 2007 Sun Microsystems, Inc.  All Rights Reserved.
     6.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     6.7 + *
     6.8 + * This code is free software; you can redistribute it and/or modify it
     6.9 + * under the terms of the GNU General Public License version 2 only, as
    6.10 + * published by the Free Software Foundation.  Sun designates this
    6.11 + * particular file as subject to the "Classpath" exception as provided
    6.12 + * by Sun in the LICENSE file that accompanied this code.
    6.13 + *
    6.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
    6.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    6.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    6.17 + * version 2 for more details (a copy is included in the LICENSE file that
    6.18 + * accompanied this code).
    6.19 + *
    6.20 + * You should have received a copy of the GNU General Public License version
    6.21 + * 2 along with this work; if not, write to the Free Software Foundation,
    6.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
    6.23 + *
    6.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
    6.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
    6.26 + * have any questions.
    6.27 + */
    6.28 +
    6.29 +package com.sun.tools.classfile;
    6.30 +
    6.31 +import java.io.IOException;
    6.32 +
    6.33 +/**
    6.34 + * See JVMS3, section 4.8.16.
    6.35 + *
    6.36 + *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
    6.37 + *  you write code that depends on this, you do so at your own risk.
    6.38 + *  This code and its internal interfaces are subject to change or
    6.39 + *  deletion without notice.</b>
    6.40 + */
    6.41 +public class Annotation {
    6.42 +    static class InvalidAnnotation extends AttributeException {
    6.43 +        InvalidAnnotation(String msg) {
    6.44 +            super(msg);
    6.45 +        }
    6.46 +    }
    6.47 +
    6.48 +    Annotation(ClassReader cr) throws IOException, InvalidAnnotation {
    6.49 +        type_index = cr.readUnsignedShort();
    6.50 +        num_element_value_pairs = cr.readUnsignedShort();
    6.51 +        element_value_pairs = new element_value_pair[num_element_value_pairs];
    6.52 +        for (int i = 0; i < element_value_pairs.length; i++)
    6.53 +            element_value_pairs[i] = new element_value_pair(cr);
    6.54 +    }
    6.55 +
    6.56 +    public Annotation(ConstantPool constant_pool,
    6.57 +            int type_index,
    6.58 +            element_value_pair[] element_value_pairs) {
    6.59 +        this.type_index = type_index;
    6.60 +        num_element_value_pairs = element_value_pairs.length;
    6.61 +        this.element_value_pairs = element_value_pairs;
    6.62 +    }
    6.63 +
    6.64 +    public int length() {
    6.65 +        int n = 2 /*type_index*/ + 2 /*num_element_value_pairs*/;
    6.66 +        for (element_value_pair pair: element_value_pairs)
    6.67 +            n += pair.length();
    6.68 +        return n;
    6.69 +    }
    6.70 +
    6.71 +    public final int type_index;
    6.72 +    public final int num_element_value_pairs;
    6.73 +    public final element_value_pair element_value_pairs[];
    6.74 +
    6.75 +    /**
    6.76 +     * See JVMS3, section 4.8.16.1.
    6.77 +     */
    6.78 +    public static abstract class element_value {
    6.79 +        public static element_value read(ClassReader cr)
    6.80 +                throws IOException, InvalidAnnotation {
    6.81 +            int tag = cr.readUnsignedByte();
    6.82 +            switch (tag) {
    6.83 +            case 'B':
    6.84 +            case 'C':
    6.85 +            case 'D':
    6.86 +            case 'F':
    6.87 +            case 'I':
    6.88 +            case 'J':
    6.89 +            case 'S':
    6.90 +            case 'Z':
    6.91 +            case 's':
    6.92 +                return new Primitive_element_value(cr, tag);
    6.93 +
    6.94 +            case 'e':
    6.95 +                return new Enum_element_value(cr, tag);
    6.96 +
    6.97 +            case 'c':
    6.98 +                return new Class_element_value(cr, tag);
    6.99 +
   6.100 +            case '@':
   6.101 +                return new Annotation_element_value(cr, tag);
   6.102 +
   6.103 +            case '[':
   6.104 +                return new Array_element_value(cr, tag);
   6.105 +
   6.106 +            default:
   6.107 +                throw new InvalidAnnotation("unrecognized tag: " + tag);
   6.108 +            }
   6.109 +        }
   6.110 +
   6.111 +        protected element_value(int tag) {
   6.112 +            this.tag = tag;
   6.113 +        }
   6.114 +
   6.115 +        public abstract int length();
   6.116 +
   6.117 +        public abstract <R,P> R accept(Visitor<R,P> visitor, P p);
   6.118 +
   6.119 +        public interface Visitor<R,P> {
   6.120 +            R visitPrimitive(Primitive_element_value ev, P p);
   6.121 +            R visitEnum(Enum_element_value ev, P p);
   6.122 +            R visitClass(Class_element_value ev, P p);
   6.123 +            R visitAnnotation(Annotation_element_value ev, P p);
   6.124 +            R visitArray(Array_element_value ev, P p);
   6.125 +        }
   6.126 +
   6.127 +        public final int tag;
   6.128 +    }
   6.129 +
   6.130 +    public static class Primitive_element_value extends element_value {
   6.131 +        Primitive_element_value(ClassReader cr, int tag) throws IOException {
   6.132 +            super(tag);
   6.133 +            const_value_index = cr.readUnsignedShort();
   6.134 +        }
   6.135 +
   6.136 +        @Override
   6.137 +        public int length() {
   6.138 +            return 2;
   6.139 +        }
   6.140 +
   6.141 +        public <R,P> R accept(Visitor<R,P> visitor, P p) {
   6.142 +            return visitor.visitPrimitive(this, p);
   6.143 +        }
   6.144 +
   6.145 +        public final int const_value_index;
   6.146 +
   6.147 +    }
   6.148 +
   6.149 +    public static class Enum_element_value extends element_value {
   6.150 +        Enum_element_value(ClassReader cr, int tag) throws IOException {
   6.151 +            super(tag);
   6.152 +            type_name_index = cr.readUnsignedShort();
   6.153 +            const_name_index = cr.readUnsignedShort();
   6.154 +        }
   6.155 +
   6.156 +        @Override
   6.157 +        public int length() {
   6.158 +            return 4;
   6.159 +        }
   6.160 +
   6.161 +        public <R,P> R accept(Visitor<R,P> visitor, P p) {
   6.162 +            return visitor.visitEnum(this, p);
   6.163 +        }
   6.164 +
   6.165 +        public final int type_name_index;
   6.166 +        public final int const_name_index;
   6.167 +    }
   6.168 +
   6.169 +    public static class Class_element_value extends element_value {
   6.170 +        Class_element_value(ClassReader cr, int tag) throws IOException {
   6.171 +            super(tag);
   6.172 +            class_info_index = cr.readUnsignedShort();
   6.173 +        }
   6.174 +
   6.175 +        @Override
   6.176 +        public int length() {
   6.177 +            return 2;
   6.178 +        }
   6.179 +
   6.180 +        public <R,P> R accept(Visitor<R,P> visitor, P p) {
   6.181 +            return visitor.visitClass(this, p);
   6.182 +        }
   6.183 +
   6.184 +        public final int class_info_index;
   6.185 +    }
   6.186 +
   6.187 +    public static class Annotation_element_value extends element_value {
   6.188 +        Annotation_element_value(ClassReader cr, int tag)
   6.189 +                throws IOException, InvalidAnnotation {
   6.190 +            super(tag);
   6.191 +            annotation_value = new Annotation(cr);
   6.192 +        }
   6.193 +
   6.194 +        @Override
   6.195 +        public int length() {
   6.196 +            return annotation_value.length();
   6.197 +        }
   6.198 +
   6.199 +        public <R,P> R accept(Visitor<R,P> visitor, P p) {
   6.200 +            return visitor.visitAnnotation(this, p);
   6.201 +        }
   6.202 +
   6.203 +        public final Annotation annotation_value;
   6.204 +    }
   6.205 +
   6.206 +    public static class Array_element_value extends element_value {
   6.207 +        Array_element_value(ClassReader cr, int tag)
   6.208 +                throws IOException, InvalidAnnotation {
   6.209 +            super(tag);
   6.210 +            num_values = cr.readUnsignedShort();
   6.211 +            values = new element_value[num_values];
   6.212 +            for (int i = 0; i < values.length; i++)
   6.213 +                values[i] = element_value.read(cr);
   6.214 +        }
   6.215 +
   6.216 +        @Override
   6.217 +        public int length() {
   6.218 +            int n = 2;
   6.219 +            for (int i = 0; i < values.length; i++)
   6.220 +                n += values[i].length();
   6.221 +            return n;
   6.222 +        }
   6.223 +
   6.224 +        public <R,P> R accept(Visitor<R,P> visitor, P p) {
   6.225 +            return visitor.visitArray(this, p);
   6.226 +        }
   6.227 +
   6.228 +        public final int num_values;
   6.229 +        public final element_value[] values;
   6.230 +    }
   6.231 +
   6.232 +    public static class element_value_pair {
   6.233 +        element_value_pair(ClassReader cr)
   6.234 +                throws IOException, InvalidAnnotation {
   6.235 +            element_name_index = cr.readUnsignedShort();
   6.236 +            value = element_value.read(cr);
   6.237 +        }
   6.238 +
   6.239 +        public int length() {
   6.240 +            return 2 + value.length();
   6.241 +        }
   6.242 +
   6.243 +        public final int element_name_index;
   6.244 +        public final element_value value;
   6.245 +    }
   6.246 +}

     7.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.2 +++ b/src/share/classes/com/sun/tools/classfile/AnnotationDefault_attribute.java	Tue Jun 03 13:26:47 2008 -0700
     7.3 @@ -0,0 +1,61 @@
     7.4 +/*
     7.5 + * Copyright 2007 Sun Microsystems, Inc.  All Rights Reserved.
     7.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     7.7 + *
     7.8 + * This code is free software; you can redistribute it and/or modify it
     7.9 + * under the terms of the GNU General Public License version 2 only, as
    7.10 + * published by the Free Software Foundation.  Sun designates this
    7.11 + * particular file as subject to the "Classpath" exception as provided
    7.12 + * by Sun in the LICENSE file that accompanied this code.
    7.13 + *
    7.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
    7.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    7.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    7.17 + * version 2 for more details (a copy is included in the LICENSE file that
    7.18 + * accompanied this code).
    7.19 + *
    7.20 + * You should have received a copy of the GNU General Public License version
    7.21 + * 2 along with this work; if not, write to the Free Software Foundation,
    7.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
    7.23 + *
    7.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
    7.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
    7.26 + * have any questions.
    7.27 + */
    7.28 +
    7.29 +package com.sun.tools.classfile;
    7.30 +
    7.31 +import java.io.IOException;
    7.32 +
    7.33 +/**
    7.34 + * See JVMS3, section 4.8.15.
    7.35 + *
    7.36 + *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
    7.37 + *  you write code that depends on this, you do so at your own risk.
    7.38 + *  This code and its internal interfaces are subject to change or
    7.39 + *  deletion without notice.</b>
    7.40 + */
    7.41 +public class AnnotationDefault_attribute extends Attribute {
    7.42 +    AnnotationDefault_attribute(ClassReader cr, int name_index, int length)
    7.43 +            throws IOException, Annotation.InvalidAnnotation {
    7.44 +        super(name_index, length);
    7.45 +        default_value = Annotation.element_value.read(cr);
    7.46 +    }
    7.47 +
    7.48 +    public AnnotationDefault_attribute(ConstantPool constant_pool, Annotation.element_value default_value)
    7.49 +            throws ConstantPoolException {
    7.50 +        this(constant_pool.getUTF8Index(Attribute.AnnotationDefault), default_value);
    7.51 +    }
    7.52 +
    7.53 +    public AnnotationDefault_attribute(int name_index, Annotation.element_value default_value) {
    7.54 +        super(name_index, default_value.length());
    7.55 +        this.default_value = default_value;
    7.56 +    }
    7.57 +
    7.58 +    public <R, D> R accept(Visitor<R, D> visitor, D data) {
    7.59 +        return visitor.visitAnnotationDefault(this, data);
    7.60 +    }
    7.61 +
    7.62 +    public final Annotation.element_value default_value;
    7.63 +}
    7.64 +

     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/src/share/classes/com/sun/tools/classfile/Attribute.java	Tue Jun 03 13:26:47 2008 -0700
     8.3 @@ -0,0 +1,199 @@
     8.4 +/*
     8.5 + * Copyright 2007 Sun Microsystems, Inc.  All Rights Reserved.
     8.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     8.7 + *
     8.8 + * This code is free software; you can redistribute it and/or modify it
     8.9 + * under the terms of the GNU General Public License version 2 only, as
    8.10 + * published by the Free Software Foundation.  Sun designates this
    8.11 + * particular file as subject to the "Classpath" exception as provided
    8.12 + * by Sun in the LICENSE file that accompanied this code.
    8.13 + *
    8.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
    8.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    8.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    8.17 + * version 2 for more details (a copy is included in the LICENSE file that
    8.18 + * accompanied this code).
    8.19 + *
    8.20 + * You should have received a copy of the GNU General Public License version
    8.21 + * 2 along with this work; if not, write to the Free Software Foundation,
    8.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
    8.23 + *
    8.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
    8.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
    8.26 + * have any questions.
    8.27 + */
    8.28 +
    8.29 +package com.sun.tools.classfile;
    8.30 +
    8.31 +import java.io.IOException;
    8.32 +import java.lang.reflect.Constructor;
    8.33 +import java.util.HashMap;
    8.34 +import java.util.Map;
    8.35 +
    8.36 +/**
    8.37 + *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
    8.38 + *  you write code that depends on this, you do so at your own risk.
    8.39 + *  This code and its internal interfaces are subject to change or
    8.40 + *  deletion without notice.</b>
    8.41 + */
    8.42 +
    8.43 +public abstract class Attribute {
    8.44 +    public static final String AnnotationDefault        = "AnnotationDefault";
    8.45 +    public static final String CharacterRangeTable      = "CharacterRangeTable";
    8.46 +    public static final String Code                     = "Code";
    8.47 +    public static final String ConstantValue            = "ConstantValue";
    8.48 +    public static final String CompilationID            = "CompilationID";
    8.49 +    public static final String Deprecated               = "Deprecated";
    8.50 +    public static final String EnclosingMethod          = "EnclosingMethod";
    8.51 +    public static final String Exceptions               = "Exceptions";
    8.52 +    public static final String InnerClasses             = "InnerClasses";
    8.53 +    public static final String LineNumberTable          = "LineNumberTable";
    8.54 +    public static final String LocalVariableTable       = "LocalVariableTable";
    8.55 +    public static final String LocalVariableTypeTable   = "LocalVariableTypeTable";
    8.56 +    public static final String RuntimeVisibleAnnotations = "RuntimeVisibleAnnotations";
    8.57 +    public static final String RuntimeInvisibleAnnotations = "RuntimeInvisibleAnnotations";
    8.58 +    public static final String RuntimeVisibleParameterAnnotations = "RuntimeVisibleParameterAnnotations";
    8.59 +    public static final String RuntimeInvisibleParameterAnnotations = "RuntimeInvisibleParameterAnnotations";
    8.60 +    public static final String Signature                = "Signature";
    8.61 +    public static final String SourceDebugExtension     = "SourceDebugExtension";
    8.62 +    public static final String SourceFile               = "SourceFile";
    8.63 +    public static final String SourceID                 = "SourceID";
    8.64 +    public static final String StackMap                 = "StackMap";
    8.65 +    public static final String StackMapTable            = "StackMapTable";
    8.66 +    public static final String Synthetic                = "Synthetic";
    8.67 +
    8.68 +    // JSR 277/294
    8.69 +    public static final String Module                   = "Module";
    8.70 +    public static final String ModuleExportTable        = "ModuleExportTable";
    8.71 +    public static final String ModuleMemberTable        = "ModuleMemberTable";
    8.72 +
    8.73 +    public static class Factory {
    8.74 +        public Factory() {
    8.75 +            // defer init of standardAttributeClasses until after options set up
    8.76 +        }
    8.77 +
    8.78 +        public void setCompat(boolean compat) {
    8.79 +            this.compat = compat;
    8.80 +        }
    8.81 +
    8.82 +        public void setJSR277(boolean jsr277) {
    8.83 +            this.jsr277 = jsr277;
    8.84 +        }
    8.85 +
    8.86 +        public Attribute createAttribute(ClassReader cr, int name_index, byte[] data)
    8.87 +                throws IOException {
    8.88 +            if (standardAttributes == null)
    8.89 +                init();
    8.90 +
    8.91 +            ConstantPool cp = cr.getConstantPool();
    8.92 +            try {
    8.93 +                String name = cp.getUTF8Value(name_index);
    8.94 +                Class<? extends Attribute> attrClass = standardAttributes.get(name);
    8.95 +                if (attrClass != null) {
    8.96 +                    try {
    8.97 +                        Class<?>[] constrArgTypes = {ClassReader.class, int.class, int.class};
    8.98 +                        Constructor<? extends Attribute> constr = attrClass.getDeclaredConstructor(constrArgTypes);
    8.99 +                        return constr.newInstance(new Object[] { cr, name_index, data.length });
   8.100 +                    } catch (Throwable t) {
   8.101 +                        // fall through and use DefaultAttribute
   8.102 +                        // t.printStackTrace();
   8.103 +                    }
   8.104 +                }
   8.105 +            } catch (ConstantPoolException e) {
   8.106 +                // fall through and use DefaultAttribute
   8.107 +            }
   8.108 +            return new DefaultAttribute(cr, name_index, data);
   8.109 +        }
   8.110 +
   8.111 +        protected void init() {
   8.112 +            standardAttributes = new HashMap<String,Class<? extends Attribute>>();
   8.113 +            standardAttributes.put(AnnotationDefault, AnnotationDefault_attribute.class);
   8.114 +            standardAttributes.put(CharacterRangeTable, CharacterRangeTable_attribute.class);
   8.115 +            standardAttributes.put(Code,              Code_attribute.class);
   8.116 +            standardAttributes.put(ConstantValue,     ConstantValue_attribute.class);
   8.117 +            standardAttributes.put(Deprecated,        Deprecated_attribute.class);
   8.118 +            standardAttributes.put(EnclosingMethod,   EnclosingMethod_attribute.class);
   8.119 +            standardAttributes.put(Exceptions,        Exceptions_attribute.class);
   8.120 +            standardAttributes.put(InnerClasses,      InnerClasses_attribute.class);
   8.121 +            standardAttributes.put(LineNumberTable,   LineNumberTable_attribute.class);
   8.122 +            standardAttributes.put(LocalVariableTable, LocalVariableTable_attribute.class);
   8.123 +            standardAttributes.put(LocalVariableTypeTable, LocalVariableTypeTable_attribute.class);
   8.124 +
   8.125 +            if (jsr277) {
   8.126 +                standardAttributes.put(Module,            Module_attribute.class);
   8.127 +                standardAttributes.put(ModuleExportTable, ModuleExportTable_attribute.class);
   8.128 +                standardAttributes.put(ModuleMemberTable, ModuleMemberTable_attribute.class);
   8.129 +            }
   8.130 +
   8.131 +            if (!compat) { // old javap does not recognize recent attributes
   8.132 +                standardAttributes.put(CompilationID, CompilationID_attribute.class);
   8.133 +                standardAttributes.put(RuntimeInvisibleAnnotations, RuntimeInvisibleAnnotations_attribute.class);
   8.134 +                standardAttributes.put(RuntimeInvisibleParameterAnnotations, RuntimeInvisibleParameterAnnotations_attribute.class);
   8.135 +                standardAttributes.put(RuntimeVisibleAnnotations, RuntimeVisibleAnnotations_attribute.class);
   8.136 +                standardAttributes.put(RuntimeVisibleParameterAnnotations, RuntimeVisibleParameterAnnotations_attribute.class);
   8.137 +                standardAttributes.put(Signature,     Signature_attribute.class);
   8.138 +                standardAttributes.put(SourceID, SourceID_attribute.class);
   8.139 +            }
   8.140 +
   8.141 +            standardAttributes.put(SourceDebugExtension, SourceDebugExtension_attribute.class);
   8.142 +            standardAttributes.put(SourceFile,        SourceFile_attribute.class);
   8.143 +            standardAttributes.put(StackMap,          StackMap_attribute.class);
   8.144 +            standardAttributes.put(StackMapTable,     StackMapTable_attribute.class);
   8.145 +            standardAttributes.put(Synthetic,         Synthetic_attribute.class);
   8.146 +        }
   8.147 +
   8.148 +        private Map<String,Class<? extends Attribute>> standardAttributes;
   8.149 +        private boolean compat; // don't support recent attrs in compatibility mode
   8.150 +        private boolean jsr277; // support new jsr277 attrs
   8.151 +    }
   8.152 +
   8.153 +    public static Attribute read(ClassReader cr) throws IOException {
   8.154 +        return cr.readAttribute();
   8.155 +    }
   8.156 +
   8.157 +    protected Attribute(int name_index, int length) {
   8.158 +        attribute_name_index = name_index;
   8.159 +        attribute_length = length;
   8.160 +    }
   8.161 +
   8.162 +    public String getName(ConstantPool constant_pool) throws ConstantPoolException {
   8.163 +        return constant_pool.getUTF8Value(attribute_name_index);
   8.164 +    }
   8.165 +
   8.166 +    public abstract <R,D> R accept(Attribute.Visitor<R,D> visitor, D data);
   8.167 +
   8.168 +    public final int attribute_name_index;
   8.169 +    public final int attribute_length;
   8.170 +
   8.171 +
   8.172 +    public interface Visitor<R,P> {
   8.173 +        R visitDefault(DefaultAttribute attr, P p);
   8.174 +        R visitAnnotationDefault(AnnotationDefault_attribute attr, P p);
   8.175 +        R visitCharacterRangeTable(CharacterRangeTable_attribute attr, P p);
   8.176 +        R visitCode(Code_attribute attr, P p);
   8.177 +        R visitCompilationID(CompilationID_attribute attr, P p);
   8.178 +        R visitConstantValue(ConstantValue_attribute attr, P p);
   8.179 +        R visitDeprecated(Deprecated_attribute attr, P p);
   8.180 +        R visitEnclosingMethod(EnclosingMethod_attribute attr, P p);
   8.181 +        R visitExceptions(Exceptions_attribute attr, P p);
   8.182 +        R visitInnerClasses(InnerClasses_attribute attr, P p);
   8.183 +        R visitLineNumberTable(LineNumberTable_attribute attr, P p);
   8.184 +        R visitLocalVariableTable(LocalVariableTable_attribute attr, P p);
   8.185 +        R visitLocalVariableTypeTable(LocalVariableTypeTable_attribute attr, P p);
   8.186 +        R visitRuntimeVisibleAnnotations(RuntimeVisibleAnnotations_attribute attr, P p);
   8.187 +        R visitRuntimeInvisibleAnnotations(RuntimeInvisibleAnnotations_attribute attr, P p);
   8.188 +        R visitRuntimeVisibleParameterAnnotations(RuntimeVisibleParameterAnnotations_attribute attr, P p);
   8.189 +        R visitRuntimeInvisibleParameterAnnotations(RuntimeInvisibleParameterAnnotations_attribute attr, P p);
   8.190 +        R visitSignature(Signature_attribute attr, P p);
   8.191 +        R visitSourceDebugExtension(SourceDebugExtension_attribute attr, P p);
   8.192 +        R visitSourceFile(SourceFile_attribute attr, P p);
   8.193 +        R visitSourceID(SourceID_attribute attr, P p);
   8.194 +        R visitStackMap(StackMap_attribute attr, P p);
   8.195 +        R visitStackMapTable(StackMapTable_attribute attr, P p);
   8.196 +        R visitSynthetic(Synthetic_attribute attr, P p);
   8.197 +
   8.198 +        R visitModule(Module_attribute attr, P p);
   8.199 +        R visitModuleExportTable(ModuleExportTable_attribute attr, P p);
   8.200 +        R visitModuleMemberTable(ModuleMemberTable_attribute attr, P p);
   8.201 +    }
   8.202 +}

     9.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     9.2 +++ b/src/share/classes/com/sun/tools/classfile/AttributeException.java	Tue Jun 03 13:26:47 2008 -0700
     9.3 @@ -0,0 +1,40 @@
     9.4 +/*
     9.5 + * Copyright 2008 Sun Microsystems, Inc.  All Rights Reserved.
     9.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     9.7 + *
     9.8 + * This code is free software; you can redistribute it and/or modify it
     9.9 + * under the terms of the GNU General Public License version 2 only, as
    9.10 + * published by the Free Software Foundation.  Sun designates this
    9.11 + * particular file as subject to the "Classpath" exception as provided
    9.12 + * by Sun in the LICENSE file that accompanied this code.
    9.13 + *
    9.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
    9.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    9.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    9.17 + * version 2 for more details (a copy is included in the LICENSE file that
    9.18 + * accompanied this code).
    9.19 + *
    9.20 + * You should have received a copy of the GNU General Public License version
    9.21 + * 2 along with this work; if not, write to the Free Software Foundation,
    9.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
    9.23 + *
    9.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
    9.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
    9.26 + * have any questions.
    9.27 + */
    9.28 +
    9.29 +package com.sun.tools.classfile;
    9.30 +
    9.31 +/*
    9.32 + *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
    9.33 + *  you write code that depends on this, you do so at your own risk.
    9.34 + *  This code and its internal interfaces are subject to change or
    9.35 + *  deletion without notice.</b>
    9.36 + */
    9.37 +public class AttributeException extends Exception {
    9.38 +    AttributeException() { }
    9.39 +
    9.40 +    AttributeException(String msg) {
    9.41 +        super(msg);
    9.42 +    }
    9.43 +}

    10.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    10.2 +++ b/src/share/classes/com/sun/tools/classfile/Attributes.java	Tue Jun 03 13:26:47 2008 -0700
    10.3 @@ -0,0 +1,87 @@
    10.4 +/*
    10.5 + * Copyright 2007 Sun Microsystems, Inc.  All Rights Reserved.
    10.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    10.7 + *
    10.8 + * This code is free software; you can redistribute it and/or modify it
    10.9 + * under the terms of the GNU General Public License version 2 only, as
   10.10 + * published by the Free Software Foundation.  Sun designates this
   10.11 + * particular file as subject to the "Classpath" exception as provided
   10.12 + * by Sun in the LICENSE file that accompanied this code.
   10.13 + *
   10.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   10.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   10.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   10.17 + * version 2 for more details (a copy is included in the LICENSE file that
   10.18 + * accompanied this code).
   10.19 + *
   10.20 + * You should have received a copy of the GNU General Public License version
   10.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   10.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   10.23 + *
   10.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
   10.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
   10.26 + * have any questions.
   10.27 + */
   10.28 +
   10.29 +package com.sun.tools.classfile;
   10.30 +
   10.31 +import java.io.IOException;
   10.32 +import java.util.Arrays;
   10.33 +import java.util.HashMap;
   10.34 +import java.util.Iterator;
   10.35 +import java.util.Map;
   10.36 +
   10.37 +/*
   10.38 + *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
   10.39 + *  you write code that depends on this, you do so at your own risk.
   10.40 + *  This code and its internal interfaces are subject to change or
   10.41 + *  deletion without notice.</b>
   10.42 + */
   10.43 +public class Attributes implements Iterable<Attribute> {
   10.44 +    Attributes(ClassReader cr) throws IOException {
   10.45 +        map = new HashMap<String,Attribute>();
   10.46 +        int attrs_count = cr.readUnsignedShort();
   10.47 +        attrs = new Attribute[attrs_count];
   10.48 +        for (int i = 0; i < attrs_count; i++) {
   10.49 +            Attribute attr = Attribute.read(cr);
   10.50 +            attrs[i] = attr;
   10.51 +            try {
   10.52 +                map.put(attr.getName(cr.getConstantPool()), attr);
   10.53 +            } catch (ConstantPoolException e) {
   10.54 +                // don't enter invalid names in map
   10.55 +            }
   10.56 +        }
   10.57 +    }
   10.58 +
   10.59 +    public Attributes(ConstantPool constant_pool, Attribute[] attrs) {
   10.60 +        this.attrs = attrs;
   10.61 +        map = new HashMap<String,Attribute>();
   10.62 +        for (int i = 0; i < attrs.length; i++) {
   10.63 +            Attribute attr = attrs[i];
   10.64 +            try {
   10.65 +                map.put(attr.getName(constant_pool), attr);
   10.66 +            } catch (ConstantPoolException e) {
   10.67 +                // don't enter invalid names in map
   10.68 +            }
   10.69 +        }
   10.70 +    }
   10.71 +
   10.72 +    public Iterator<Attribute> iterator() {
   10.73 +        return Arrays.asList(attrs).iterator();
   10.74 +    }
   10.75 +
   10.76 +    public Attribute get(int index) {
   10.77 +        return attrs[index];
   10.78 +    }
   10.79 +
   10.80 +    public Attribute get(String name) {
   10.81 +        return map.get(name);
   10.82 +    }
   10.83 +
   10.84 +    public int size() {
   10.85 +        return attrs.length;
   10.86 +    }
   10.87 +
   10.88 +    public final Attribute[] attrs;
   10.89 +    public final Map<String, Attribute> map;
   10.90 +}

    11.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    11.2 +++ b/src/share/classes/com/sun/tools/classfile/CharacterRangeTable_attribute.java	Tue Jun 03 13:26:47 2008 -0700
    11.3 @@ -0,0 +1,90 @@
    11.4 +/*
    11.5 + * Copyright 2007 Sun Microsystems, Inc.  All Rights Reserved.
    11.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    11.7 + *
    11.8 + * This code is free software; you can redistribute it and/or modify it
    11.9 + * under the terms of the GNU General Public License version 2 only, as
   11.10 + * published by the Free Software Foundation.  Sun designates this
   11.11 + * particular file as subject to the "Classpath" exception as provided
   11.12 + * by Sun in the LICENSE file that accompanied this code.
   11.13 + *
   11.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   11.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   11.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   11.17 + * version 2 for more details (a copy is included in the LICENSE file that
   11.18 + * accompanied this code).
   11.19 + *
   11.20 + * You should have received a copy of the GNU General Public License version
   11.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   11.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   11.23 + *
   11.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
   11.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
   11.26 + * have any questions.
   11.27 + */
   11.28 +
   11.29 +package com.sun.tools.classfile;
   11.30 +
   11.31 +import java.io.IOException;
   11.32 +
   11.33 +/**
   11.34 + *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
   11.35 + *  you write code that depends on this, you do so at your own risk.
   11.36 + *  This code and its internal interfaces are subject to change or
   11.37 + *  deletion without notice.</b>
   11.38 + */
   11.39 +public class CharacterRangeTable_attribute  extends Attribute {
   11.40 +    public static final int CRT_STATEMENT       = 0x0001;
   11.41 +    public static final int CRT_BLOCK           = 0x0002;
   11.42 +    public static final int CRT_ASSIGNMENT      = 0x0004;
   11.43 +    public static final int CRT_FLOW_CONTROLLER = 0x0008;
   11.44 +    public static final int CRT_FLOW_TARGET     = 0x0010;
   11.45 +    public static final int CRT_INVOKE          = 0x0020;
   11.46 +    public static final int CRT_CREATE          = 0x0040;
   11.47 +    public static final int CRT_BRANCH_TRUE     = 0x0080;
   11.48 +    public static final int CRT_BRANCH_FALSE    = 0x0100;
   11.49 +
   11.50 +    CharacterRangeTable_attribute(ClassReader cr, int name_index, int length) throws IOException {
   11.51 +        super(name_index, length);
   11.52 +        int character_range_table_length = cr.readUnsignedShort();
   11.53 +        character_range_table = new Entry[character_range_table_length];
   11.54 +        for (int i = 0; i < character_range_table_length; i++)
   11.55 +            character_range_table[i] = new Entry(cr);
   11.56 +    }
   11.57 +
   11.58 +    public CharacterRangeTable_attribute(ConstantPool constant_pool, Entry[] character_range_table)
   11.59 +            throws ConstantPoolException {
   11.60 +        this(constant_pool.getUTF8Index(Attribute.CharacterRangeTable), character_range_table);
   11.61 +    }
   11.62 +
   11.63 +    public CharacterRangeTable_attribute(int name_index, Entry[] character_range_table) {
   11.64 +        super(name_index, character_range_table.length * Entry.length());
   11.65 +        this.character_range_table = character_range_table;
   11.66 +    }
   11.67 +
   11.68 +    public <R, D> R accept(Visitor<R, D> visitor, D data) {
   11.69 +        return visitor.visitCharacterRangeTable(this, data);
   11.70 +    }
   11.71 +
   11.72 +    public final Entry[] character_range_table;
   11.73 +
   11.74 +    public static class Entry {
   11.75 +        Entry(ClassReader cr) throws IOException {
   11.76 +            start_pc = cr.readUnsignedShort();
   11.77 +            end_pc = cr.readUnsignedShort();
   11.78 +            character_range_start = cr.readInt();
   11.79 +            character_range_end = cr.readInt();
   11.80 +            flags = cr.readUnsignedShort();
   11.81 +        }
   11.82 +
   11.83 +        public static int length() {
   11.84 +            return 14;
   11.85 +        }
   11.86 +
   11.87 +        public final int start_pc;
   11.88 +        public final int end_pc;
   11.89 +        public final int character_range_start;
   11.90 +        public final int character_range_end;
   11.91 +        public final int flags;
   11.92 +    };
   11.93 +}

    12.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    12.2 +++ b/src/share/classes/com/sun/tools/classfile/ClassFile.java	Tue Jun 03 13:26:47 2008 -0700
    12.3 @@ -0,0 +1,153 @@
    12.4 +/*
    12.5 + * Copyright 2007 Sun Microsystems, Inc.  All Rights Reserved.
    12.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    12.7 + *
    12.8 + * This code is free software; you can redistribute it and/or modify it
    12.9 + * under the terms of the GNU General Public License version 2 only, as
   12.10 + * published by the Free Software Foundation.  Sun designates this
   12.11 + * particular file as subject to the "Classpath" exception as provided
   12.12 + * by Sun in the LICENSE file that accompanied this code.
   12.13 + *
   12.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   12.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   12.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   12.17 + * version 2 for more details (a copy is included in the LICENSE file that
   12.18 + * accompanied this code).
   12.19 + *
   12.20 + * You should have received a copy of the GNU General Public License version
   12.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   12.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   12.23 + *
   12.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
   12.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
   12.26 + * have any questions.
   12.27 + */
   12.28 +
   12.29 +package com.sun.tools.classfile;
   12.30 +
   12.31 +import java.io.File;
   12.32 +import java.io.FileInputStream;
   12.33 +import java.io.IOException;
   12.34 +import java.io.InputStream;
   12.35 +
   12.36 +import static com.sun.tools.classfile.AccessFlags.*;
   12.37 +
   12.38 +/**
   12.39 + * See JVMS3, section 4.2.
   12.40 + *
   12.41 + *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
   12.42 + *  you write code that depends on this, you do so at your own risk.
   12.43 + *  This code and its internal interfaces are subject to change or
   12.44 + *  deletion without notice.</b>
   12.45 + */
   12.46 +public class ClassFile {
   12.47 +    public static ClassFile read(File file)
   12.48 +            throws IOException, ConstantPoolException {
   12.49 +        return read(file, new Attribute.Factory());
   12.50 +    }
   12.51 +
   12.52 +    public static ClassFile read(File file, Attribute.Factory attributeFactory)
   12.53 +            throws IOException, ConstantPoolException {
   12.54 +        FileInputStream in = new FileInputStream(file);
   12.55 +        try {
   12.56 +            return new ClassFile(in, attributeFactory);
   12.57 +        } finally {
   12.58 +            try {
   12.59 +                in.close();
   12.60 +            } catch (IOException e) {
   12.61 +                // ignore
   12.62 +            }
   12.63 +        }
   12.64 +    }
   12.65 +
   12.66 +    public static ClassFile read(InputStream in)
   12.67 +            throws IOException, ConstantPoolException {
   12.68 +        return new ClassFile(in, new Attribute.Factory());
   12.69 +    }
   12.70 +
   12.71 +    public static ClassFile read(InputStream in, Attribute.Factory attributeFactory)
   12.72 +            throws IOException, ConstantPoolException {
   12.73 +        return new ClassFile(in, attributeFactory);
   12.74 +    }
   12.75 +
   12.76 +    ClassFile(InputStream in, Attribute.Factory attributeFactory) throws IOException, ConstantPoolException {
   12.77 +        ClassReader cr = new ClassReader(this, in, attributeFactory);
   12.78 +        magic = cr.readInt();
   12.79 +        minor_version = cr.readUnsignedShort();
   12.80 +        major_version = cr.readUnsignedShort();
   12.81 +        constant_pool = new ConstantPool(cr);
   12.82 +        access_flags = new AccessFlags(cr);
   12.83 +        this_class = cr.readUnsignedShort();
   12.84 +        super_class = cr.readUnsignedShort();
   12.85 +
   12.86 +        int interfaces_count = cr.readUnsignedShort();
   12.87 +        interfaces = new int[interfaces_count];
   12.88 +        for (int i = 0; i < interfaces_count; i++)
   12.89 +            interfaces[i] = cr.readUnsignedShort();
   12.90 +
   12.91 +        int fields_count = cr.readUnsignedShort();
   12.92 +        fields = new Field[fields_count];
   12.93 +        for (int i = 0; i < fields_count; i++)
   12.94 +            fields[i] = new Field(cr);
   12.95 +
   12.96 +        int methods_count = cr.readUnsignedShort();
   12.97 +        methods = new Method[methods_count];
   12.98 +        for (int i = 0; i < methods_count; i++)
   12.99 +            methods[i] = new Method(cr);
  12.100 +
  12.101 +        attributes = new Attributes(cr);
  12.102 +    }
  12.103 +
  12.104 +    public ClassFile(int magic, int minor_version, int major_version,
  12.105 +            ConstantPool constant_pool, AccessFlags access_flags,
  12.106 +            int this_class, int super_class, int[] interfaces,
  12.107 +            Field[] fields, Method[] methods, Attributes attributes) {
  12.108 +        this.magic = magic;
  12.109 +        this.minor_version = minor_version;
  12.110 +        this.major_version = major_version;
  12.111 +        this.constant_pool = constant_pool;
  12.112 +        this.access_flags = access_flags;
  12.113 +        this.this_class = this_class;
  12.114 +        this.super_class = super_class;
  12.115 +        this.interfaces = interfaces;
  12.116 +        this.fields = fields;
  12.117 +        this.methods = methods;
  12.118 +        this.attributes = attributes;
  12.119 +    }
  12.120 +
  12.121 +    public String getName() throws ConstantPoolException {
  12.122 +        return constant_pool.getClassInfo(this_class).getName();
  12.123 +    }
  12.124 +
  12.125 +    public String getSuperclassName() throws ConstantPoolException {
  12.126 +        return constant_pool.getClassInfo(super_class).getName();
  12.127 +    }
  12.128 +
  12.129 +    public String getInterfaceName(int i) throws ConstantPoolException {
  12.130 +        return constant_pool.getClassInfo(interfaces[i]).getName();
  12.131 +    }
  12.132 +
  12.133 +    public Attribute getAttribute(String name) {
  12.134 +        return attributes.get(name);
  12.135 +    }
  12.136 +
  12.137 +    public boolean isClass() {
  12.138 +        return !isInterface();
  12.139 +    }
  12.140 +
  12.141 +    public boolean isInterface() {
  12.142 +        return access_flags.is(ACC_INTERFACE);
  12.143 +    }
  12.144 +
  12.145 +    public final int magic;
  12.146 +    public final int minor_version;
  12.147 +    public final int major_version;
  12.148 +    public final ConstantPool constant_pool;
  12.149 +    public final AccessFlags access_flags;
  12.150 +    public final int this_class;
  12.151 +    public final int super_class;
  12.152 +    public final int[] interfaces;
  12.153 +    public final Field[] fields;
  12.154 +    public final Method[] methods;
  12.155 +    public final Attributes attributes;
  12.156 +}

    13.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    13.2 +++ b/src/share/classes/com/sun/tools/classfile/ClassReader.java	Tue Jun 03 13:26:47 2008 -0700
    13.3 @@ -0,0 +1,109 @@
    13.4 +/*
    13.5 + * Copyright 2007 Sun Microsystems, Inc.  All Rights Reserved.
    13.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    13.7 + *
    13.8 + * This code is free software; you can redistribute it and/or modify it
    13.9 + * under the terms of the GNU General Public License version 2 only, as
   13.10 + * published by the Free Software Foundation.  Sun designates this
   13.11 + * particular file as subject to the "Classpath" exception as provided
   13.12 + * by Sun in the LICENSE file that accompanied this code.
   13.13 + *
   13.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   13.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   13.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   13.17 + * version 2 for more details (a copy is included in the LICENSE file that
   13.18 + * accompanied this code).
   13.19 + *
   13.20 + * You should have received a copy of the GNU General Public License version
   13.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   13.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   13.23 + *
   13.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
   13.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
   13.26 + * have any questions.
   13.27 + */
   13.28 +
   13.29 +package com.sun.tools.classfile;
   13.30 +
   13.31 +import java.io.BufferedInputStream;
   13.32 +import java.io.ByteArrayInputStream;
   13.33 +import java.io.DataInputStream;
   13.34 +import java.io.IOException;
   13.35 +import java.io.InputStream;
   13.36 +
   13.37 +/**
   13.38 + *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
   13.39 + *  you write code that depends on this, you do so at your own risk.
   13.40 + *  This code and its internal interfaces are subject to change or
   13.41 + *  deletion without notice.</b>
   13.42 + */
   13.43 +public class ClassReader {
   13.44 +    ClassReader(ClassFile classFile, InputStream in, Attribute.Factory attributeFactory) throws IOException {
   13.45 +        // null checks
   13.46 +        classFile.getClass();
   13.47 +        attributeFactory.getClass();
   13.48 +
   13.49 +        this.classFile = classFile;
   13.50 +        this.in = new DataInputStream(new BufferedInputStream(in));
   13.51 +        this.attributeFactory = attributeFactory;
   13.52 +    }
   13.53 +
   13.54 +    ClassFile getClassFile() {
   13.55 +        return classFile;
   13.56 +    }
   13.57 +
   13.58 +    ConstantPool getConstantPool() {
   13.59 +        return classFile.constant_pool;
   13.60 +    }
   13.61 +
   13.62 +    public Attribute readAttribute() throws IOException {
   13.63 +        int name_index = readUnsignedShort();
   13.64 +        int length = readInt();
   13.65 +        byte[] data = new byte[length];
   13.66 +        readFully(data);
   13.67 +
   13.68 +        DataInputStream prev = in;
   13.69 +        in = new DataInputStream(new ByteArrayInputStream(data));
   13.70 +        try {
   13.71 +            return attributeFactory.createAttribute(this, name_index, data);
   13.72 +        } finally {
   13.73 +            in = prev;
   13.74 +        }
   13.75 +    }
   13.76 +
   13.77 +    public void readFully(byte[] b) throws IOException {
   13.78 +        in.readFully(b);
   13.79 +    }
   13.80 +
   13.81 +    public int readUnsignedByte() throws IOException {
   13.82 +        return in.readUnsignedByte();
   13.83 +    }
   13.84 +
   13.85 +    public int readUnsignedShort() throws IOException {
   13.86 +        return in.readUnsignedShort();
   13.87 +    }
   13.88 +
   13.89 +    public int readInt() throws IOException {
   13.90 +        return in.readInt();
   13.91 +    }
   13.92 +
   13.93 +    public long readLong() throws IOException {
   13.94 +        return in.readLong();
   13.95 +    }
   13.96 +
   13.97 +    public float readFloat() throws IOException {
   13.98 +        return in.readFloat();
   13.99 +    }
  13.100 +
  13.101 +    public double readDouble() throws IOException {
  13.102 +        return in.readDouble();
  13.103 +    }
  13.104 +
  13.105 +    public String readUTF() throws IOException {
  13.106 +        return in.readUTF();
  13.107 +    }
  13.108 +
  13.109 +    private DataInputStream in;
  13.110 +    private ClassFile classFile;
  13.111 +    private Attribute.Factory attributeFactory;
  13.112 +}

    14.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    14.2 +++ b/src/share/classes/com/sun/tools/classfile/ClassTranslator.java	Tue Jun 03 13:26:47 2008 -0700
    14.3 @@ -0,0 +1,368 @@
    14.4 +/*
    14.5 + * Copyright 2008 Sun Microsystems, Inc.  All Rights Reserved.
    14.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    14.7 + *
    14.8 + * This code is free software; you can redistribute it and/or modify it
    14.9 + * under the terms of the GNU General Public License version 2 only, as
   14.10 + * published by the Free Software Foundation.  Sun designates this
   14.11 + * particular file as subject to the "Classpath" exception as provided
   14.12 + * by Sun in the LICENSE file that accompanied this code.
   14.13 + *
   14.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   14.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   14.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   14.17 + * version 2 for more details (a copy is included in the LICENSE file that
   14.18 + * accompanied this code).
   14.19 + *
   14.20 + * You should have received a copy of the GNU General Public License version
   14.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   14.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   14.23 + *
   14.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
   14.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
   14.26 + * have any questions.
   14.27 + */
   14.28 +
   14.29 +package com.sun.tools.classfile;
   14.30 +
   14.31 +import com.sun.tools.classfile.ConstantPool.CONSTANT_Class_info;
   14.32 +import com.sun.tools.classfile.ConstantPool.CONSTANT_Double_info;
   14.33 +import com.sun.tools.classfile.ConstantPool.CONSTANT_Fieldref_info;
   14.34 +import com.sun.tools.classfile.ConstantPool.CONSTANT_Float_info;
   14.35 +import com.sun.tools.classfile.ConstantPool.CONSTANT_Integer_info;
   14.36 +import com.sun.tools.classfile.ConstantPool.CONSTANT_InterfaceMethodref_info;
   14.37 +import com.sun.tools.classfile.ConstantPool.CONSTANT_Long_info;
   14.38 +import com.sun.tools.classfile.ConstantPool.CONSTANT_Methodref_info;
   14.39 +import com.sun.tools.classfile.ConstantPool.CONSTANT_NameAndType_info;
   14.40 +import com.sun.tools.classfile.ConstantPool.CONSTANT_String_info;
   14.41 +import com.sun.tools.classfile.ConstantPool.CONSTANT_Utf8_info;
   14.42 +import com.sun.tools.classfile.ConstantPool.CPInfo;
   14.43 +import java.util.Map;
   14.44 +
   14.45 +/**
   14.46 + * Rewrites a class file using a map of translations.
   14.47 + *
   14.48 + *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
   14.49 + *  you write code that depends on this, you do so at your own risk.
   14.50 + *  This code and its internal interfaces are subject to change or
   14.51 + *  deletion without notice.</b>
   14.52 + */
   14.53 +public class ClassTranslator
   14.54 +        implements ConstantPool.Visitor<ConstantPool.CPInfo,Map<Object,Object>> {
   14.55 +    /**
   14.56 +     * Create a new ClassFile from {@code cf}, such that for all entries
   14.57 +     * {@code k&nbsp;-\&gt;&nbsp;v} in {@code translations},
   14.58 +     * each occurrence of {@code k} in {@code cf} will be replaced by {@code v}.
   14.59 +     * in
   14.60 +     * @param cf the class file to be processed
   14.61 +     * @param translations the set of translations to be applied
   14.62 +     * @return a copy of {@code} with the values in {@code translations} substituted
   14.63 +     */
   14.64 +    public ClassFile translate(ClassFile cf, Map<Object,Object> translations) {
   14.65 +        ClassFile cf2 = (ClassFile) translations.get(cf);
   14.66 +        if (cf2 == null) {
   14.67 +            ConstantPool constant_pool2 = translate(cf.constant_pool, translations);
   14.68 +            Field[] fields2 = translate(cf.fields, cf.constant_pool, translations);
   14.69 +            Method[] methods2 = translateMethods(cf.methods, cf.constant_pool, translations);
   14.70 +            Attributes attributes2 = translateAttributes(cf.attributes, cf.constant_pool,
   14.71 +                    translations);
   14.72 +
   14.73 +            if (constant_pool2 == cf.constant_pool &&
   14.74 +                    fields2 == cf.fields &&
   14.75 +                    methods2 == cf.methods &&
   14.76 +                    attributes2 == cf.attributes)
   14.77 +                cf2 = cf;
   14.78 +            else
   14.79 +                cf2 = new ClassFile(
   14.80 +                        cf.magic,
   14.81 +                        cf.minor_version,
   14.82 +                        cf.major_version,
   14.83 +                        constant_pool2,
   14.84 +                        cf.access_flags,
   14.85 +                        cf.this_class,
   14.86 +                        cf.super_class,
   14.87 +                        cf.interfaces,
   14.88 +                        fields2,
   14.89 +                        methods2,
   14.90 +                        attributes2);
   14.91 +            translations.put(cf, cf2);
   14.92 +        }
   14.93 +        return cf2;
   14.94 +    }
   14.95 +
   14.96 +    ConstantPool translate(ConstantPool cp, Map<Object,Object> translations) {
   14.97 +        ConstantPool cp2 = (ConstantPool) translations.get(cp);
   14.98 +        if (cp2 == null) {
   14.99 +            ConstantPool.CPInfo[] pool2 = new ConstantPool.CPInfo[cp.size()];
  14.100 +            boolean eq = true;
  14.101 +            for (int i = 0; i < cp.size(); i++) {
  14.102 +                ConstantPool.CPInfo cpInfo;
  14.103 +                try {
  14.104 +                    cpInfo = cp.get(i);
  14.105 +                } catch (ConstantPool.InvalidIndex e) {
  14.106 +                    throw new IllegalStateException(e);
  14.107 +                }
  14.108 +                ConstantPool.CPInfo cpInfo2 = translate(cpInfo, translations);
  14.109 +                eq &= (cpInfo == cpInfo2);
  14.110 +                pool2[i] = cpInfo2;
  14.111 +                if (cpInfo.getTag() != cpInfo2.getTag())
  14.112 +                    throw new IllegalStateException();
  14.113 +                switch (cpInfo.getTag()) {
  14.114 +                    case ConstantPool.CONSTANT_Double:
  14.115 +                    case ConstantPool.CONSTANT_Long:
  14.116 +                        i += 1;
  14.117 +                }
  14.118 +            }
  14.119 +
  14.120 +            if (eq)
  14.121 +                cp2 = cp;
  14.122 +            else
  14.123 +                cp2 = new ConstantPool(pool2);
  14.124 +
  14.125 +            translations.put(cp, cp2);
  14.126 +        }
  14.127 +        return cp2;
  14.128 +    }
  14.129 +
  14.130 +    ConstantPool.CPInfo translate(ConstantPool.CPInfo cpInfo, Map<Object,Object> translations) {
  14.131 +        ConstantPool.CPInfo cpInfo2 = (ConstantPool.CPInfo) translations.get(cpInfo);
  14.132 +        if (cpInfo2 == null) {
  14.133 +            cpInfo2 = cpInfo.accept(this, translations);
  14.134 +            translations.put(cpInfo, cpInfo2);
  14.135 +        }
  14.136 +        return cpInfo2;
  14.137 +    }
  14.138 +
  14.139 +    Field[] translate(Field[] fields, ConstantPool constant_pool, Map<Object,Object> translations) {
  14.140 +        Field[] fields2 = (Field[]) translations.get(fields);
  14.141 +        if (fields2 == null) {
  14.142 +            fields2 = new Field[fields.length];
  14.143 +            for (int i = 0; i < fields.length; i++)
  14.144 +                fields2[i] = translate(fields[i], constant_pool, translations);
  14.145 +            if (equal(fields, fields2))
  14.146 +                fields2 = fields;
  14.147 +            translations.put(fields, fields2);
  14.148 +        }
  14.149 +        return fields2;
  14.150 +    }
  14.151 +
  14.152 +    Field translate(Field field, ConstantPool constant_pool, Map<Object,Object> translations) {
  14.153 +        Field field2 = (Field) translations.get(field);
  14.154 +        if (field2 == null) {
  14.155 +            Attributes attributes2 = translateAttributes(field.attributes, constant_pool,
  14.156 +                    translations);
  14.157 +
  14.158 +            if (attributes2 == field.attributes)
  14.159 +                field2 = field;
  14.160 +            else
  14.161 +                field2 = new Field(
  14.162 +                        field.access_flags,
  14.163 +                        field.name_index,
  14.164 +                        field.descriptor,
  14.165 +                        attributes2);
  14.166 +            translations.put(field, field2);
  14.167 +        }
  14.168 +        return field2;
  14.169 +    }
  14.170 +
  14.171 +    Method[] translateMethods(Method[] methods, ConstantPool constant_pool, Map<Object,Object> translations) {
  14.172 +        Method[] methods2 = (Method[]) translations.get(methods);
  14.173 +        if (methods2 == null) {
  14.174 +            methods2 = new Method[methods.length];
  14.175 +            for (int i = 0; i < methods.length; i++)
  14.176 +                methods2[i] = translate(methods[i], constant_pool, translations);
  14.177 +            if (equal(methods, methods2))
  14.178 +                methods2 = methods;
  14.179 +            translations.put(methods, methods2);
  14.180 +        }
  14.181 +        return methods2;
  14.182 +    }
  14.183 +
  14.184 +    Method translate(Method method, ConstantPool constant_pool, Map<Object,Object> translations) {
  14.185 +        Method method2 = (Method) translations.get(method);
  14.186 +        if (method2 == null) {
  14.187 +            Attributes attributes2 = translateAttributes(method.attributes, constant_pool,
  14.188 +                    translations);
  14.189 +
  14.190 +            if (attributes2 == method.attributes)
  14.191 +                method2 = method;
  14.192 +            else
  14.193 +                method2 = new Method(
  14.194 +                        method.access_flags,
  14.195 +                        method.name_index,
  14.196 +                        method.descriptor,
  14.197 +                        attributes2);
  14.198 +            translations.put(method, method2);
  14.199 +        }
  14.200 +        return method2;
  14.201 +    }
  14.202 +
  14.203 +    Attributes translateAttributes(Attributes attributes,
  14.204 +            ConstantPool constant_pool, Map<Object,Object> translations) {
  14.205 +        Attributes attributes2 = (Attributes) translations.get(attributes);
  14.206 +        if (attributes2 == null) {
  14.207 +            Attribute[] attrArray2 = new Attribute[attributes.size()];
  14.208 +            ConstantPool constant_pool2 = translate(constant_pool, translations);
  14.209 +            boolean attrsEqual = true;
  14.210 +            for (int i = 0; i < attributes.size(); i++) {
  14.211 +                Attribute attr = attributes.get(i);
  14.212 +                Attribute attr2 = translate(attr, translations);
  14.213 +                if (attr2 != attr)
  14.214 +                    attrsEqual = false;
  14.215 +                attrArray2[i] = attr2;
  14.216 +            }
  14.217 +            if ((constant_pool2 == constant_pool) && attrsEqual)
  14.218 +                attributes2 = attributes;
  14.219 +            else
  14.220 +                attributes2 = new Attributes(constant_pool2, attrArray2);
  14.221 +            translations.put(attributes, attributes2);
  14.222 +        }
  14.223 +        return attributes2;
  14.224 +    }
  14.225 +
  14.226 +    Attribute translate(Attribute attribute, Map<Object,Object> translations) {
  14.227 +        Attribute attribute2 = (Attribute) translations.get(attribute);
  14.228 +        if (attribute2 == null) {
  14.229 +            attribute2 = attribute; // don't support translation within attributes yet
  14.230 +                                    // (what about Code attribute)
  14.231 +            translations.put(attribute, attribute2);
  14.232 +        }
  14.233 +        return attribute2;
  14.234 +    }
  14.235 +
  14.236 +    private static <T> boolean equal(T[] a1, T[] a2) {
  14.237 +        if (a1 == null || a2 == null)
  14.238 +            return (a1 == a2);
  14.239 +        if (a1.length != a2.length)
  14.240 +            return false;
  14.241 +        for (int i = 0; i < a1.length; i++) {
  14.242 +            if (a1[i] != a2[i])
  14.243 +                return false;
  14.244 +        }
  14.245 +        return true;
  14.246 +    }
  14.247 +
  14.248 +    public CPInfo visitClass(CONSTANT_Class_info info, Map<Object, Object> translations) {
  14.249 +        CONSTANT_Class_info info2 = (CONSTANT_Class_info) translations.get(info);
  14.250 +        if (info2 == null) {
  14.251 +            ConstantPool cp2 = translate(info.cp, translations);
  14.252 +            if (cp2 == info.cp)
  14.253 +                info2 = info;
  14.254 +            else
  14.255 +                info2 = new CONSTANT_Class_info(cp2, info.name_index);
  14.256 +            translations.put(info, info2);
  14.257 +        }
  14.258 +        return info;
  14.259 +    }
  14.260 +
  14.261 +    public CPInfo visitDouble(CONSTANT_Double_info info, Map<Object, Object> translations) {
  14.262 +        CONSTANT_Double_info info2 = (CONSTANT_Double_info) translations.get(info);
  14.263 +        if (info2 == null) {
  14.264 +            info2 = info;
  14.265 +            translations.put(info, info2);
  14.266 +        }
  14.267 +        return info;
  14.268 +    }
  14.269 +
  14.270 +    public CPInfo visitFieldref(CONSTANT_Fieldref_info info, Map<Object, Object> translations) {
  14.271 +        CONSTANT_Fieldref_info info2 = (CONSTANT_Fieldref_info) translations.get(info);
  14.272 +        if (info2 == null) {
  14.273 +            ConstantPool cp2 = translate(info.cp, translations);
  14.274 +            if (cp2 == info.cp)
  14.275 +                info2 = info;
  14.276 +            else
  14.277 +                info2 = new CONSTANT_Fieldref_info(cp2, info.class_index, info.name_and_type_index);
  14.278 +            translations.put(info, info2);
  14.279 +        }
  14.280 +        return info;
  14.281 +    }
  14.282 +
  14.283 +    public CPInfo visitFloat(CONSTANT_Float_info info, Map<Object, Object> translations) {
  14.284 +        CONSTANT_Float_info info2 = (CONSTANT_Float_info) translations.get(info);
  14.285 +        if (info2 == null) {
  14.286 +            info2 = info;
  14.287 +            translations.put(info, info2);
  14.288 +        }
  14.289 +        return info;
  14.290 +    }
  14.291 +
  14.292 +    public CPInfo visitInteger(CONSTANT_Integer_info info, Map<Object, Object> translations) {
  14.293 +        CONSTANT_Integer_info info2 = (CONSTANT_Integer_info) translations.get(info);
  14.294 +        if (info2 == null) {
  14.295 +            info2 = info;
  14.296 +            translations.put(info, info2);
  14.297 +        }
  14.298 +        return info;
  14.299 +    }
  14.300 +
  14.301 +    public CPInfo visitInterfaceMethodref(CONSTANT_InterfaceMethodref_info info, Map<Object, Object> translations) {
  14.302 +        CONSTANT_InterfaceMethodref_info info2 = (CONSTANT_InterfaceMethodref_info) translations.get(info);
  14.303 +        if (info2 == null) {
  14.304 +            ConstantPool cp2 = translate(info.cp, translations);
  14.305 +            if (cp2 == info.cp)
  14.306 +                info2 = info;
  14.307 +            else
  14.308 +                info2 = new CONSTANT_InterfaceMethodref_info(cp2, info.class_index, info.name_and_type_index);
  14.309 +            translations.put(info, info2);
  14.310 +        }
  14.311 +        return info;
  14.312 +    }
  14.313 +
  14.314 +    public CPInfo visitLong(CONSTANT_Long_info info, Map<Object, Object> translations) {
  14.315 +        CONSTANT_Long_info info2 = (CONSTANT_Long_info) translations.get(info);
  14.316 +        if (info2 == null) {
  14.317 +            info2 = info;
  14.318 +            translations.put(info, info2);
  14.319 +        }
  14.320 +        return info;
  14.321 +    }
  14.322 +
  14.323 +    public CPInfo visitNameAndType(CONSTANT_NameAndType_info info, Map<Object, Object> translations) {
  14.324 +        CONSTANT_NameAndType_info info2 = (CONSTANT_NameAndType_info) translations.get(info);
  14.325 +        if (info2 == null) {
  14.326 +            ConstantPool cp2 = translate(info.cp, translations);
  14.327 +            if (cp2 == info.cp)
  14.328 +                info2 = info;
  14.329 +            else
  14.330 +                info2 = new CONSTANT_NameAndType_info(cp2, info.name_index, info.type_index);
  14.331 +            translations.put(info, info2);
  14.332 +        }
  14.333 +        return info;
  14.334 +    }
  14.335 +
  14.336 +    public CPInfo visitMethodref(CONSTANT_Methodref_info info, Map<Object, Object> translations) {
  14.337 +        CONSTANT_Methodref_info info2 = (CONSTANT_Methodref_info) translations.get(info);
  14.338 +        if (info2 == null) {
  14.339 +            ConstantPool cp2 = translate(info.cp, translations);
  14.340 +            if (cp2 == info.cp)
  14.341 +                info2 = info;
  14.342 +            else
  14.343 +                info2 = new CONSTANT_Methodref_info(cp2, info.class_index, info.name_and_type_index);
  14.344 +            translations.put(info, info2);
  14.345 +        }
  14.346 +        return info;
  14.347 +    }
  14.348 +
  14.349 +    public CPInfo visitString(CONSTANT_String_info info, Map<Object, Object> translations) {
  14.350 +        CONSTANT_String_info info2 = (CONSTANT_String_info) translations.get(info);
  14.351 +        if (info2 == null) {
  14.352 +            ConstantPool cp2 = translate(info.cp, translations);
  14.353 +            if (cp2 == info.cp)
  14.354 +                info2 = info;
  14.355 +            else
  14.356 +                info2 = new CONSTANT_String_info(cp2, info.string_index);
  14.357 +            translations.put(info, info2);
  14.358 +        }
  14.359 +        return info;
  14.360 +    }
  14.361 +
  14.362 +    public CPInfo visitUtf8(CONSTANT_Utf8_info info, Map<Object, Object> translations) {
  14.363 +        CONSTANT_Utf8_info info2 = (CONSTANT_Utf8_info) translations.get(info);
  14.364 +        if (info2 == null) {
  14.365 +            info2 = info;
  14.366 +            translations.put(info, info2);
  14.367 +        }
  14.368 +        return info;
  14.369 +    }
  14.370 +
  14.371 +}

    15.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    15.2 +++ b/src/share/classes/com/sun/tools/classfile/ClassWriter.java	Tue Jun 03 13:26:47 2008 -0700
    15.3 @@ -0,0 +1,689 @@
    15.4 +/*
    15.5 + * Copyright 2008 Sun Microsystems, Inc.  All Rights Reserved.
    15.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    15.7 + *
    15.8 + * This code is free software; you can redistribute it and/or modify it
    15.9 + * under the terms of the GNU General Public License version 2 only, as
   15.10 + * published by the Free Software Foundation.  Sun designates this
   15.11 + * particular file as subject to the "Classpath" exception as provided
   15.12 + * by Sun in the LICENSE file that accompanied this code.
   15.13 + *
   15.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   15.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   15.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   15.17 + * version 2 for more details (a copy is included in the LICENSE file that
   15.18 + * accompanied this code).
   15.19 + *
   15.20 + * You should have received a copy of the GNU General Public License version
   15.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   15.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   15.23 + *
   15.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
   15.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
   15.26 + * have any questions.
   15.27 + */
   15.28 +
   15.29 +package com.sun.tools.classfile;
   15.30 +
   15.31 +import java.io.ByteArrayOutputStream;
   15.32 +import java.io.DataOutputStream;
   15.33 +import java.io.File;
   15.34 +import java.io.FileOutputStream;
   15.35 +import java.io.IOException;
   15.36 +import java.io.OutputStream;
   15.37 +
   15.38 +import static com.sun.tools.classfile.Annotation.*;
   15.39 +import static com.sun.tools.classfile.ConstantPool.*;
   15.40 +import static com.sun.tools.classfile.StackMapTable_attribute.*;
   15.41 +import static com.sun.tools.classfile.StackMapTable_attribute.verification_type_info.*;
   15.42 +
   15.43 +/**
   15.44 + * Write a ClassFile data structure to a file or stream.
   15.45 + *
   15.46 + *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
   15.47 + *  you write code that depends on this, you do so at your own risk.
   15.48 + *  This code and its internal interfaces are subject to change or
   15.49 + *  deletion without notice.</b>
   15.50 + */
   15.51 +public class ClassWriter {
   15.52 +    public ClassWriter() {
   15.53 +        attributeWriter = new AttributeWriter();
   15.54 +        constantPoolWriter = new ConstantPoolWriter();
   15.55 +        out = new ClassOutputStream();
   15.56 +    }
   15.57 +
   15.58 +    /**
   15.59 +     * Write a ClassFile data structure to a file.
   15.60 +     */
   15.61 +    public void write(ClassFile classFile, File f) throws IOException {
   15.62 +        FileOutputStream f_out = new FileOutputStream(f);
   15.63 +        try {
   15.64 +            write(classFile, f_out);
   15.65 +        } finally {
   15.66 +            f_out.close();
   15.67 +        }
   15.68 +    }
   15.69 +
   15.70 +    /**
   15.71 +     * Write a ClassFile data structure to a stream.
   15.72 +     */
   15.73 +    public void write(ClassFile classFile, OutputStream s) throws IOException {
   15.74 +        this.classFile = classFile;
   15.75 +        out.reset();
   15.76 +        write();
   15.77 +        out.writeTo(s);
   15.78 +    }
   15.79 +
   15.80 +    protected void write() throws IOException {
   15.81 +        writeHeader();
   15.82 +        writeConstantPool();
   15.83 +        writeAccessFlags(classFile.access_flags);
   15.84 +        writeClassInfo();
   15.85 +        writeFields();
   15.86 +        writeMethods();
   15.87 +        writeAttributes(classFile.attributes);
   15.88 +    }
   15.89 +
   15.90 +    protected void writeHeader() {
   15.91 +        out.writeInt(classFile.magic);
   15.92 +        out.writeShort(classFile.minor_version);
   15.93 +        out.writeShort(classFile.major_version);
   15.94 +    }
   15.95 +
   15.96 +    protected void writeAccessFlags(AccessFlags flags) {
   15.97 +        out.writeShort(flags.flags);
   15.98 +    }
   15.99 +
  15.100 +    protected void writeAttributes(Attributes attributes) {
  15.101 +        int size = attributes.size();
  15.102 +        out.writeShort(size);
  15.103 +        for (Attribute attr: attributes)
  15.104 +            attributeWriter.write(attr, out);
  15.105 +    }
  15.106 +
  15.107 +    protected void writeClassInfo() {
  15.108 +        out.writeShort(classFile.this_class);
  15.109 +        out.writeShort(classFile.super_class);
  15.110 +        int[] interfaces = classFile.interfaces;
  15.111 +        out.writeShort(interfaces.length);
  15.112 +        for (int i: interfaces)
  15.113 +            out.writeShort(i);
  15.114 +    }
  15.115 +
  15.116 +    protected void writeDescriptor(Descriptor d) {
  15.117 +        out.writeShort(d.index);
  15.118 +    }
  15.119 +
  15.120 +    protected void writeConstantPool() {
  15.121 +        ConstantPool pool = classFile.constant_pool;
  15.122 +        int size = pool.size();
  15.123 +        out.writeShort(size);
  15.124 +        try {
  15.125 +            for (int i = 1; i < size; ) {
  15.126 +                i += constantPoolWriter.write(pool.get(i), out);
  15.127 +            }
  15.128 +        } catch (ConstantPoolException e) {
  15.129 +            throw new Error(e); // ??
  15.130 +        }
  15.131 +    }
  15.132 +
  15.133 +    protected void writeFields() throws IOException {
  15.134 +        Field[] fields = classFile.fields;
  15.135 +        out.writeShort(fields.length);
  15.136 +        for (Field f: fields)
  15.137 +            writeField(f);
  15.138 +    }
  15.139 +
  15.140 +    protected void writeField(Field f) throws IOException {
  15.141 +        writeAccessFlags(f.access_flags);
  15.142 +        out.writeShort(f.name_index);
  15.143 +        writeDescriptor(f.descriptor);
  15.144 +        writeAttributes(f.attributes);
  15.145 +    }
  15.146 +
  15.147 +    protected void writeMethods() throws IOException {
  15.148 +        Method[] methods = classFile.methods;
  15.149 +        out.writeShort(methods.length);
  15.150 +        for (Method m: methods) {
  15.151 +            writeMethod(m);
  15.152 +        }
  15.153 +    }
  15.154 +
  15.155 +    protected void writeMethod(Method m) throws IOException {
  15.156 +        writeAccessFlags(m.access_flags);
  15.157 +        out.writeShort(m.name_index);
  15.158 +        writeDescriptor(m.descriptor);
  15.159 +        writeAttributes(m.attributes);
  15.160 +    }
  15.161 +
  15.162 +    protected ClassFile classFile;
  15.163 +    protected ClassOutputStream out;
  15.164 +    protected AttributeWriter attributeWriter;
  15.165 +    protected ConstantPoolWriter constantPoolWriter;
  15.166 +
  15.167 +    /**
  15.168 +     * Subtype of ByteArrayOutputStream with the convenience methods of
  15.169 +     * a DataOutputStream. Since ByteArrayOutputStream does not throw
  15.170 +     * IOException, there are no exceptions from the additional
  15.171 +     * convenience methods either,
  15.172 +     */
  15.173 +    protected static class ClassOutputStream extends ByteArrayOutputStream {
  15.174 +        public ClassOutputStream() {
  15.175 +            d = new DataOutputStream(this);
  15.176 +        }
  15.177 +
  15.178 +        public void writeByte(int value) {
  15.179 +            try {
  15.180 +                d.writeByte(value);
  15.181 +            } catch (IOException ignore) {
  15.182 +            }
  15.183 +        }
  15.184 +
  15.185 +        public void writeShort(int value) {
  15.186 +            try {
  15.187 +                d.writeShort(value);
  15.188 +            } catch (IOException ignore) {
  15.189 +            }
  15.190 +        }
  15.191 +
  15.192 +        public void writeInt(int value) {
  15.193 +            try {
  15.194 +                d.writeInt(value);
  15.195 +            } catch (IOException ignore) {
  15.196 +            }
  15.197 +        }
  15.198 +
  15.199 +        public void writeLong(long value) {
  15.200 +            try {
  15.201 +                d.writeLong(value);
  15.202 +            } catch (IOException ignore) {
  15.203 +            }
  15.204 +        }
  15.205 +
  15.206 +        public void writeFloat(float value) {
  15.207 +            try {
  15.208 +                d.writeFloat(value);
  15.209 +            } catch (IOException ignore) {
  15.210 +            }
  15.211 +        }
  15.212 +
  15.213 +        public void writeDouble(double value) {
  15.214 +            try {
  15.215 +                d.writeDouble(value);
  15.216 +            } catch (IOException ignore) {
  15.217 +            }
  15.218 +        }
  15.219 +
  15.220 +        public void writeUTF(String value) {
  15.221 +            try {
  15.222 +                d.writeUTF(value);
  15.223 +            } catch (IOException ignore) {
  15.224 +            }
  15.225 +        }
  15.226 +
  15.227 +        public void writeTo(ClassOutputStream s) {
  15.228 +            try {
  15.229 +                super.writeTo(s);
  15.230 +            } catch (IOException ignore) {
  15.231 +            }
  15.232 +        }
  15.233 +
  15.234 +        private DataOutputStream d;
  15.235 +    }
  15.236 +
  15.237 +    /**
  15.238 +     * Writer for the entries in the constant pool.
  15.239 +     */
  15.240 +    protected static class ConstantPoolWriter
  15.241 +           implements ConstantPool.Visitor<Integer,ClassOutputStream> {
  15.242 +        protected int write(CPInfo info, ClassOutputStream out) {
  15.243 +            out.writeByte(info.getTag());
  15.244 +            return info.accept(this, out);
  15.245 +        }
  15.246 +
  15.247 +        public Integer visitClass(CONSTANT_Class_info info, ClassOutputStream out) {
  15.248 +            out.writeShort(info.name_index);
  15.249 +            return 1;
  15.250 +        }
  15.251 +
  15.252 +        public Integer visitDouble(CONSTANT_Double_info info, ClassOutputStream out) {
  15.253 +            out.writeDouble(info.value);
  15.254 +            return 2;
  15.255 +        }
  15.256 +
  15.257 +        public Integer visitFieldref(CONSTANT_Fieldref_info info, ClassOutputStream out) {
  15.258 +            writeRef(info, out);
  15.259 +            return 1;
  15.260 +        }
  15.261 +
  15.262 +        public Integer visitFloat(CONSTANT_Float_info info, ClassOutputStream out) {
  15.263 +            out.writeFloat(info.value);
  15.264 +            return 1;
  15.265 +        }
  15.266 +
  15.267 +        public Integer visitInteger(CONSTANT_Integer_info info, ClassOutputStream out) {
  15.268 +            out.writeInt(info.value);
  15.269 +            return 1;
  15.270 +        }
  15.271 +
  15.272 +        public Integer visitInterfaceMethodref(CONSTANT_InterfaceMethodref_info info, ClassOutputStream out) {
  15.273 +            writeRef(info, out);
  15.274 +            return 1;
  15.275 +        }
  15.276 +
  15.277 +        public Integer visitLong(CONSTANT_Long_info info, ClassOutputStream out) {
  15.278 +            out.writeLong(info.value);
  15.279 +            return 2;
  15.280 +        }
  15.281 +
  15.282 +        public Integer visitNameAndType(CONSTANT_NameAndType_info info, ClassOutputStream out) {
  15.283 +            out.writeShort(info.name_index);
  15.284 +            out.writeShort(info.type_index);
  15.285 +            return 1;
  15.286 +        }
  15.287 +
  15.288 +        public Integer visitMethodref(CONSTANT_Methodref_info info, ClassOutputStream out) {
  15.289 +            return writeRef(info, out);
  15.290 +        }
  15.291 +
  15.292 +        public Integer visitString(CONSTANT_String_info info, ClassOutputStream out) {
  15.293 +            out.writeShort(info.string_index);
  15.294 +            return 1;
  15.295 +        }
  15.296 +
  15.297 +        public Integer visitUtf8(CONSTANT_Utf8_info info, ClassOutputStream out) {
  15.298 +            out.writeUTF(info.value);
  15.299 +            return 1;
  15.300 +        }
  15.301 +
  15.302 +        protected Integer writeRef(CPRefInfo info, ClassOutputStream out) {
  15.303 +            out.writeShort(info.class_index);
  15.304 +            out.writeShort(info.name_and_type_index);
  15.305 +            return 1;
  15.306 +        }
  15.307 +    }
  15.308 +
  15.309 +    /**
  15.310 +     * Writer for the different types of attribute.
  15.311 +     */
  15.312 +    protected static class AttributeWriter implements Attribute.Visitor<Void,ClassOutputStream> {
  15.313 +        public void write(Attributes attributes, ClassOutputStream out) {
  15.314 +            int size = attributes.size();
  15.315 +            out.writeShort(size);
  15.316 +            for (Attribute a: attributes)
  15.317 +                write(a, out);
  15.318 +        }
  15.319 +
  15.320 +        // Note: due to the use of shared resources, this method is not reentrant.
  15.321 +        public void write(Attribute attr, ClassOutputStream out) {
  15.322 +            out.writeShort(attr.attribute_name_index);
  15.323 +            sharedOut.reset();
  15.324 +            attr.accept(this, sharedOut);
  15.325 +            out.writeInt(sharedOut.size());
  15.326 +            sharedOut.writeTo(out);
  15.327 +        }
  15.328 +
  15.329 +        protected ClassOutputStream sharedOut = new ClassOutputStream();
  15.330 +        protected AnnotationWriter annotationWriter = new AnnotationWriter();
  15.331 +
  15.332 +        public Void visitDefault(DefaultAttribute attr, ClassOutputStream out) {
  15.333 +            out.write(attr.info, 0, attr.info.length);
  15.334 +            return null;
  15.335 +        }
  15.336 +
  15.337 +        public Void visitAnnotationDefault(AnnotationDefault_attribute attr, ClassOutputStream out) {
  15.338 +            annotationWriter.write(attr.default_value, out);
  15.339 +            return null;
  15.340 +        }
  15.341 +
  15.342 +        public Void visitCharacterRangeTable(CharacterRangeTable_attribute attr, ClassOutputStream out) {
  15.343 +            out.writeShort(attr.character_range_table.length);
  15.344 +            for (CharacterRangeTable_attribute.Entry e: attr.character_range_table)
  15.345 +                writeCharacterRangeTableEntry(e, out);
  15.346 +            return null;
  15.347 +        }
  15.348 +
  15.349 +        protected void writeCharacterRangeTableEntry(CharacterRangeTable_attribute.Entry entry, ClassOutputStream out) {
  15.350 +            out.writeShort(entry.start_pc);
  15.351 +            out.writeShort(entry.end_pc);
  15.352 +            out.writeInt(entry.character_range_start);
  15.353 +            out.writeInt(entry.character_range_end);
  15.354 +            out.writeShort(entry.flags);
  15.355 +        }
  15.356 +
  15.357 +        public Void visitCode(Code_attribute attr, ClassOutputStream out) {
  15.358 +            out.writeShort(attr.max_stack);
  15.359 +            out.writeShort(attr.max_locals);
  15.360 +            out.writeInt(attr.code.length);
  15.361 +            out.write(attr.code, 0, attr.code.length);
  15.362 +            out.writeShort(attr.exception_table.length);
  15.363 +            for (Code_attribute.Exception_data e: attr.exception_table)
  15.364 +                writeExceptionTableEntry(e, out);
  15.365 +            new AttributeWriter().write(attr.attributes, out);
  15.366 +            return null;
  15.367 +        }
  15.368 +
  15.369 +        protected void writeExceptionTableEntry(Code_attribute.Exception_data exception_data, ClassOutputStream out) {
  15.370 +            out.writeShort(exception_data.start_pc);
  15.371 +            out.writeShort(exception_data.end_pc);
  15.372 +            out.writeShort(exception_data.handler_pc);
  15.373 +            out.writeShort(exception_data.catch_type);
  15.374 +        }
  15.375 +
  15.376 +        public Void visitCompilationID(CompilationID_attribute attr, ClassOutputStream out) {
  15.377 +            out.writeShort(attr.compilationID_index);
  15.378 +            return null;
  15.379 +        }
  15.380 +
  15.381 +        public Void visitConstantValue(ConstantValue_attribute attr, ClassOutputStream out) {
  15.382 +            out.writeShort(attr.constantvalue_index);
  15.383 +            return null;
  15.384 +        }
  15.385 +
  15.386 +        public Void visitDeprecated(Deprecated_attribute attr, ClassOutputStream out) {
  15.387 +            return null;
  15.388 +        }
  15.389 +
  15.390 +        public Void visitEnclosingMethod(EnclosingMethod_attribute attr, ClassOutputStream out) {
  15.391 +            out.writeShort(attr.class_index);
  15.392 +            out.writeShort(attr.method_index);
  15.393 +            return null;
  15.394 +        }
  15.395 +
  15.396 +        public Void visitExceptions(Exceptions_attribute attr, ClassOutputStream out) {
  15.397 +            out.writeShort(attr.exception_index_table.length);
  15.398 +            for (int i: attr.exception_index_table)
  15.399 +                out.writeShort(i);
  15.400 +            return null;
  15.401 +        }
  15.402 +
  15.403 +        public Void visitInnerClasses(InnerClasses_attribute attr, ClassOutputStream out) {
  15.404 +            out.writeShort(attr.classes.length);
  15.405 +            for (InnerClasses_attribute.Info info: attr.classes)
  15.406 +                writeInnerClassesInfo(info, out);
  15.407 +            return null;
  15.408 +        }
  15.409 +
  15.410 +        protected void writeInnerClassesInfo(InnerClasses_attribute.Info info, ClassOutputStream out) {
  15.411 +            out.writeShort(info.inner_class_info_index);
  15.412 +            out.writeShort(info.outer_class_info_index);
  15.413 +            out.writeShort(info.inner_name_index);
  15.414 +            writeAccessFlags(info.inner_class_access_flags, out);
  15.415 +        }
  15.416 +
  15.417 +        public Void visitLineNumberTable(LineNumberTable_attribute attr, ClassOutputStream out) {
  15.418 +            out.writeShort(attr.line_number_table.length);
  15.419 +            for (LineNumberTable_attribute.Entry e: attr.line_number_table)
  15.420 +                writeLineNumberTableEntry(e, out);
  15.421 +            return null;
  15.422 +        }
  15.423 +
  15.424 +        protected void writeLineNumberTableEntry(LineNumberTable_attribute.Entry entry, ClassOutputStream out) {
  15.425 +            out.writeShort(entry.start_pc);
  15.426 +            out.writeShort(entry.line_number);
  15.427 +        }
  15.428 +
  15.429 +        public Void visitLocalVariableTable(LocalVariableTable_attribute attr, ClassOutputStream out) {
  15.430 +            out.writeShort(attr.local_variable_table.length);
  15.431 +            for (LocalVariableTable_attribute.Entry e: attr.local_variable_table)
  15.432 +                writeLocalVariableTableEntry(e, out);
  15.433 +            return null;
  15.434 +        }
  15.435 +
  15.436 +        protected void writeLocalVariableTableEntry(LocalVariableTable_attribute.Entry entry, ClassOutputStream out) {
  15.437 +            out.writeShort(entry.start_pc);
  15.438 +            out.writeShort(entry.length);
  15.439 +            out.writeShort(entry.name_index);
  15.440 +            out.writeShort(entry.descriptor_index);
  15.441 +            out.writeShort(entry.index);
  15.442 +        }
  15.443 +
  15.444 +        public Void visitLocalVariableTypeTable(LocalVariableTypeTable_attribute attr, ClassOutputStream out) {
  15.445 +            out.writeByte(attr.local_variable_table.length);
  15.446 +            for (LocalVariableTypeTable_attribute.Entry e: attr.local_variable_table)
  15.447 +                writeLocalVariableTypeTableEntry(e, out);
  15.448 +            return null;
  15.449 +        }
  15.450 +
  15.451 +        protected void writeLocalVariableTypeTableEntry(LocalVariableTypeTable_attribute.Entry entry, ClassOutputStream out) {
  15.452 +            out.writeShort(entry.start_pc);
  15.453 +            out.writeShort(entry.length);
  15.454 +            out.writeShort(entry.name_index);
  15.455 +            out.writeShort(entry.signature_index);
  15.456 +            out.writeShort(entry.index);
  15.457 +        }
  15.458 +
  15.459 +        public Void visitModule(Module_attribute attr, ClassOutputStream out) {
  15.460 +            out.writeShort(attr.module_name);
  15.461 +            return null;
  15.462 +        }
  15.463 +
  15.464 +        public Void visitModuleExportTable(ModuleExportTable_attribute attr, ClassOutputStream out) {
  15.465 +            out.writeShort(attr.export_type_table.length);
  15.466 +            for (int i: attr.export_type_table)
  15.467 +                out.writeShort(i);
  15.468 +            return null;
  15.469 +        }
  15.470 +
  15.471 +        public Void visitModuleMemberTable(ModuleMemberTable_attribute attr, ClassOutputStream out) {
  15.472 +            out.writeShort(attr.package_member_table.length);
  15.473 +            for (int i: attr.package_member_table)
  15.474 +                out.writeShort(i);
  15.475 +            return null;
  15.476 +        }
  15.477 +
  15.478 +        public Void visitRuntimeVisibleAnnotations(RuntimeVisibleAnnotations_attribute attr, ClassOutputStream out) {
  15.479 +            annotationWriter.write(attr.annotations, out);
  15.480 +            return null;
  15.481 +        }
  15.482 +
  15.483 +        public Void visitRuntimeInvisibleAnnotations(RuntimeInvisibleAnnotations_attribute attr, ClassOutputStream out) {
  15.484 +            annotationWriter.write(attr.annotations, out);
  15.485 +            return null;
  15.486 +        }
  15.487 +
  15.488 +        public Void visitRuntimeVisibleParameterAnnotations(RuntimeVisibleParameterAnnotations_attribute attr, ClassOutputStream out) {
  15.489 +            out.writeByte(attr.parameter_annotations.length);
  15.490 +            for (Annotation[] annos: attr.parameter_annotations)
  15.491 +                annotationWriter.write(annos, out);
  15.492 +            return null;
  15.493 +        }
  15.494 +
  15.495 +        public Void visitRuntimeInvisibleParameterAnnotations(RuntimeInvisibleParameterAnnotations_attribute attr, ClassOutputStream out) {
  15.496 +            out.writeByte(attr.parameter_annotations.length);
  15.497 +            for (Annotation[] annos: attr.parameter_annotations)
  15.498 +                annotationWriter.write(annos, out);
  15.499 +            return null;
  15.500 +        }
  15.501 +
  15.502 +        public Void visitSignature(Signature_attribute attr, ClassOutputStream out) {
  15.503 +            out.writeShort(attr.signature_index);
  15.504 +            return null;
  15.505 +        }
  15.506 +
  15.507 +        public Void visitSourceDebugExtension(SourceDebugExtension_attribute attr, ClassOutputStream out) {
  15.508 +            out.write(attr.debug_extension, 0, attr.debug_extension.length);
  15.509 +            return null;
  15.510 +        }
  15.511 +
  15.512 +        public Void visitSourceFile(SourceFile_attribute attr, ClassOutputStream out) {
  15.513 +            out.writeShort(attr.sourcefile_index);
  15.514 +            return null;
  15.515 +        }
  15.516 +
  15.517 +        public Void visitSourceID(SourceID_attribute attr, ClassOutputStream out) {
  15.518 +            out.writeShort(attr.sourceID_index);
  15.519 +            return null;
  15.520 +        }
  15.521 +
  15.522 +        public Void visitStackMap(StackMap_attribute attr, ClassOutputStream out) {
  15.523 +            if (stackMapWriter == null)
  15.524 +                stackMapWriter = new StackMapTableWriter();
  15.525 +
  15.526 +            out.writeShort(attr.entries.length);
  15.527 +            for (stack_map_frame f: attr.entries)
  15.528 +                stackMapWriter.write(f, out);
  15.529 +            return null;
  15.530 +        }
  15.531 +
  15.532 +        public Void visitStackMapTable(StackMapTable_attribute attr, ClassOutputStream out) {
  15.533 +            if (stackMapWriter == null)
  15.534 +                stackMapWriter = new StackMapTableWriter();
  15.535 +
  15.536 +            out.writeShort(attr.entries.length);
  15.537 +            for (stack_map_frame f: attr.entries)
  15.538 +                stackMapWriter.write(f, out);
  15.539 +            return null;
  15.540 +        }
  15.541 +
  15.542 +        public Void visitSynthetic(Synthetic_attribute attr, ClassOutputStream out) {
  15.543 +            return null;
  15.544 +        }
  15.545 +
  15.546 +        protected void writeAccessFlags(AccessFlags flags, ClassOutputStream p) {
  15.547 +            sharedOut.writeShort(flags.flags);
  15.548 +        }
  15.549 +
  15.550 +        protected StackMapTableWriter stackMapWriter;
  15.551 +    }
  15.552 +
  15.553 +    /**
  15.554 +     * Writer for the frames of StackMap and StackMapTable attributes.
  15.555 +     */
  15.556 +    protected static class StackMapTableWriter
  15.557 +            implements stack_map_frame.Visitor<Void,ClassOutputStream> {
  15.558 +
  15.559 +        public void write(stack_map_frame frame, ClassOutputStream out) {
  15.560 +            out.write(frame.frame_type);
  15.561 +            frame.accept(this, out);
  15.562 +        }
  15.563 +
  15.564 +        public Void visit_same_frame(same_frame frame, ClassOutputStream p) {
  15.565 +            return null;
  15.566 +        }
  15.567 +
  15.568 +        public Void visit_same_locals_1_stack_item_frame(same_locals_1_stack_item_frame frame, ClassOutputStream out) {
  15.569 +            writeVerificationTypeInfo(frame.stack[0], out);
  15.570 +            return null;
  15.571 +        }
  15.572 +
  15.573 +        public Void visit_same_locals_1_stack_item_frame_extended(same_locals_1_stack_item_frame_extended frame, ClassOutputStream out) {
  15.574 +            out.writeShort(frame.offset_delta);
  15.575 +            writeVerificationTypeInfo(frame.stack[0], out);
  15.576 +            return null;
  15.577 +        }
  15.578 +
  15.579 +        public Void visit_chop_frame(chop_frame frame, ClassOutputStream out) {
  15.580 +            out.writeShort(frame.offset_delta);
  15.581 +            return null;
  15.582 +        }
  15.583 +
  15.584 +        public Void visit_same_frame_extended(same_frame_extended frame, ClassOutputStream out) {
  15.585 +            out.writeShort(frame.offset_delta);
  15.586 +            return null;
  15.587 +        }
  15.588 +
  15.589 +        public Void visit_append_frame(append_frame frame, ClassOutputStream out) {
  15.590 +            out.writeShort(frame.offset_delta);
  15.591 +            for (verification_type_info l: frame.locals)
  15.592 +                writeVerificationTypeInfo(l, out);
  15.593 +            return null;
  15.594 +        }
  15.595 +
  15.596 +        public Void visit_full_frame(full_frame frame, ClassOutputStream out) {
  15.597 +            out.writeShort(frame.offset_delta);
  15.598 +            out.writeShort(frame.locals.length);
  15.599 +            for (verification_type_info l: frame.locals)
  15.600 +                writeVerificationTypeInfo(l, out);
  15.601 +            out.writeShort(frame.stack.length);
  15.602 +            for (verification_type_info s: frame.stack)
  15.603 +                writeVerificationTypeInfo(s, out);
  15.604 +            return null;
  15.605 +        }
  15.606 +
  15.607 +        protected void writeVerificationTypeInfo(verification_type_info info,
  15.608 +                ClassOutputStream out)  {
  15.609 +            out.write(info.tag);
  15.610 +            switch (info.tag) {
  15.611 +            case ITEM_Top:
  15.612 +            case ITEM_Integer:
  15.613 +            case ITEM_Float:
  15.614 +            case ITEM_Long:
  15.615 +            case ITEM_Double:
  15.616 +            case ITEM_Null:
  15.617 +            case ITEM_UninitializedThis:
  15.618 +                break;
  15.619 +
  15.620 +            case ITEM_Object:
  15.621 +                Object_variable_info o = (Object_variable_info) info;
  15.622 +                out.writeShort(o.cpool_index);
  15.623 +                break;
  15.624 +
  15.625 +            case ITEM_Uninitialized:
  15.626 +                Uninitialized_variable_info u = (Uninitialized_variable_info) info;
  15.627 +                out.writeShort(u.offset);
  15.628 +                break;
  15.629 +
  15.630 +            default:
  15.631 +                throw new Error();
  15.632 +            }
  15.633 +        }
  15.634 +    }
  15.635 +
  15.636 +    /**
  15.637 +     * Writer for annotations and the values they contain.
  15.638 +     */
  15.639 +    protected static class AnnotationWriter
  15.640 +            implements Annotation.element_value.Visitor<Void,ClassOutputStream> {
  15.641 +        public void write(Annotation[] annos, ClassOutputStream out) {
  15.642 +            out.writeShort(annos.length);
  15.643 +            for (Annotation anno: annos)
  15.644 +                write(anno, out);
  15.645 +        }
  15.646 +
  15.647 +        public void write(Annotation anno, ClassOutputStream out) {
  15.648 +            out.writeShort(anno.type_index);
  15.649 +            out.writeShort(anno.element_value_pairs.length);
  15.650 +            for (element_value_pair p: anno.element_value_pairs)
  15.651 +                write(p, out);
  15.652 +        }
  15.653 +
  15.654 +        public void write(element_value_pair pair, ClassOutputStream out) {
  15.655 +            out.writeShort(pair.element_name_index);
  15.656 +            write(pair.value, out);
  15.657 +        }
  15.658 +
  15.659 +        public void write(element_value ev, ClassOutputStream out) {
  15.660 +            out.writeByte(ev.tag);
  15.661 +            ev.accept(this, out);
  15.662 +        }
  15.663 +
  15.664 +        public Void visitPrimitive(Primitive_element_value ev, ClassOutputStream out) {
  15.665 +            out.writeShort(ev.const_value_index);
  15.666 +            return null;
  15.667 +        }
  15.668 +
  15.669 +        public Void visitEnum(Enum_element_value ev, ClassOutputStream out) {
  15.670 +            out.writeShort(ev.type_name_index);
  15.671 +            out.writeShort(ev.const_name_index);
  15.672 +            return null;
  15.673 +        }
  15.674 +
  15.675 +        public Void visitClass(Class_element_value ev, ClassOutputStream out) {
  15.676 +            out.writeShort(ev.class_info_index);
  15.677 +            return null;
  15.678 +        }
  15.679 +
  15.680 +        public Void visitAnnotation(Annotation_element_value ev, ClassOutputStream out) {
  15.681 +            write(ev.annotation_value, out);
  15.682 +            return null;
  15.683 +        }
  15.684 +
  15.685 +        public Void visitArray(Array_element_value ev, ClassOutputStream out) {
  15.686 +            out.writeShort(ev.num_values);
  15.687 +            for (element_value v: ev.values)
  15.688 +                write(v, out);
  15.689 +            return null;
  15.690 +        }
  15.691 +    }
  15.692 +}

    16.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    16.2 +++ b/src/share/classes/com/sun/tools/classfile/Code_attribute.java	Tue Jun 03 13:26:47 2008 -0700
    16.3 @@ -0,0 +1,123 @@
    16.4 +/*
    16.5 + * Copyright 2007 Sun Microsystems, Inc.  All Rights Reserved.
    16.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    16.7 + *
    16.8 + * This code is free software; you can redistribute it and/or modify it
    16.9 + * under the terms of the GNU General Public License version 2 only, as
   16.10 + * published by the Free Software Foundation.  Sun designates this
   16.11 + * particular file as subject to the "Classpath" exception as provided
   16.12 + * by Sun in the LICENSE file that accompanied this code.
   16.13 + *
   16.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   16.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   16.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   16.17 + * version 2 for more details (a copy is included in the LICENSE file that
   16.18 + * accompanied this code).
   16.19 + *
   16.20 + * You should have received a copy of the GNU General Public License version
   16.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   16.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   16.23 + *
   16.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
   16.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
   16.26 + * have any questions.
   16.27 + */
   16.28 +
   16.29 +package com.sun.tools.classfile;
   16.30 +
   16.31 +import java.io.IOException;
   16.32 +
   16.33 +/**
   16.34 + * See JVMS3, section 4.8.3.
   16.35 + *
   16.36 + *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
   16.37 + *  you write code that depends on this, you do so at your own risk.
   16.38 + *  This code and its internal interfaces are subject to change or
   16.39 + *  deletion without notice.</b>
   16.40 + */
   16.41 +public class Code_attribute extends Attribute {
   16.42 +    public class InvalidIndex extends AttributeException {
   16.43 +        InvalidIndex(int index) {
   16.44 +            this.index = index;
   16.45 +        }
   16.46 +
   16.47 +        @Override
   16.48 +        public String getMessage() {
   16.49 +            // i18n
   16.50 +            return "invalid index " + index + " in Code attribute";
   16.51 +        }
   16.52 +
   16.53 +        public final int index;
   16.54 +    }
   16.55 +
   16.56 +    Code_attribute(ClassReader cr, int name_index, int length)
   16.57 +            throws IOException, ConstantPoolException {
   16.58 +        super(name_index, length);
   16.59 +        max_stack = cr.readUnsignedShort();
   16.60 +        max_locals = cr.readUnsignedShort();
   16.61 +        code_length = cr.readInt();
   16.62 +        code = new byte[code_length];
   16.63 +        cr.readFully(code);
   16.64 +        exception_table_langth = cr.readUnsignedShort();
   16.65 +        exception_table = new Exception_data[exception_table_langth];
   16.66 +        for (int i = 0; i < exception_table_langth; i++)
   16.67 +            exception_table[i] = new Exception_data(cr);
   16.68 +        attributes = new Attributes(cr);
   16.69 +    }
   16.70 +
   16.71 +    public int getByte(int offset) throws InvalidIndex {
   16.72 +        if (offset < 0 || offset >= code.length)
   16.73 +            throw new InvalidIndex(offset);
   16.74 +        return code[offset];
   16.75 +    }
   16.76 +
   16.77 +    public int getUnsignedByte(int offset) throws InvalidIndex {
   16.78 +        if (offset < 0 || offset >= code.length)
   16.79 +            throw new InvalidIndex(offset);
   16.80 +        return code[offset] & 0xff;
   16.81 +    }
   16.82 +
   16.83 +    public int getShort(int offset) throws InvalidIndex {
   16.84 +        if (offset < 0 || offset + 1 >= code.length)
   16.85 +            throw new InvalidIndex(offset);
   16.86 +        return (code[offset] << 8) | (code[offset + 1] & 0xFF);
   16.87 +    }
   16.88 +
   16.89 +    public int getUnsignedShort(int offset) throws InvalidIndex {
   16.90 +        if (offset < 0 || offset + 1 >= code.length)
   16.91 +            throw new InvalidIndex(offset);
   16.92 +        return ((code[offset] << 8) | (code[offset + 1] & 0xFF)) & 0xFFFF;
   16.93 +    }
   16.94 +
   16.95 +    public int getInt(int offset) throws InvalidIndex {
   16.96 +        if (offset < 0 || offset + 3 >= code.length)
   16.97 +            throw new InvalidIndex(offset);
   16.98 +        return (getShort(offset) << 16) | (getShort(offset + 2) & 0xFFFF);
   16.99 +    }
  16.100 +
  16.101 +    public <R, D> R accept(Visitor<R, D> visitor, D data) {
  16.102 +        return visitor.visitCode(this, data);
  16.103 +    }
  16.104 +
  16.105 +    public final int max_stack;
  16.106 +    public final int max_locals;
  16.107 +    public final int code_length;
  16.108 +    public final byte[] code;
  16.109 +    public final int exception_table_langth;
  16.110 +    public final Exception_data[] exception_table;
  16.111 +    public final Attributes attributes;
  16.112 +
  16.113 +    public class Exception_data {
  16.114 +        Exception_data(ClassReader cr) throws IOException {
  16.115 +            start_pc = cr.readUnsignedShort();
  16.116 +            end_pc = cr.readUnsignedShort();
  16.117 +            handler_pc = cr.readUnsignedShort();
  16.118 +            catch_type = cr.readUnsignedShort();
  16.119 +        }
  16.120 +
  16.121 +        public final int start_pc;
  16.122 +        public final int end_pc;
  16.123 +        public final int handler_pc;
  16.124 +        public final int catch_type;
  16.125 +    }
  16.126 +}

    17.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    17.2 +++ b/src/share/classes/com/sun/tools/classfile/CompilationID_attribute.java	Tue Jun 03 13:26:47 2008 -0700
    17.3 @@ -0,0 +1,62 @@
    17.4 +/*
    17.5 + * Copyright 2008 Sun Microsystems, Inc.  All Rights Reserved.
    17.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    17.7 + *
    17.8 + * This code is free software; you can redistribute it and/or modify it
    17.9 + * under the terms of the GNU General Public License version 2 only, as
   17.10 + * published by the Free Software Foundation.  Sun designates this
   17.11 + * particular file as subject to the "Classpath" exception as provided
   17.12 + * by Sun in the LICENSE file that accompanied this code.
   17.13 + *
   17.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   17.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   17.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   17.17 + * version 2 for more details (a copy is included in the LICENSE file that
   17.18 + * accompanied this code).
   17.19 + *
   17.20 + * You should have received a copy of the GNU General Public License version
   17.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   17.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   17.23 + *
   17.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
   17.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
   17.26 + * have any questions.
   17.27 + */
   17.28 +package com.sun.tools.classfile;
   17.29 +
   17.30 +import java.io.IOException;
   17.31 +
   17.32 +/**
   17.33 + *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
   17.34 + *  you write code that depends on this, you do so at your own risk.
   17.35 + *  This code and its internal interfaces are subject to change or
   17.36 + *  deletion without notice.</b>
   17.37 + */
   17.38 +public class CompilationID_attribute extends Attribute {
   17.39 +
   17.40 +    CompilationID_attribute(ClassReader cr, int name_index, int length) throws IOException {
   17.41 +        super(name_index, length);
   17.42 +        compilationID_index = cr.readUnsignedShort();
   17.43 +    }
   17.44 +
   17.45 +    public CompilationID_attribute(ConstantPool constant_pool, int compilationID_index)
   17.46 +            throws ConstantPoolException {
   17.47 +        this(constant_pool.getUTF8Index(Attribute.CompilationID), compilationID_index);
   17.48 +    }
   17.49 +
   17.50 +    public CompilationID_attribute(int name_index, int compilationID_index) {
   17.51 +        super(name_index, 2);
   17.52 +        this.compilationID_index = compilationID_index;
   17.53 +    }
   17.54 +
   17.55 +    String getCompilationID(ConstantPool constant_pool)
   17.56 +            throws ConstantPoolException {
   17.57 +        return constant_pool.getUTF8Value(compilationID_index);
   17.58 +    }
   17.59 +
   17.60 +    public <R, D> R accept(Visitor<R, D> visitor, D data) {
   17.61 +        return visitor.visitCompilationID(this, data);
   17.62 +    }
   17.63 +
   17.64 +    public final int compilationID_index;
   17.65 +}

    18.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    18.2 +++ b/src/share/classes/com/sun/tools/classfile/ConstantPool.java	Tue Jun 03 13:26:47 2008 -0700
    18.3 @@ -0,0 +1,562 @@
    18.4 +/*
    18.5 + * Copyright 2007 Sun Microsystems, Inc.  All Rights Reserved.
    18.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    18.7 + *
    18.8 + * This code is free software; you can redistribute it and/or modify it
    18.9 + * under the terms of the GNU General Public License version 2 only, as
   18.10 + * published by the Free Software Foundation.  Sun designates this
   18.11 + * particular file as subject to the "Classpath" exception as provided
   18.12 + * by Sun in the LICENSE file that accompanied this code.
   18.13 + *
   18.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   18.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   18.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   18.17 + * version 2 for more details (a copy is included in the LICENSE file that
   18.18 + * accompanied this code).
   18.19 + *
   18.20 + * You should have received a copy of the GNU General Public License version
   18.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   18.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   18.23 + *
   18.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
   18.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
   18.26 + * have any questions.
   18.27 + */
   18.28 +
   18.29 +package com.sun.tools.classfile;
   18.30 +
   18.31 +import java.io.IOException;
   18.32 +
   18.33 +/**
   18.34 + * See JVMS3, section 4.5.
   18.35 + *
   18.36 + *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
   18.37 + *  you write code that depends on this, you do so at your own risk.
   18.38 + *  This code and its internal interfaces are subject to change or
   18.39 + *  deletion without notice.</b>
   18.40 + */
   18.41 +public class ConstantPool {
   18.42 +
   18.43 +    public class InvalidIndex extends ConstantPoolException {
   18.44 +        InvalidIndex(int index) {
   18.45 +            super(index);
   18.46 +        }
   18.47 +
   18.48 +        @Override
   18.49 +        public String getMessage() {
   18.50 +            // i18n
   18.51 +            return "invalid index #" + index;
   18.52 +        }
   18.53 +    }
   18.54 +
   18.55 +    public class UnexpectedEntry extends ConstantPoolException {
   18.56 +        UnexpectedEntry(int index, int expected_tag, int found_tag) {
   18.57 +            super(index);
   18.58 +            this.expected_tag = expected_tag;
   18.59 +            this.found_tag = found_tag;
   18.60 +        }
   18.61 +
   18.62 +        @Override
   18.63 +        public String getMessage() {
   18.64 +            // i18n?
   18.65 +            return "unexpected entry at #" + index + " -- expected tag " + expected_tag + ", found " + found_tag;
   18.66 +        }
   18.67 +
   18.68 +        public final int expected_tag;
   18.69 +        public final int found_tag;
   18.70 +    }
   18.71 +
   18.72 +    public class InvalidEntry extends ConstantPoolException {
   18.73 +        InvalidEntry(int index, int tag) {
   18.74 +            super(index);
   18.75 +            this.tag = tag;
   18.76 +        }
   18.77 +
   18.78 +        @Override
   18.79 +        public String getMessage() {
   18.80 +            // i18n?
   18.81 +            return "unexpected tag at #" + index + ": " + tag;
   18.82 +        }
   18.83 +
   18.84 +        public final int tag;
   18.85 +    }
   18.86 +
   18.87 +    public class EntryNotFound extends ConstantPoolException {
   18.88 +        EntryNotFound(Object value) {
   18.89 +            super(-1);
   18.90 +            this.value = value;
   18.91 +        }
   18.92 +
   18.93 +        @Override
   18.94 +        public String getMessage() {
   18.95 +            // i18n?
   18.96 +            return "value not found: " + value;
   18.97 +        }
   18.98 +
   18.99 +        public final Object value;
  18.100 +    }
  18.101 +
  18.102 +    public static final int CONSTANT_Utf8 = 1;
  18.103 +    public static final int CONSTANT_Integer = 3;
  18.104 +    public static final int CONSTANT_Float = 4;
  18.105 +    public static final int CONSTANT_Long = 5;
  18.106 +    public static final int CONSTANT_Double = 6;
  18.107 +    public static final int CONSTANT_Class = 7;
  18.108 +    public static final int CONSTANT_String = 8;
  18.109 +    public static final int CONSTANT_Fieldref = 9;
  18.110 +    public static final int CONSTANT_Methodref = 10;
  18.111 +    public static final int CONSTANT_InterfaceMethodref = 11;
  18.112 +    public static final int CONSTANT_NameAndType = 12;
  18.113 +
  18.114 +    ConstantPool(ClassReader cr) throws IOException, InvalidEntry {
  18.115 +        int count = cr.readUnsignedShort();
  18.116 +        pool = new CPInfo[count];
  18.117 +        for (int i = 1; i < count; i++) {
  18.118 +            int tag = cr.readUnsignedByte();
  18.119 +            switch (tag) {
  18.120 +            case CONSTANT_Class:
  18.121 +                pool[i] = new CONSTANT_Class_info(this, cr);
  18.122 +                break;
  18.123 +
  18.124 +            case CONSTANT_Double:
  18.125 +                pool[i] = new CONSTANT_Double_info(cr);
  18.126 +                i++;
  18.127 +                break;
  18.128 +
  18.129 +            case CONSTANT_Fieldref:
  18.130 +                pool[i] = new CONSTANT_Fieldref_info(this, cr);
  18.131 +                break;
  18.132 +
  18.133 +            case CONSTANT_Float:
  18.134 +                pool[i] = new CONSTANT_Float_info(cr);
  18.135 +                break;
  18.136 +
  18.137 +            case CONSTANT_Integer:
  18.138 +                pool[i] = new CONSTANT_Integer_info(cr);
  18.139 +                break;
  18.140 +
  18.141 +            case CONSTANT_InterfaceMethodref:
  18.142 +                pool[i] = new CONSTANT_InterfaceMethodref_info(this, cr);
  18.143 +                break;
  18.144 +
  18.145 +            case CONSTANT_Long:
  18.146 +                pool[i] = new CONSTANT_Long_info(cr);
  18.147 +                i++;
  18.148 +                break;
  18.149 +
  18.150 +            case CONSTANT_Methodref:
  18.151 +                pool[i] = new CONSTANT_Methodref_info(this, cr);
  18.152 +                break;
  18.153 +
  18.154 +            case CONSTANT_NameAndType:
  18.155 +                pool[i] = new CONSTANT_NameAndType_info(this, cr);
  18.156 +                break;
  18.157 +
  18.158 +            case CONSTANT_String:
  18.159 +                pool[i] = new CONSTANT_String_info(cr);
  18.160 +                break;
  18.161 +
  18.162 +            case CONSTANT_Utf8:
  18.163 +                pool[i] = new CONSTANT_Utf8_info(cr);
  18.164 +                break;
  18.165 +
  18.166 +            default:
  18.167 +                throw new InvalidEntry(i, tag);
  18.168 +            }
  18.169 +        }
  18.170 +    }
  18.171 +
  18.172 +    public ConstantPool(CPInfo[] pool) {
  18.173 +        this.pool = pool;
  18.174 +    }
  18.175 +
  18.176 +    public int size() {
  18.177 +        return pool.length;
  18.178 +    }
  18.179 +
  18.180 +    public CPInfo get(int index) throws InvalidIndex {
  18.181 +        if (index <= 0 || index >= pool.length)
  18.182 +            throw new InvalidIndex(index);
  18.183 +        CPInfo info = pool[index];
  18.184 +        if (info == null) {
  18.185 +            // this occurs for indices referencing the "second half" of an
  18.186 +            // 8 byte constant, such as CONSTANT_Double or CONSTANT_Long
  18.187 +            throw new InvalidIndex(index);
  18.188 +        }
  18.189 +        return pool[index];
  18.190 +    }
  18.191 +
  18.192 +    private CPInfo get(int index, int expected_type) throws InvalidIndex, UnexpectedEntry {
  18.193 +        CPInfo info = get(index);
  18.194 +        if (info.getTag() != expected_type)
  18.195 +            throw new UnexpectedEntry(index, expected_type, info.getTag());
  18.196 +        return info;
  18.197 +    }
  18.198 +
  18.199 +    public CONSTANT_Utf8_info getUTF8Info(int index) throws InvalidIndex, UnexpectedEntry {
  18.200 +        return ((CONSTANT_Utf8_info) get(index, CONSTANT_Utf8));
  18.201 +    }
  18.202 +
  18.203 +    public CONSTANT_Class_info getClassInfo(int index) throws InvalidIndex, UnexpectedEntry {
  18.204 +        return ((CONSTANT_Class_info) get(index, CONSTANT_Class));
  18.205 +    }
  18.206 +
  18.207 +    public CONSTANT_NameAndType_info getNameAndTypeInfo(int index) throws InvalidIndex, UnexpectedEntry {
  18.208 +        return ((CONSTANT_NameAndType_info) get(index, CONSTANT_NameAndType));
  18.209 +    }
  18.210 +
  18.211 +    public String getUTF8Value(int index) throws InvalidIndex, UnexpectedEntry {
  18.212 +        return getUTF8Info(index).value;
  18.213 +    }
  18.214 +
  18.215 +    public int getUTF8Index(String value) throws EntryNotFound {
  18.216 +        for (int i = 1; i < pool.length; i++) {
  18.217 +            CPInfo info = pool[i];
  18.218 +            if (info instanceof CONSTANT_Utf8_info &&
  18.219 +                    ((CONSTANT_Utf8_info) info).value.equals(value))
  18.220 +                return i;
  18.221 +        }
  18.222 +        throw new EntryNotFound(value);
  18.223 +    }
  18.224 +
  18.225 +    private CPInfo[] pool;
  18.226 +
  18.227 +    public interface Visitor<R,P> {
  18.228 +        R visitClass(CONSTANT_Class_info info, P p);
  18.229 +        R visitDouble(CONSTANT_Double_info info, P p);
  18.230 +        R visitFieldref(CONSTANT_Fieldref_info info, P p);
  18.231 +        R visitFloat(CONSTANT_Float_info info, P p);
  18.232 +        R visitInteger(CONSTANT_Integer_info info, P p);
  18.233 +        R visitInterfaceMethodref(CONSTANT_InterfaceMethodref_info info, P p);
  18.234 +        R visitLong(CONSTANT_Long_info info, P p);
  18.235 +        R visitNameAndType(CONSTANT_NameAndType_info info, P p);
  18.236 +        R visitMethodref(CONSTANT_Methodref_info info, P p);
  18.237 +        R visitString(CONSTANT_String_info info, P p);
  18.238 +        R visitUtf8(CONSTANT_Utf8_info info, P p);
  18.239 +    }
  18.240 +
  18.241 +    public static abstract class CPInfo {
  18.242 +        CPInfo() {
  18.243 +            this.cp = null;
  18.244 +        }
  18.245 +
  18.246 +        CPInfo(ConstantPool cp) {
  18.247 +            this.cp = cp;
  18.248 +        }
  18.249 +
  18.250 +        public abstract int getTag();
  18.251 +
  18.252 +        public abstract <R,D> R accept(Visitor<R,D> visitor, D data);
  18.253 +
  18.254 +        protected final ConstantPool cp;
  18.255 +    }
  18.256 +
  18.257 +    public static abstract class CPRefInfo extends CPInfo {
  18.258 +        protected CPRefInfo(ConstantPool cp, ClassReader cr, int tag) throws IOException {
  18.259 +            super(cp);
  18.260 +            this.tag = tag;
  18.261 +            class_index = cr.readUnsignedShort();
  18.262 +            name_and_type_index = cr.readUnsignedShort();
  18.263 +        }
  18.264 +
  18.265 +        protected CPRefInfo(ConstantPool cp, int tag, int class_index, int name_and_type_index) {
  18.266 +            super(cp);
  18.267 +            this.tag = tag;
  18.268 +            this.class_index = class_index;
  18.269 +            this.name_and_type_index = name_and_type_index;
  18.270 +        }
  18.271 +
  18.272 +        public int getTag() {
  18.273 +            return tag;
  18.274 +        }
  18.275 +
  18.276 +        public CONSTANT_Class_info getClassInfo() throws ConstantPoolException {
  18.277 +            return cp.getClassInfo(class_index);
  18.278 +        }
  18.279 +
  18.280 +        public String getClassName() throws ConstantPoolException {
  18.281 +            return cp.getClassInfo(class_index).getName();
  18.282 +        }
  18.283 +
  18.284 +        public CONSTANT_NameAndType_info getNameAndTypeInfo() throws ConstantPoolException {
  18.285 +            return cp.getNameAndTypeInfo(name_and_type_index);
  18.286 +        }
  18.287 +
  18.288 +        public final int tag;
  18.289 +        public final int class_index;
  18.290 +        public final int name_and_type_index;
  18.291 +    }
  18.292 +
  18.293 +    public static class CONSTANT_Class_info extends CPInfo {
  18.294 +        CONSTANT_Class_info(ConstantPool cp, ClassReader cr) throws IOException {
  18.295 +            super(cp);
  18.296 +            name_index = cr.readUnsignedShort();
  18.297 +        }
  18.298 +
  18.299 +        public CONSTANT_Class_info(ConstantPool cp, int name_index) {
  18.300 +            super(cp);
  18.301 +            this.name_index = name_index;
  18.302 +        }
  18.303 +
  18.304 +        public int getTag() {
  18.305 +            return CONSTANT_Class;
  18.306 +        }
  18.307 +
  18.308 +        public String getName() throws ConstantPoolException {
  18.309 +            return cp.getUTF8Value(name_index);
  18.310 +        }
  18.311 +
  18.312 +        @Override
  18.313 +        public String toString() {
  18.314 +            return "CONSTANT_Class_info[name_index: " + name_index + "]";
  18.315 +        }
  18.316 +
  18.317 +        public <R, D> R accept(Visitor<R, D> visitor, D data) {
  18.318 +            return visitor.visitClass(this, data);
  18.319 +        }
  18.320 +
  18.321 +        public final int name_index;
  18.322 +    }
  18.323 +
  18.324 +    public static class CONSTANT_Double_info extends CPInfo {
  18.325 +        CONSTANT_Double_info(ClassReader cr) throws IOException {
  18.326 +            value = cr.readDouble();
  18.327 +        }
  18.328 +
  18.329 +        public CONSTANT_Double_info(double value) {
  18.330 +            this.value = value;
  18.331 +        }
  18.332 +
  18.333 +        public int getTag() {
  18.334 +            return CONSTANT_Double;
  18.335 +        }
  18.336 +
  18.337 +        @Override
  18.338 +        public String toString() {
  18.339 +            return "CONSTANT_Double_info[value: " + value + "]";
  18.340 +        }
  18.341 +
  18.342 +        public <R, D> R accept(Visitor<R, D> visitor, D data) {
  18.343 +            return visitor.visitDouble(this, data);
  18.344 +        }
  18.345 +
  18.346 +        public final double value;
  18.347 +    }
  18.348 +
  18.349 +    public static class CONSTANT_Fieldref_info extends CPRefInfo {
  18.350 +        CONSTANT_Fieldref_info(ConstantPool cp, ClassReader cr) throws IOException {
  18.351 +            super(cp, cr, CONSTANT_Fieldref);
  18.352 +        }
  18.353 +
  18.354 +        public CONSTANT_Fieldref_info(ConstantPool cp, int class_index, int name_and_type_index) {
  18.355 +            super(cp, CONSTANT_Fieldref, class_index, name_and_type_index);
  18.356 +        }
  18.357 +
  18.358 +        @Override
  18.359 +        public String toString() {
  18.360 +            return "CONSTANT_Fieldref_info[class_index: " + class_index + ", name_and_type_index: " + name_and_type_index + "]";
  18.361 +        }
  18.362 +
  18.363 +        public <R, D> R accept(Visitor<R, D> visitor, D data) {
  18.364 +            return visitor.visitFieldref(this, data);
  18.365 +        }
  18.366 +    }
  18.367 +
  18.368 +    public static class CONSTANT_Float_info extends CPInfo {
  18.369 +        CONSTANT_Float_info(ClassReader cr) throws IOException {
  18.370 +            value = cr.readFloat();
  18.371 +        }
  18.372 +
  18.373 +        public CONSTANT_Float_info(float value) {
  18.374 +            this.value = value;
  18.375 +        }
  18.376 +
  18.377 +        public int getTag() {
  18.378 +            return CONSTANT_Float;
  18.379 +        }
  18.380 +
  18.381 +        @Override
  18.382 +        public String toString() {
  18.383 +            return "CONSTANT_Float_info[value: " + value + "]";
  18.384 +        }
  18.385 +
  18.386 +        public <R, D> R accept(Visitor<R, D> visitor, D data) {
  18.387 +            return visitor.visitFloat(this, data);
  18.388 +        }
  18.389 +
  18.390 +        public final float value;
  18.391 +    }
  18.392 +
  18.393 +    public static class CONSTANT_Integer_info extends CPInfo {
  18.394 +        CONSTANT_Integer_info(ClassReader cr) throws IOException {
  18.395 +            value = cr.readInt();
  18.396 +        }
  18.397 +
  18.398 +        public CONSTANT_Integer_info(int value) {
  18.399 +            this.value = value;
  18.400 +        }
  18.401 +
  18.402 +        public int getTag() {
  18.403 +            return CONSTANT_Integer;
  18.404 +        }
  18.405 +
  18.406 +        @Override
  18.407 +        public String toString() {
  18.408 +            return "CONSTANT_Integer_info[value: " + value + "]";
  18.409 +        }
  18.410 +
  18.411 +        public <R, D> R accept(Visitor<R, D> visitor, D data) {
  18.412 +            return visitor.visitInteger(this, data);
  18.413 +        }
  18.414 +
  18.415 +        public final int value;
  18.416 +    }
  18.417 +
  18.418 +    public static class CONSTANT_InterfaceMethodref_info extends CPRefInfo {
  18.419 +        CONSTANT_InterfaceMethodref_info(ConstantPool cp, ClassReader cr) throws IOException {
  18.420 +            super(cp, cr, CONSTANT_InterfaceMethodref);
  18.421 +        }
  18.422 +
  18.423 +        public CONSTANT_InterfaceMethodref_info(ConstantPool cp, int class_index, int name_and_type_index) {
  18.424 +            super(cp, CONSTANT_InterfaceMethodref, class_index, name_and_type_index);
  18.425 +        }
  18.426 +
  18.427 +        @Override
  18.428 +        public String toString() {
  18.429 +            return "CONSTANT_InterfaceMethodref_info[class_index: " + class_index + ", name_and_type_index: " + name_and_type_index + "]";
  18.430 +        }
  18.431 +
  18.432 +        public <R, D> R accept(Visitor<R, D> visitor, D data) {
  18.433 +            return visitor.visitInterfaceMethodref(this, data);
  18.434 +        }
  18.435 +    }
  18.436 +
  18.437 +    public static class CONSTANT_Long_info extends CPInfo {
  18.438 +        CONSTANT_Long_info(ClassReader cr) throws IOException {
  18.439 +            value = cr.readLong();
  18.440 +        }
  18.441 +
  18.442 +        public CONSTANT_Long_info(long value) {
  18.443 +            this.value = value;
  18.444 +        }
  18.445 +
  18.446 +        public int getTag() {
  18.447 +            return CONSTANT_Long;
  18.448 +        }
  18.449 +
  18.450 +        @Override
  18.451 +        public String toString() {
  18.452 +            return "CONSTANT_Long_info[value: " + value + "]";
  18.453 +        }
  18.454 +
  18.455 +        public <R, D> R accept(Visitor<R, D> visitor, D data) {
  18.456 +            return visitor.visitLong(this, data);
  18.457 +        }
  18.458 +
  18.459 +        public final long value;
  18.460 +    }
  18.461 +
  18.462 +    public static class CONSTANT_Methodref_info extends CPRefInfo {
  18.463 +        CONSTANT_Methodref_info(ConstantPool cp, ClassReader cr) throws IOException {
  18.464 +            super(cp, cr, CONSTANT_Methodref);
  18.465 +        }
  18.466 +
  18.467 +        public CONSTANT_Methodref_info(ConstantPool cp, int class_index, int name_and_type_index) {
  18.468 +            super(cp, CONSTANT_Methodref, class_index, name_and_type_index);
  18.469 +        }
  18.470 +
  18.471 +        @Override
  18.472 +        public String toString() {
  18.473 +            return "CONSTANT_Methodref_info[class_index: " + class_index + ", name_and_type_index: " + name_and_type_index + "]";
  18.474 +        }
  18.475 +
  18.476 +        public <R, D> R accept(Visitor<R, D> visitor, D data) {
  18.477 +            return visitor.visitMethodref(this, data);
  18.478 +        }
  18.479 +    }
  18.480 +
  18.481 +    public static class CONSTANT_NameAndType_info extends CPInfo {
  18.482 +        CONSTANT_NameAndType_info(ConstantPool cp, ClassReader cr) throws IOException {
  18.483 +            super(cp);
  18.484 +            name_index = cr.readUnsignedShort();
  18.485 +            type_index = cr.readUnsignedShort();
  18.486 +        }
  18.487 +
  18.488 +        public CONSTANT_NameAndType_info(ConstantPool cp, int name_index, int type_index) {
  18.489 +            super(cp);
  18.490 +            this.name_index = name_index;
  18.491 +            this.type_index = type_index;
  18.492 +        }
  18.493 +
  18.494 +        public int getTag() {
  18.495 +            return CONSTANT_NameAndType;
  18.496 +        }
  18.497 +
  18.498 +        public String getName() throws ConstantPoolException {
  18.499 +            return cp.getUTF8Value(name_index);
  18.500 +        }
  18.501 +
  18.502 +        public String getType() throws ConstantPoolException {
  18.503 +            return cp.getUTF8Value(type_index);
  18.504 +        }
  18.505 +
  18.506 +        public <R, D> R accept(Visitor<R, D> visitor, D data) {
  18.507 +            return visitor.visitNameAndType(this, data);
  18.508 +        }
  18.509 +
  18.510 +        public final int name_index;
  18.511 +        public final int type_index;
  18.512 +    }
  18.513 +
  18.514 +    public static class CONSTANT_String_info extends CPInfo {
  18.515 +        CONSTANT_String_info(ClassReader cr) throws IOException {
  18.516 +            string_index = cr.readUnsignedShort();
  18.517 +        }
  18.518 +
  18.519 +        public CONSTANT_String_info(ConstantPool cp, int string_index) {
  18.520 +            super(cp);
  18.521 +            this.string_index = string_index;
  18.522 +        }
  18.523 +
  18.524 +        public int getTag() {
  18.525 +            return CONSTANT_String;
  18.526 +        }
  18.527 +
  18.528 +        public String getString() throws ConstantPoolException {
  18.529 +            return cp.getUTF8Value(string_index);
  18.530 +        }
  18.531 +
  18.532 +        public <R, D> R accept(Visitor<R, D> visitor, D data) {
  18.533 +            return visitor.visitString(this, data);
  18.534 +        }
  18.535 +
  18.536 +        public final int string_index;
  18.537 +    }
  18.538 +
  18.539 +    public static class CONSTANT_Utf8_info extends CPInfo {
  18.540 +        CONSTANT_Utf8_info(ClassReader cr) throws IOException {
  18.541 +            value = cr.readUTF();
  18.542 +        }
  18.543 +
  18.544 +        public CONSTANT_Utf8_info(String value) {
  18.545 +            this.value = value;
  18.546 +        }
  18.547 +
  18.548 +        public int getTag() {
  18.549 +            return CONSTANT_Utf8;
  18.550 +        }
  18.551 +
  18.552 +        @Override
  18.553 +        public String toString() {
  18.554 +            return "CONSTANT_Utf8_info[value: " + value + "]";
  18.555 +        }
  18.556 +
  18.557 +        public <R, D> R accept(Visitor<R, D> visitor, D data) {
  18.558 +            return visitor.visitUtf8(this, data);
  18.559 +        }
  18.560 +
  18.561 +        public final String value;
  18.562 +    }
  18.563 +
  18.564 +
  18.565 +}

    19.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    19.2 +++ b/src/share/classes/com/sun/tools/classfile/ConstantPoolException.java	Tue Jun 03 13:26:47 2008 -0700
    19.3 @@ -0,0 +1,41 @@
    19.4 +/*
    19.5 + * Copyright 2008 Sun Microsystems, Inc.  All Rights Reserved.
    19.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    19.7 + *
    19.8 + * This code is free software; you can redistribute it and/or modify it
    19.9 + * under the terms of the GNU General Public License version 2 only, as
   19.10 + * published by the Free Software Foundation.  Sun designates this
   19.11 + * particular file as subject to the "Classpath" exception as provided
   19.12 + * by Sun in the LICENSE file that accompanied this code.
   19.13 + *
   19.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   19.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   19.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   19.17 + * version 2 for more details (a copy is included in the LICENSE file that
   19.18 + * accompanied this code).
   19.19 + *
   19.20 + * You should have received a copy of the GNU General Public License version
   19.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   19.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   19.23 + *
   19.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
   19.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
   19.26 + * have any questions.
   19.27 + */
   19.28 +
   19.29 +
   19.30 +package com.sun.tools.classfile;
   19.31 +
   19.32 +/*
   19.33 + *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
   19.34 + *  you write code that depends on this, you do so at your own risk.
   19.35 + *  This code and its internal interfaces are subject to change or
   19.36 + *  deletion without notice.</b>
   19.37 + */
   19.38 +public class ConstantPoolException extends Exception {
   19.39 +    ConstantPoolException(int index) {
   19.40 +        this.index = index;
   19.41 +    }
   19.42 +
   19.43 +    public final int index;
   19.44 +}

    20.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    20.2 +++ b/src/share/classes/com/sun/tools/classfile/ConstantValue_attribute.java	Tue Jun 03 13:26:47 2008 -0700
    20.3 @@ -0,0 +1,59 @@
    20.4 +/*
    20.5 + * Copyright 2007 Sun Microsystems, Inc.  All Rights Reserved.
    20.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    20.7 + *
    20.8 + * This code is free software; you can redistribute it and/or modify it
    20.9 + * under the terms of the GNU General Public License version 2 only, as
   20.10 + * published by the Free Software Foundation.  Sun designates this
   20.11 + * particular file as subject to the "Classpath" exception as provided
   20.12 + * by Sun in the LICENSE file that accompanied this code.
   20.13 + *
   20.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   20.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   20.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   20.17 + * version 2 for more details (a copy is included in the LICENSE file that
   20.18 + * accompanied this code).
   20.19 + *
   20.20 + * You should have received a copy of the GNU General Public License version
   20.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   20.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   20.23 + *
   20.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
   20.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
   20.26 + * have any questions.
   20.27 + */
   20.28 +
   20.29 +package com.sun.tools.classfile;
   20.30 +
   20.31 +import java.io.IOException;
   20.32 +
   20.33 +/**
   20.34 + * See JVMS3, section 4.8.2.
   20.35 + *
   20.36 + *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
   20.37 + *  you write code that depends on this, you do so at your own risk.
   20.38 + *  This code and its internal interfaces are subject to change or
   20.39 + *  deletion without notice.</b>
   20.40 + */
   20.41 +public class ConstantValue_attribute extends Attribute {
   20.42 +    ConstantValue_attribute(ClassReader cr, int name_index, int length) throws IOException {
   20.43 +        super(name_index, length);
   20.44 +        constantvalue_index = cr.readUnsignedShort();
   20.45 +    }
   20.46 +
   20.47 +    public ConstantValue_attribute(ConstantPool constant_pool, int constantvalue_index)
   20.48 +            throws ConstantPoolException {
   20.49 +        this(constant_pool.getUTF8Index(Attribute.ConstantValue), constantvalue_index);
   20.50 +    }
   20.51 +
   20.52 +    public ConstantValue_attribute(int name_index, int constantvalue_index) {
   20.53 +        super(name_index, 2);
   20.54 +        this.constantvalue_index = constantvalue_index;
   20.55 +    }
   20.56 +
   20.57 +    public <R, D> R accept(Visitor<R, D> visitor, D data) {
   20.58 +        return visitor.visitConstantValue(this, data);
   20.59 +    }
   20.60 +
   20.61 +    public final int constantvalue_index;
   20.62 +}

    21.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    21.2 +++ b/src/share/classes/com/sun/tools/classfile/DefaultAttribute.java	Tue Jun 03 13:26:47 2008 -0700
    21.3 @@ -0,0 +1,50 @@
    21.4 +/*
    21.5 + * Copyright 2007 Sun Microsystems, Inc.  All Rights Reserved.
    21.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    21.7 + *
    21.8 + * This code is free software; you can redistribute it and/or modify it
    21.9 + * under the terms of the GNU General Public License version 2 only, as
   21.10 + * published by the Free Software Foundation.  Sun designates this
   21.11 + * particular file as subject to the "Classpath" exception as provided
   21.12 + * by Sun in the LICENSE file that accompanied this code.
   21.13 + *
   21.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   21.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   21.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   21.17 + * version 2 for more details (a copy is included in the LICENSE file that
   21.18 + * accompanied this code).
   21.19 + *
   21.20 + * You should have received a copy of the GNU General Public License version
   21.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   21.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   21.23 + *
   21.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
   21.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
   21.26 + * have any questions.
   21.27 + */
   21.28 +
   21.29 +package com.sun.tools.classfile;
   21.30 +
   21.31 +/*
   21.32 + *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
   21.33 + *  you write code that depends on this, you do so at your own risk.
   21.34 + *  This code and its internal interfaces are subject to change or
   21.35 + *  deletion without notice.</b>
   21.36 + */
   21.37 +public class DefaultAttribute extends Attribute {
   21.38 +    DefaultAttribute(ClassReader cr, int name_index, byte[] data) {
   21.39 +        super(name_index, data.length);
   21.40 +        info = data;
   21.41 +    }
   21.42 +
   21.43 +    public DefaultAttribute(ConstantPool constant_pool, int name_index, byte[] info) {
   21.44 +        super(name_index, info.length);
   21.45 +        this.info = info;
   21.46 +    }
   21.47 +
   21.48 +    public <R, P> R accept(Visitor<R, P> visitor, P p) {
   21.49 +        return visitor.visitDefault(this, p);
   21.50 +    }
   21.51 +
   21.52 +    public final byte[] info;
   21.53 +}

    22.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    22.2 +++ b/src/share/classes/com/sun/tools/classfile/Deprecated_attribute.java	Tue Jun 03 13:26:47 2008 -0700
    22.3 @@ -0,0 +1,55 @@
    22.4 +/*
    22.5 + * Copyright 2007 Sun Microsystems, Inc.  All Rights Reserved.
    22.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    22.7 + *
    22.8 + * This code is free software; you can redistribute it and/or modify it
    22.9 + * under the terms of the GNU General Public License version 2 only, as
   22.10 + * published by the Free Software Foundation.  Sun designates this
   22.11 + * particular file as subject to the "Classpath" exception as provided
   22.12 + * by Sun in the LICENSE file that accompanied this code.
   22.13 + *
   22.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   22.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   22.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   22.17 + * version 2 for more details (a copy is included in the LICENSE file that
   22.18 + * accompanied this code).
   22.19 + *
   22.20 + * You should have received a copy of the GNU General Public License version
   22.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   22.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   22.23 + *
   22.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
   22.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
   22.26 + * have any questions.
   22.27 + */
   22.28 +
   22.29 +package com.sun.tools.classfile;
   22.30 +
   22.31 +import java.io.IOException;
   22.32 +
   22.33 +/**
   22.34 + * See JVMS3, section 4.8.15.
   22.35 + *
   22.36 + *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
   22.37 + *  you write code that depends on this, you do so at your own risk.
   22.38 + *  This code and its internal interfaces are subject to change or
   22.39 + *  deletion without notice.</b>
   22.40 + */
   22.41 +public class Deprecated_attribute extends Attribute {
   22.42 +    Deprecated_attribute(ClassReader cr, int name_index, int length) throws IOException {
   22.43 +        super(name_index, length);
   22.44 +    }
   22.45 +
   22.46 +    public Deprecated_attribute(ConstantPool constant_pool)
   22.47 +            throws ConstantPoolException {
   22.48 +        this(constant_pool.getUTF8Index(Attribute.Deprecated));
   22.49 +    }
   22.50 +
   22.51 +    public Deprecated_attribute(int name_index) {
   22.52 +        super(name_index, 0);
   22.53 +    }
   22.54 +
   22.55 +    public <R, D> R accept(Visitor<R, D> visitor, D data) {
   22.56 +        return visitor.visitDeprecated(this, data);
   22.57 +    }
   22.58 +}

    23.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    23.2 +++ b/src/share/classes/com/sun/tools/classfile/Descriptor.java	Tue Jun 03 13:26:47 2008 -0700
    23.3 @@ -0,0 +1,198 @@
    23.4 +/*
    23.5 + * Copyright 2007 Sun Microsystems, Inc.  All Rights Reserved.
    23.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    23.7 + *
    23.8 + * This code is free software; you can redistribute it and/or modify it
    23.9 + * under the terms of the GNU General Public License version 2 only, as
   23.10 + * published by the Free Software Foundation.  Sun designates this
   23.11 + * particular file as subject to the "Classpath" exception as provided
   23.12 + * by Sun in the LICENSE file that accompanied this code.
   23.13 + *
   23.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   23.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   23.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   23.17 + * version 2 for more details (a copy is included in the LICENSE file that
   23.18 + * accompanied this code).
   23.19 + *
   23.20 + * You should have received a copy of the GNU General Public License version
   23.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   23.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   23.23 + *
   23.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
   23.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
   23.26 + * have any questions.
   23.27 + */
   23.28 +
   23.29 +
   23.30 +package com.sun.tools.classfile;
   23.31 +
   23.32 +import java.io.IOException;
   23.33 +
   23.34 +/**
   23.35 + * See JVMS3, section 4.4.
   23.36 + *
   23.37 + *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
   23.38 + *  you write code that depends on this, you do so at your own risk.
   23.39 + *  This code and its internal interfaces are subject to change or
   23.40 + *  deletion without notice.</b>
   23.41 + */
   23.42 +public class Descriptor {
   23.43 +    public class InvalidDescriptor extends DescriptorException {
   23.44 +        InvalidDescriptor(String desc) {
   23.45 +            this.desc = desc;
   23.46 +            this.index = -1;
   23.47 +        }
   23.48 +
   23.49 +        InvalidDescriptor(String desc, int index) {
   23.50 +            this.desc = desc;
   23.51 +            this.index = index;
   23.52 +        }
   23.53 +
   23.54 +        @Override
   23.55 +        public String getMessage() {
   23.56 +            // i18n
   23.57 +            if (index == -1)
   23.58 +                return "invalid descriptor \"" + desc + "\"";
   23.59 +            else
   23.60 +                return "descriptor is invalid at offset " + index + " in \"" + desc + "\"";
   23.61 +        }
   23.62 +
   23.63 +        public final String desc;
   23.64 +        public final int index;
   23.65 +
   23.66 +    }
   23.67 +
   23.68 +    public Descriptor(ClassReader cr) throws IOException {
   23.69 +        this(cr.readUnsignedShort());
   23.70 +    }
   23.71 +
   23.72 +    public Descriptor(int index) {
   23.73 +        this.index = index;
   23.74 +
   23.75 +    }
   23.76 +
   23.77 +    public String getValue(ConstantPool constant_pool) throws ConstantPoolException {
   23.78 +        return constant_pool.getUTF8Value(index);
   23.79 +    }
   23.80 +
   23.81 +    public int getParameterCount(ConstantPool constant_pool)
   23.82 +            throws ConstantPoolException, InvalidDescriptor {
   23.83 +        String desc = getValue(constant_pool);
   23.84 +        int end = desc.indexOf(")");
   23.85 +        if (end == -1)
   23.86 +            throw new InvalidDescriptor(desc);
   23.87 +        parse(desc, 0, end + 1);
   23.88 +        return count;
   23.89 +
   23.90 +    }
   23.91 +
   23.92 +    public String getParameterTypes(ConstantPool constant_pool)
   23.93 +            throws ConstantPoolException, InvalidDescriptor {
   23.94 +        String desc = getValue(constant_pool);
   23.95 +        int end = desc.indexOf(")");
   23.96 +        if (end == -1)
   23.97 +            throw new InvalidDescriptor(desc);
   23.98 +        return parse(desc, 0, end + 1);
   23.99 +    }
  23.100 +
  23.101 +    public String getReturnType(ConstantPool constant_pool)
  23.102 +            throws ConstantPoolException, InvalidDescriptor {
  23.103 +        String desc = getValue(constant_pool);
  23.104 +        int end = desc.indexOf(")");
  23.105 +        if (end == -1)
  23.106 +            throw new InvalidDescriptor(desc);
  23.107 +        return parse(desc, end + 1, desc.length());
  23.108 +    }
  23.109 +
  23.110 +    public String getFieldType(ConstantPool constant_pool)
  23.111 +            throws ConstantPoolException, InvalidDescriptor {
  23.112 +        String desc = getValue(constant_pool);
  23.113 +        return parse(desc, 0, desc.length());
  23.114 +    }
  23.115 +
  23.116 +    private String parse(String desc, int start, int end)
  23.117 +            throws InvalidDescriptor {
  23.118 +        int p = start;
  23.119 +        StringBuffer sb = new StringBuffer();
  23.120 +        int dims = 0;
  23.121 +        count = 0;
  23.122 +
  23.123 +        while (p < end) {
  23.124 +            String type;
  23.125 +            char ch;
  23.126 +            switch (ch = desc.charAt(p++)) {
  23.127 +                case '(':
  23.128 +                    sb.append('(');
  23.129 +                    continue;
  23.130 +
  23.131 +                case ')':
  23.132 +                    sb.append(')');
  23.133 +                    continue;
  23.134 +
  23.135 +                case '[':
  23.136 +                    dims++;
  23.137 +                    continue;
  23.138 +
  23.139 +                case 'B':
  23.140 +                    type = "byte";
  23.141 +                    break;
  23.142 +
  23.143 +                case 'C':
  23.144 +                    type = "char";
  23.145 +                    break;
  23.146 +
  23.147 +                case 'D':
  23.148 +                    type = "double";
  23.149 +                    break;
  23.150 +
  23.151 +                case 'F':
  23.152 +                    type = "float";
  23.153 +                    break;
  23.154 +
  23.155 +                case 'I':
  23.156 +                    type = "int";
  23.157 +                    break;
  23.158 +
  23.159 +                case 'J':
  23.160 +                    type = "long";
  23.161 +                    break;
  23.162 +
  23.163 +                case 'L':
  23.164 +                    int sep = desc.indexOf(';', p);
  23.165 +                    if (sep == -1)
  23.166 +                        throw new InvalidDescriptor(desc, p - 1);
  23.167 +                    type = desc.substring(p, sep).replace('/', '.');
  23.168 +                    p = sep + 1;
  23.169 +                    break;
  23.170 +
  23.171 +                case 'S':
  23.172 +                    type = "short";
  23.173 +                    break;
  23.174 +
  23.175 +                case 'Z':
  23.176 +                    type = "boolean";
  23.177 +                    break;
  23.178 +
  23.179 +                case 'V':
  23.180 +                    type = "void";
  23.181 +                    break;
  23.182 +
  23.183 +                default:
  23.184 +                    throw new InvalidDescriptor(desc, p - 1);
  23.185 +            }
  23.186 +
  23.187 +            if (sb.length() > 1 && sb.charAt(0) == '(')
  23.188 +                sb.append(", ");
  23.189 +            sb.append(type);
  23.190 +            for ( ; dims > 0; dims-- )
  23.191 +                sb.append("[]");
  23.192 +
  23.193 +            count++;
  23.194 +        }
  23.195 +
  23.196 +        return sb.toString();
  23.197 +    }
  23.198 +
  23.199 +    public final int index;
  23.200 +    private int count;
  23.201 +}