1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/src/clojure/asm/AnnotationVisitor.java	Sat Aug 21 06:25:44 2010 -0400
     1.3 @@ -0,0 +1,97 @@
     1.4 +/***
     1.5 + * ASM: a very small and fast Java bytecode manipulation framework
     1.6 + * Copyright (c) 2000-2005 INRIA, France Telecom
     1.7 + * All rights reserved.
     1.8 + *
     1.9 + * Redistribution and use in source and binary forms, with or without
    1.10 + * modification, are permitted provided that the following conditions
    1.11 + * are met:
    1.12 + * 1. Redistributions of source code must retain the above copyright
    1.13 + *    notice, this list of conditions and the following disclaimer.
    1.14 + * 2. Redistributions in binary form must reproduce the above copyright
    1.15 + *    notice, this list of conditions and the following disclaimer in the
    1.16 + *    documentation and/or other materials provided with the distribution.
    1.17 + * 3. Neither the name of the copyright holders nor the names of its
    1.18 + *    contributors may be used to endorse or promote products derived from
    1.19 + *    this software without specific prior written permission.
    1.20 + *
    1.21 + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    1.22 + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    1.23 + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    1.24 + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
    1.25 + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    1.26 + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    1.27 + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    1.28 + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    1.29 + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    1.30 + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
    1.31 + * THE POSSIBILITY OF SUCH DAMAGE.
    1.32 + */
    1.33 +package clojure.asm;
    1.34 +
    1.35 +/**
    1.36 + * A visitor to visit a Java annotation. The methods of this interface must be
    1.37 + * called in the following order: (<tt>visit<tt> | <tt>visitEnum<tt> |
    1.38 + * <tt>visitAnnotation<tt> | <tt>visitArray<tt>)* <tt>visitEnd<tt>.
    1.39 + *
    1.40 + * @author Eric Bruneton
    1.41 + * @author Eugene Kuleshov
    1.42 + */
    1.43 +public interface AnnotationVisitor{
    1.44 +
    1.45 +/**
    1.46 + * Visits a primitive value of the annotation.
    1.47 + *
    1.48 + * @param name  the value name.
    1.49 + * @param value the actual value, whose type must be {@link Byte},
    1.50 + *              {@link Boolean}, {@link Character}, {@link Short},
    1.51 + *              {@link Integer}, {@link Long}, {@link Float}, {@link Double},
    1.52 + *              {@link String} or {@link Type}. This value can also be an array
    1.53 + *              of byte, boolean, short, char, int, long, float or double values
    1.54 + *              (this is equivalent to using {@link #visitArray visitArray} and
    1.55 + *              visiting each array element in turn, but is more convenient).
    1.56 + */
    1.57 +void visit(String name, Object value);
    1.58 +
    1.59 +/**
    1.60 + * Visits an enumeration value of the annotation.
    1.61 + *
    1.62 + * @param name  the value name.
    1.63 + * @param desc  the class descriptor of the enumeration class.
    1.64 + * @param value the actual enumeration value.
    1.65 + */
    1.66 +void visitEnum(String name, String desc, String value);
    1.67 +
    1.68 +/**
    1.69 + * Visits a nested annotation value of the annotation.
    1.70 + *
    1.71 + * @param name the value name.
    1.72 + * @param desc the class descriptor of the nested annotation class.
    1.73 + * @return a visitor to visit the actual nested annotation value, or
    1.74 + *         <tt>null</tt> if this visitor is not interested in visiting
    1.75 + *         this nested annotation. <i>The nested annotation value must be
    1.76 + *         fully visited before calling other methods on this annotation
    1.77 + *         visitor</i>.
    1.78 + */
    1.79 +AnnotationVisitor visitAnnotation(String name, String desc);
    1.80 +
    1.81 +/**
    1.82 + * Visits an array value of the annotation. Note that arrays of primitive
    1.83 + * types (such as byte, boolean, short, char, int, long, float or double)
    1.84 + * can be passed as value to {@link #visit visit}. This is what
    1.85 + * {@link ClassReader} does.
    1.86 + *
    1.87 + * @param name the value name.
    1.88 + * @return a visitor to visit the actual array value elements, or
    1.89 + *         <tt>null</tt> if this visitor is not interested in visiting
    1.90 + *         these values. The 'name' parameters passed to the methods of this
    1.91 + *         visitor are ignored. <i>All the array values must be visited
    1.92 + *         before calling other methods on this annotation visitor</i>.
    1.93 + */
    1.94 +AnnotationVisitor visitArray(String name);
    1.95 +
    1.96 +/**
    1.97 + * Visits the end of the annotation.
    1.98 + */
    1.99 +void visitEnd();
   1.100 +}

     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/src/clojure/asm/AnnotationWriter.java	Sat Aug 21 06:25:44 2010 -0400
     2.3 @@ -0,0 +1,357 @@
     2.4 +/***
     2.5 + * ASM: a very small and fast Java bytecode manipulation framework
     2.6 + * Copyright (c) 2000-2005 INRIA, France Telecom
     2.7 + * All rights reserved.
     2.8 + *
     2.9 + * Redistribution and use in source and binary forms, with or without
    2.10 + * modification, are permitted provided that the following conditions
    2.11 + * are met:
    2.12 + * 1. Redistributions of source code must retain the above copyright
    2.13 + *    notice, this list of conditions and the following disclaimer.
    2.14 + * 2. Redistributions in binary form must reproduce the above copyright
    2.15 + *    notice, this list of conditions and the following disclaimer in the
    2.16 + *    documentation and/or other materials provided with the distribution.
    2.17 + * 3. Neither the name of the copyright holders nor the names of its
    2.18 + *    contributors may be used to endorse or promote products derived from
    2.19 + *    this software without specific prior written permission.
    2.20 + *
    2.21 + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    2.22 + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    2.23 + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    2.24 + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
    2.25 + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    2.26 + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    2.27 + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    2.28 + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    2.29 + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    2.30 + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
    2.31 + * THE POSSIBILITY OF SUCH DAMAGE.
    2.32 + */
    2.33 +package clojure.asm;
    2.34 +
    2.35 +/**
    2.36 + * An {@link AnnotationVisitor} that generates annotations in bytecode form.
    2.37 + *
    2.38 + * @author Eric Bruneton
    2.39 + * @author Eugene Kuleshov
    2.40 + */
    2.41 +final class AnnotationWriter implements AnnotationVisitor{
    2.42 +
    2.43 +/**
    2.44 + * The class writer to which this annotation must be added.
    2.45 + */
    2.46 +private final ClassWriter cw;
    2.47 +
    2.48 +/**
    2.49 + * The number of values in this annotation.
    2.50 + */
    2.51 +private int size;
    2.52 +
    2.53 +/**
    2.54 + * <tt>true<tt> if values are named, <tt>false</tt> otherwise. Annotation
    2.55 + * writers used for annotation default and annotation arrays use unnamed
    2.56 + * values.
    2.57 + */
    2.58 +private final boolean named;
    2.59 +
    2.60 +/**
    2.61 + * The annotation values in bytecode form. This byte vector only contains
    2.62 + * the values themselves, i.e. the number of values must be stored as a
    2.63 + * unsigned short just before these bytes.
    2.64 + */
    2.65 +private final ByteVector bv;
    2.66 +
    2.67 +/**
    2.68 + * The byte vector to be used to store the number of values of this
    2.69 + * annotation. See {@link #bv}.
    2.70 + */
    2.71 +private final ByteVector parent;
    2.72 +
    2.73 +/**
    2.74 + * Where the number of values of this annotation must be stored in
    2.75 + * {@link #parent}.
    2.76 + */
    2.77 +private final int offset;
    2.78 +
    2.79 +/**
    2.80 + * Next annotation writer. This field is used to store annotation lists.
    2.81 + */
    2.82 +AnnotationWriter next;
    2.83 +
    2.84 +/**
    2.85 + * Previous annotation writer. This field is used to store annotation lists.
    2.86 + */
    2.87 +AnnotationWriter prev;
    2.88 +
    2.89 +// ------------------------------------------------------------------------
    2.90 +// Constructor
    2.91 +// ------------------------------------------------------------------------
    2.92 +
    2.93 +/**
    2.94 + * Constructs a new {@link AnnotationWriter}.
    2.95 + *
    2.96 + * @param cw     the class writer to which this annotation must be added.
    2.97 + * @param named  <tt>true<tt> if values are named, <tt>false</tt> otherwise.
    2.98 + * @param bv     where the annotation values must be stored.
    2.99 + * @param parent where the number of annotation values must be stored.
   2.100 + * @param offset where in <tt>parent</tt> the number of annotation values must
   2.101 + *               be stored.
   2.102 + */
   2.103 +AnnotationWriter(
   2.104 +		final ClassWriter cw,
   2.105 +		final boolean named,
   2.106 +		final ByteVector bv,
   2.107 +		final ByteVector parent,
   2.108 +		final int offset){
   2.109 +	this.cw = cw;
   2.110 +	this.named = named;
   2.111 +	this.bv = bv;
   2.112 +	this.parent = parent;
   2.113 +	this.offset = offset;
   2.114 +}
   2.115 +
   2.116 +// ------------------------------------------------------------------------
   2.117 +// Implementation of the AnnotationVisitor interface
   2.118 +// ------------------------------------------------------------------------
   2.119 +
   2.120 +public void visit(final String name, final Object value){
   2.121 +	++size;
   2.122 +	if(named)
   2.123 +		{
   2.124 +		bv.putShort(cw.newUTF8(name));
   2.125 +		}
   2.126 +	if(value instanceof String)
   2.127 +		{
   2.128 +		bv.put12('s', cw.newUTF8((String) value));
   2.129 +		}
   2.130 +	else if(value instanceof Byte)
   2.131 +		{
   2.132 +		bv.put12('B', cw.newInteger(((Byte) value).byteValue()).index);
   2.133 +		}
   2.134 +	else if(value instanceof Boolean)
   2.135 +		{
   2.136 +		int v = ((Boolean) value).booleanValue() ? 1 : 0;
   2.137 +		bv.put12('Z', cw.newInteger(v).index);
   2.138 +		}
   2.139 +	else if(value instanceof Character)
   2.140 +		{
   2.141 +		bv.put12('C', cw.newInteger(((Character) value).charValue()).index);
   2.142 +		}
   2.143 +	else if(value instanceof Short)
   2.144 +		{
   2.145 +		bv.put12('S', cw.newInteger(((Short) value).shortValue()).index);
   2.146 +		}
   2.147 +	else if(value instanceof Type)
   2.148 +		{
   2.149 +		bv.put12('c', cw.newUTF8(((Type) value).getDescriptor()));
   2.150 +		}
   2.151 +	else if(value instanceof byte[])
   2.152 +		{
   2.153 +		byte[] v = (byte[]) value;
   2.154 +		bv.put12('[', v.length);
   2.155 +		for(int i = 0; i < v.length; i++)
   2.156 +			{
   2.157 +			bv.put12('B', cw.newInteger(v[i]).index);
   2.158 +			}
   2.159 +		}
   2.160 +	else if(value instanceof boolean[])
   2.161 +		{
   2.162 +		boolean[] v = (boolean[]) value;
   2.163 +		bv.put12('[', v.length);
   2.164 +		for(int i = 0; i < v.length; i++)
   2.165 +			{
   2.166 +			bv.put12('Z', cw.newInteger(v[i] ? 1 : 0).index);
   2.167 +			}
   2.168 +		}
   2.169 +	else if(value instanceof short[])
   2.170 +		{
   2.171 +		short[] v = (short[]) value;
   2.172 +		bv.put12('[', v.length);
   2.173 +		for(int i = 0; i < v.length; i++)
   2.174 +			{
   2.175 +			bv.put12('S', cw.newInteger(v[i]).index);
   2.176 +			}
   2.177 +		}
   2.178 +	else if(value instanceof char[])
   2.179 +		{
   2.180 +		char[] v = (char[]) value;
   2.181 +		bv.put12('[', v.length);
   2.182 +		for(int i = 0; i < v.length; i++)
   2.183 +			{
   2.184 +			bv.put12('C', cw.newInteger(v[i]).index);
   2.185 +			}
   2.186 +		}
   2.187 +	else if(value instanceof int[])
   2.188 +		{
   2.189 +		int[] v = (int[]) value;
   2.190 +		bv.put12('[', v.length);
   2.191 +		for(int i = 0; i < v.length; i++)
   2.192 +			{
   2.193 +			bv.put12('I', cw.newInteger(v[i]).index);
   2.194 +			}
   2.195 +		}
   2.196 +	else if(value instanceof long[])
   2.197 +		{
   2.198 +		long[] v = (long[]) value;
   2.199 +		bv.put12('[', v.length);
   2.200 +		for(int i = 0; i < v.length; i++)
   2.201 +			{
   2.202 +			bv.put12('J', cw.newLong(v[i]).index);
   2.203 +			}
   2.204 +		}
   2.205 +	else if(value instanceof float[])
   2.206 +		{
   2.207 +		float[] v = (float[]) value;
   2.208 +		bv.put12('[', v.length);
   2.209 +		for(int i = 0; i < v.length; i++)
   2.210 +			{
   2.211 +			bv.put12('F', cw.newFloat(v[i]).index);
   2.212 +			}
   2.213 +		}
   2.214 +	else if(value instanceof double[])
   2.215 +		{
   2.216 +		double[] v = (double[]) value;
   2.217 +		bv.put12('[', v.length);
   2.218 +		for(int i = 0; i < v.length; i++)
   2.219 +			{
   2.220 +			bv.put12('D', cw.newDouble(v[i]).index);
   2.221 +			}
   2.222 +		}
   2.223 +	else
   2.224 +		{
   2.225 +		Item i = cw.newConstItem(value);
   2.226 +		bv.put12(".s.IFJDCS".charAt(i.type), i.index);
   2.227 +		}
   2.228 +}
   2.229 +
   2.230 +public void visitEnum(
   2.231 +		final String name,
   2.232 +		final String desc,
   2.233 +		final String value){
   2.234 +	++size;
   2.235 +	if(named)
   2.236 +		{
   2.237 +		bv.putShort(cw.newUTF8(name));
   2.238 +		}
   2.239 +	bv.put12('e', cw.newUTF8(desc)).putShort(cw.newUTF8(value));
   2.240 +}
   2.241 +
   2.242 +public AnnotationVisitor visitAnnotation(
   2.243 +		final String name,
   2.244 +		final String desc){
   2.245 +	++size;
   2.246 +	if(named)
   2.247 +		{
   2.248 +		bv.putShort(cw.newUTF8(name));
   2.249 +		}
   2.250 +	// write tag and type, and reserve space for values count
   2.251 +	bv.put12('@', cw.newUTF8(desc)).putShort(0);
   2.252 +	return new AnnotationWriter(cw, true, bv, bv, bv.length - 2);
   2.253 +}
   2.254 +
   2.255 +public AnnotationVisitor visitArray(final String name){
   2.256 +	++size;
   2.257 +	if(named)
   2.258 +		{
   2.259 +		bv.putShort(cw.newUTF8(name));
   2.260 +		}
   2.261 +	// write tag, and reserve space for array size
   2.262 +	bv.put12('[', 0);
   2.263 +	return new AnnotationWriter(cw, false, bv, bv, bv.length - 2);
   2.264 +}
   2.265 +
   2.266 +public void visitEnd(){
   2.267 +	if(parent != null)
   2.268 +		{
   2.269 +		byte[] data = parent.data;
   2.270 +		data[offset] = (byte) (size >>> 8);
   2.271 +		data[offset + 1] = (byte) size;
   2.272 +		}
   2.273 +}
   2.274 +
   2.275 +// ------------------------------------------------------------------------
   2.276 +// Utility methods
   2.277 +// ------------------------------------------------------------------------
   2.278 +
   2.279 +/**
   2.280 + * Returns the size of this annotation writer list.
   2.281 + *
   2.282 + * @return the size of this annotation writer list.
   2.283 + */
   2.284 +int getSize(){
   2.285 +	int size = 0;
   2.286 +	AnnotationWriter aw = this;
   2.287 +	while(aw != null)
   2.288 +		{
   2.289 +		size += aw.bv.length;
   2.290 +		aw = aw.next;
   2.291 +		}
   2.292 +	return size;
   2.293 +}
   2.294 +
   2.295 +/**
   2.296 + * Puts the annotations of this annotation writer list into the given byte
   2.297 + * vector.
   2.298 + *
   2.299 + * @param out where the annotations must be put.
   2.300 + */
   2.301 +void put(final ByteVector out){
   2.302 +	int n = 0;
   2.303 +	int size = 2;
   2.304 +	AnnotationWriter aw = this;
   2.305 +	AnnotationWriter last = null;
   2.306 +	while(aw != null)
   2.307 +		{
   2.308 +		++n;
   2.309 +		size += aw.bv.length;
   2.310 +		aw.visitEnd(); // in case user forgot to call visitEnd
   2.311 +		aw.prev = last;
   2.312 +		last = aw;
   2.313 +		aw = aw.next;
   2.314 +		}
   2.315 +	out.putInt(size);
   2.316 +	out.putShort(n);
   2.317 +	aw = last;
   2.318 +	while(aw != null)
   2.319 +		{
   2.320 +		out.putByteArray(aw.bv.data, 0, aw.bv.length);
   2.321 +		aw = aw.prev;
   2.322 +		}
   2.323 +}
   2.324 +
   2.325 +/**
   2.326 + * Puts the given annotation lists into the given byte vector.
   2.327 + *
   2.328 + * @param panns an array of annotation writer lists.
   2.329 + * @param out   where the annotations must be put.
   2.330 + */
   2.331 +static void put(final AnnotationWriter[] panns, final ByteVector out){
   2.332 +	int size = 1 + 2 * panns.length;
   2.333 +	for(int i = 0; i < panns.length; ++i)
   2.334 +		{
   2.335 +		size += panns[i] == null ? 0 : panns[i].getSize();
   2.336 +		}
   2.337 +	out.putInt(size).putByte(panns.length);
   2.338 +	for(int i = 0; i < panns.length; ++i)
   2.339 +		{
   2.340 +		AnnotationWriter aw = panns[i];
   2.341 +		AnnotationWriter last = null;
   2.342 +		int n = 0;
   2.343 +		while(aw != null)
   2.344 +			{
   2.345 +			++n;
   2.346 +			aw.visitEnd(); // in case user forgot to call visitEnd
   2.347 +			aw.prev = last;
   2.348 +			last = aw;
   2.349 +			aw = aw.next;
   2.350 +			}
   2.351 +		out.putShort(n);
   2.352 +		aw = last;
   2.353 +		while(aw != null)
   2.354 +			{
   2.355 +			out.putByteArray(aw.bv.data, 0, aw.bv.length);
   2.356 +			aw = aw.prev;
   2.357 +			}
   2.358 +		}
   2.359 +}
   2.360 +}

     3.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.2 +++ b/src/clojure/asm/Attribute.java	Sat Aug 21 06:25:44 2010 -0400
     3.3 @@ -0,0 +1,253 @@
     3.4 +/***
     3.5 + * ASM: a very small and fast Java bytecode manipulation framework
     3.6 + * Copyright (c) 2000-2005 INRIA, France Telecom
     3.7 + * All rights reserved.
     3.8 + *
     3.9 + * Redistribution and use in source and binary forms, with or without
    3.10 + * modification, are permitted provided that the following conditions
    3.11 + * are met:
    3.12 + * 1. Redistributions of source code must retain the above copyright
    3.13 + *    notice, this list of conditions and the following disclaimer.
    3.14 + * 2. Redistributions in binary form must reproduce the above copyright
    3.15 + *    notice, this list of conditions and the following disclaimer in the
    3.16 + *    documentation and/or other materials provided with the distribution.
    3.17 + * 3. Neither the name of the copyright holders nor the names of its
    3.18 + *    contributors may be used to endorse or promote products derived from
    3.19 + *    this software without specific prior written permission.
    3.20 + *
    3.21 + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    3.22 + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    3.23 + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    3.24 + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
    3.25 + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    3.26 + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    3.27 + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    3.28 + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    3.29 + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    3.30 + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
    3.31 + * THE POSSIBILITY OF SUCH DAMAGE.
    3.32 + */
    3.33 +package clojure.asm;
    3.34 +
    3.35 +/**
    3.36 + * A non standard class, field, method or code attribute.
    3.37 + *
    3.38 + * @author Eric Bruneton
    3.39 + * @author Eugene Kuleshov
    3.40 + */
    3.41 +public class Attribute{
    3.42 +
    3.43 +/**
    3.44 + * The type of this attribute.
    3.45 + */
    3.46 +public final String type;
    3.47 +
    3.48 +/**
    3.49 + * The raw value of this attribute, used only for unknown attributes.
    3.50 + */
    3.51 +byte[] value;
    3.52 +
    3.53 +/**
    3.54 + * The next attribute in this attribute list. May be <tt>null</tt>.
    3.55 + */
    3.56 +Attribute next;
    3.57 +
    3.58 +/**
    3.59 + * Constructs a new empty attribute.
    3.60 + *
    3.61 + * @param type the type of the attribute.
    3.62 + */
    3.63 +protected Attribute(final String type){
    3.64 +	this.type = type;
    3.65 +}
    3.66 +
    3.67 +/**
    3.68 + * Returns <tt>true</tt> if this type of attribute is unknown. The default
    3.69 + * implementation of this method always returns <tt>true</tt>.
    3.70 + *
    3.71 + * @return <tt>true</tt> if this type of attribute is unknown.
    3.72 + */
    3.73 +public boolean isUnknown(){
    3.74 +	return true;
    3.75 +}
    3.76 +
    3.77 +/**
    3.78 + * Returns <tt>true</tt> if this type of attribute is a code attribute.
    3.79 + *
    3.80 + * @return <tt>true</tt> if this type of attribute is a code attribute.
    3.81 + */
    3.82 +public boolean isCodeAttribute(){
    3.83 +	return false;
    3.84 +}
    3.85 +
    3.86 +/**
    3.87 + * Returns the labels corresponding to this attribute.
    3.88 + *
    3.89 + * @return the labels corresponding to this attribute, or <tt>null</tt> if
    3.90 + *         this attribute is not a code attribute that contains labels.
    3.91 + */
    3.92 +protected Label[] getLabels(){
    3.93 +	return null;
    3.94 +}
    3.95 +
    3.96 +/**
    3.97 + * Reads a {@link #type type} attribute. This method must return a <i>new</i>
    3.98 + * {@link Attribute} object, of type {@link #type type}, corresponding to
    3.99 + * the <tt>len</tt> bytes starting at the given offset, in the given class
   3.100 + * reader.
   3.101 + *
   3.102 + * @param cr      the class that contains the attribute to be read.
   3.103 + * @param off     index of the first byte of the attribute's content in {@link
   3.104 + *                ClassReader#b cr.b}. The 6 attribute header bytes, containing the
   3.105 + *                type and the length of the attribute, are not taken into account
   3.106 + *                here.
   3.107 + * @param len     the length of the attribute's content.
   3.108 + * @param buf     buffer to be used to call
   3.109 + *                {@link ClassReader#readUTF8 readUTF8},
   3.110 + *                {@link ClassReader#readClass(int,char[]) readClass} or
   3.111 + *                {@link ClassReader#readConst readConst}.
   3.112 + * @param codeOff index of the first byte of code's attribute content in
   3.113 + *                {@link ClassReader#b cr.b}, or -1 if the attribute to be read is
   3.114 + *                not a code attribute. The 6 attribute header bytes, containing the
   3.115 + *                type and the length of the attribute, are not taken into account
   3.116 + *                here.
   3.117 + * @param labels  the labels of the method's code, or <tt>null</tt> if the
   3.118 + *                attribute to be read is not a code attribute.
   3.119 + * @return a <i>new</i> {@link Attribute} object corresponding to the given
   3.120 + *         bytes.
   3.121 + */
   3.122 +protected Attribute read(
   3.123 +		final ClassReader cr,
   3.124 +		final int off,
   3.125 +		final int len,
   3.126 +		final char[] buf,
   3.127 +		final int codeOff,
   3.128 +		final Label[] labels){
   3.129 +	Attribute attr = new Attribute(type);
   3.130 +	attr.value = new byte[len];
   3.131 +	System.arraycopy(cr.b, off, attr.value, 0, len);
   3.132 +	return attr;
   3.133 +}
   3.134 +
   3.135 +/**
   3.136 + * Returns the byte array form of this attribute.
   3.137 + *
   3.138 + * @param cw        the class to which this attribute must be added. This parameter
   3.139 + *                  can be used to add to the constant pool of this class the items
   3.140 + *                  that corresponds to this attribute.
   3.141 + * @param code      the bytecode of the method corresponding to this code
   3.142 + *                  attribute, or <tt>null</tt> if this attribute is not a code
   3.143 + *                  attributes.
   3.144 + * @param len       the length of the bytecode of the method corresponding to this
   3.145 + *                  code attribute, or <tt>null</tt> if this attribute is not a code
   3.146 + *                  attribute.
   3.147 + * @param maxStack  the maximum stack size of the method corresponding to
   3.148 + *                  this code attribute, or -1 if this attribute is not a code
   3.149 + *                  attribute.
   3.150 + * @param maxLocals the maximum number of local variables of the method
   3.151 + *                  corresponding to this code attribute, or -1 if this attribute is
   3.152 + *                  not a code attribute.
   3.153 + * @return the byte array form of this attribute.
   3.154 + */
   3.155 +protected ByteVector write(
   3.156 +		final ClassWriter cw,
   3.157 +		final byte[] code,
   3.158 +		final int len,
   3.159 +		final int maxStack,
   3.160 +		final int maxLocals){
   3.161 +	ByteVector v = new ByteVector();
   3.162 +	v.data = value;
   3.163 +	v.length = value.length;
   3.164 +	return v;
   3.165 +}
   3.166 +
   3.167 +/**
   3.168 + * Returns the length of the attribute list that begins with this attribute.
   3.169 + *
   3.170 + * @return the length of the attribute list that begins with this attribute.
   3.171 + */
   3.172 +final int getCount(){
   3.173 +	int count = 0;
   3.174 +	Attribute attr = this;
   3.175 +	while(attr != null)
   3.176 +		{
   3.177 +		count += 1;
   3.178 +		attr = attr.next;
   3.179 +		}
   3.180 +	return count;
   3.181 +}
   3.182 +
   3.183 +/**
   3.184 + * Returns the size of all the attributes in this attribute list.
   3.185 + *
   3.186 + * @param cw        the class writer to be used to convert the attributes into byte
   3.187 + *                  arrays, with the {@link #write write} method.
   3.188 + * @param code      the bytecode of the method corresponding to these code
   3.189 + *                  attributes, or <tt>null</tt> if these attributes are not code
   3.190 + *                  attributes.
   3.191 + * @param len       the length of the bytecode of the method corresponding to
   3.192 + *                  these code attributes, or <tt>null</tt> if these attributes are
   3.193 + *                  not code attributes.
   3.194 + * @param maxStack  the maximum stack size of the method corresponding to
   3.195 + *                  these code attributes, or -1 if these attributes are not code
   3.196 + *                  attributes.
   3.197 + * @param maxLocals the maximum number of local variables of the method
   3.198 + *                  corresponding to these code attributes, or -1 if these attributes
   3.199 + *                  are not code attributes.
   3.200 + * @return the size of all the attributes in this attribute list. This size
   3.201 + *         includes the size of the attribute headers.
   3.202 + */
   3.203 +final int getSize(
   3.204 +		final ClassWriter cw,
   3.205 +		final byte[] code,
   3.206 +		final int len,
   3.207 +		final int maxStack,
   3.208 +		final int maxLocals){
   3.209 +	Attribute attr = this;
   3.210 +	int size = 0;
   3.211 +	while(attr != null)
   3.212 +		{
   3.213 +		cw.newUTF8(attr.type);
   3.214 +		size += attr.write(cw, code, len, maxStack, maxLocals).length + 6;
   3.215 +		attr = attr.next;
   3.216 +		}
   3.217 +	return size;
   3.218 +}
   3.219 +
   3.220 +/**
   3.221 + * Writes all the attributes of this attribute list in the given byte
   3.222 + * vector.
   3.223 + *
   3.224 + * @param cw        the class writer to be used to convert the attributes into byte
   3.225 + *                  arrays, with the {@link #write write} method.
   3.226 + * @param code      the bytecode of the method corresponding to these code
   3.227 + *                  attributes, or <tt>null</tt> if these attributes are not code
   3.228 + *                  attributes.
   3.229 + * @param len       the length of the bytecode of the method corresponding to
   3.230 + *                  these code attributes, or <tt>null</tt> if these attributes are
   3.231 + *                  not code attributes.
   3.232 + * @param maxStack  the maximum stack size of the method corresponding to
   3.233 + *                  these code attributes, or -1 if these attributes are not code
   3.234 + *                  attributes.
   3.235 + * @param maxLocals the maximum number of local variables of the method
   3.236 + *                  corresponding to these code attributes, or -1 if these attributes
   3.237 + *                  are not code attributes.
   3.238 + * @param out       where the attributes must be written.
   3.239 + */
   3.240 +final void put(
   3.241 +		final ClassWriter cw,
   3.242 +		final byte[] code,
   3.243 +		final int len,
   3.244 +		final int maxStack,
   3.245 +		final int maxLocals,
   3.246 +		final ByteVector out){
   3.247 +	Attribute attr = this;
   3.248 +	while(attr != null)
   3.249 +		{
   3.250 +		ByteVector b = attr.write(cw, code, len, maxStack, maxLocals);
   3.251 +		out.putShort(cw.newUTF8(attr.type)).putInt(b.length);
   3.252 +		out.putByteArray(b.data, 0, b.length);
   3.253 +		attr = attr.next;
   3.254 +		}
   3.255 +}
   3.256 +}

     4.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.2 +++ b/src/clojure/asm/ByteVector.java	Sat Aug 21 06:25:44 2010 -0400
     4.3 @@ -0,0 +1,318 @@
     4.4 +/***
     4.5 + * ASM: a very small and fast Java bytecode manipulation framework
     4.6 + * Copyright (c) 2000-2005 INRIA, France Telecom
     4.7 + * All rights reserved.
     4.8 + *
     4.9 + * Redistribution and use in source and binary forms, with or without
    4.10 + * modification, are permitted provided that the following conditions
    4.11 + * are met:
    4.12 + * 1. Redistributions of source code must retain the above copyright
    4.13 + *    notice, this list of conditions and the following disclaimer.
    4.14 + * 2. Redistributions in binary form must reproduce the above copyright
    4.15 + *    notice, this list of conditions and the following disclaimer in the
    4.16 + *    documentation and/or other materials provided with the distribution.
    4.17 + * 3. Neither the name of the copyright holders nor the names of its
    4.18 + *    contributors may be used to endorse or promote products derived from
    4.19 + *    this software without specific prior written permission.
    4.20 + *
    4.21 + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    4.22 + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    4.23 + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    4.24 + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
    4.25 + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    4.26 + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    4.27 + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    4.28 + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    4.29 + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    4.30 + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
    4.31 + * THE POSSIBILITY OF SUCH DAMAGE.
    4.32 + */
    4.33 +package clojure.asm;
    4.34 +
    4.35 +/**
    4.36 + * A dynamically extensible vector of bytes. This class is roughly equivalent to
    4.37 + * a DataOutputStream on top of a ByteArrayOutputStream, but is more efficient.
    4.38 + *
    4.39 + * @author Eric Bruneton
    4.40 + */
    4.41 +public class ByteVector{
    4.42 +
    4.43 +/**
    4.44 + * The content of this vector.
    4.45 + */
    4.46 +byte[] data;
    4.47 +
    4.48 +/**
    4.49 + * Actual number of bytes in this vector.
    4.50 + */
    4.51 +int length;
    4.52 +
    4.53 +/**
    4.54 + * Constructs a new {@link ByteVector ByteVector} with a default initial
    4.55 + * size.
    4.56 + */
    4.57 +public ByteVector(){
    4.58 +	data = new byte[64];
    4.59 +}
    4.60 +
    4.61 +/**
    4.62 + * Constructs a new {@link ByteVector ByteVector} with the given initial
    4.63 + * size.
    4.64 + *
    4.65 + * @param initialSize the initial size of the byte vector to be constructed.
    4.66 + */
    4.67 +public ByteVector(final int initialSize){
    4.68 +	data = new byte[initialSize];
    4.69 +}
    4.70 +
    4.71 +/**
    4.72 + * Puts a byte into this byte vector. The byte vector is automatically
    4.73 + * enlarged if necessary.
    4.74 + *
    4.75 + * @param b a byte.
    4.76 + * @return this byte vector.
    4.77 + */
    4.78 +public ByteVector putByte(final int b){
    4.79 +	int length = this.length;
    4.80 +	if(length + 1 > data.length)
    4.81 +		{
    4.82 +		enlarge(1);
    4.83 +		}
    4.84 +	data[length++] = (byte) b;
    4.85 +	this.length = length;
    4.86 +	return this;
    4.87 +}
    4.88 +
    4.89 +/**
    4.90 + * Puts two bytes into this byte vector. The byte vector is automatically
    4.91 + * enlarged if necessary.
    4.92 + *
    4.93 + * @param b1 a byte.
    4.94 + * @param b2 another byte.
    4.95 + * @return this byte vector.
    4.96 + */
    4.97 +ByteVector put11(final int b1, final int b2){
    4.98 +	int length = this.length;
    4.99 +	if(length + 2 > data.length)
   4.100 +		{
   4.101 +		enlarge(2);
   4.102 +		}
   4.103 +	byte[] data = this.data;
   4.104 +	data[length++] = (byte) b1;
   4.105 +	data[length++] = (byte) b2;
   4.106 +	this.length = length;
   4.107 +	return this;
   4.108 +}
   4.109 +
   4.110 +/**
   4.111 + * Puts a short into this byte vector. The byte vector is automatically
   4.112 + * enlarged if necessary.
   4.113 + *
   4.114 + * @param s a short.
   4.115 + * @return this byte vector.
   4.116 + */
   4.117 +public ByteVector putShort(final int s){
   4.118 +	int length = this.length;
   4.119 +	if(length + 2 > data.length)
   4.120 +		{
   4.121 +		enlarge(2);
   4.122 +		}
   4.123 +	byte[] data = this.data;
   4.124 +	data[length++] = (byte) (s >>> 8);
   4.125 +	data[length++] = (byte) s;
   4.126 +	this.length = length;
   4.127 +	return this;
   4.128 +}
   4.129 +
   4.130 +/**
   4.131 + * Puts a byte and a short into this byte vector. The byte vector is
   4.132 + * automatically enlarged if necessary.
   4.133 + *
   4.134 + * @param b a byte.
   4.135 + * @param s a short.
   4.136 + * @return this byte vector.
   4.137 + */
   4.138 +ByteVector put12(final int b, final int s){
   4.139 +	int length = this.length;
   4.140 +	if(length + 3 > data.length)
   4.141 +		{
   4.142 +		enlarge(3);
   4.143 +		}
   4.144 +	byte[] data = this.data;
   4.145 +	data[length++] = (byte) b;
   4.146 +	data[length++] = (byte) (s >>> 8);
   4.147 +	data[length++] = (byte) s;
   4.148 +	this.length = length;
   4.149 +	return this;
   4.150 +}
   4.151 +
   4.152 +/**
   4.153 + * Puts an int into this byte vector. The byte vector is automatically
   4.154 + * enlarged if necessary.
   4.155 + *
   4.156 + * @param i an int.
   4.157 + * @return this byte vector.
   4.158 + */
   4.159 +public ByteVector putInt(final int i){
   4.160 +	int length = this.length;
   4.161 +	if(length + 4 > data.length)
   4.162 +		{
   4.163 +		enlarge(4);
   4.164 +		}
   4.165 +	byte[] data = this.data;
   4.166 +	data[length++] = (byte) (i >>> 24);
   4.167 +	data[length++] = (byte) (i >>> 16);
   4.168 +	data[length++] = (byte) (i >>> 8);
   4.169 +	data[length++] = (byte) i;
   4.170 +	this.length = length;
   4.171 +	return this;
   4.172 +}
   4.173 +
   4.174 +/**
   4.175 + * Puts a long into this byte vector. The byte vector is automatically
   4.176 + * enlarged if necessary.
   4.177 + *
   4.178 + * @param l a long.
   4.179 + * @return this byte vector.
   4.180 + */
   4.181 +public ByteVector putLong(final long l){
   4.182 +	int length = this.length;
   4.183 +	if(length + 8 > data.length)
   4.184 +		{
   4.185 +		enlarge(8);
   4.186 +		}
   4.187 +	byte[] data = this.data;
   4.188 +	int i = (int) (l >>> 32);
   4.189 +	data[length++] = (byte) (i >>> 24);
   4.190 +	data[length++] = (byte) (i >>> 16);
   4.191 +	data[length++] = (byte) (i >>> 8);
   4.192 +	data[length++] = (byte) i;
   4.193 +	i = (int) l;
   4.194 +	data[length++] = (byte) (i >>> 24);
   4.195 +	data[length++] = (byte) (i >>> 16);
   4.196 +	data[length++] = (byte) (i >>> 8);
   4.197 +	data[length++] = (byte) i;
   4.198 +	this.length = length;
   4.199 +	return this;
   4.200 +}
   4.201 +
   4.202 +/**
   4.203 + * Puts an UTF8 string into this byte vector. The byte vector is
   4.204 + * automatically enlarged if necessary.
   4.205 + *
   4.206 + * @param s a String.
   4.207 + * @return this byte vector.
   4.208 + */
   4.209 +public ByteVector putUTF8(final String s){
   4.210 +	int charLength = s.length();
   4.211 +	if(length + 2 + charLength > data.length)
   4.212 +		{
   4.213 +		enlarge(2 + charLength);
   4.214 +		}
   4.215 +	int len = length;
   4.216 +	byte[] data = this.data;
   4.217 +	// optimistic algorithm: instead of computing the byte length and then
   4.218 +	// serializing the string (which requires two loops), we assume the byte
   4.219 +	// length is equal to char length (which is the most frequent case), and
   4.220 +	// we start serializing the string right away. During the serialization,
   4.221 +	// if we find that this assumption is wrong, we continue with the
   4.222 +	// general method.
   4.223 +	data[len++] = (byte) (charLength >>> 8);
   4.224 +	data[len++] = (byte) charLength;
   4.225 +	for(int i = 0; i < charLength; ++i)
   4.226 +		{
   4.227 +		char c = s.charAt(i);
   4.228 +		if(c >= '\001' && c <= '\177')
   4.229 +			{
   4.230 +			data[len++] = (byte) c;
   4.231 +			}
   4.232 +		else
   4.233 +			{
   4.234 +			int byteLength = i;
   4.235 +			for(int j = i; j < charLength; ++j)
   4.236 +				{
   4.237 +				c = s.charAt(j);
   4.238 +				if(c >= '\001' && c <= '\177')
   4.239 +					{
   4.240 +					byteLength++;
   4.241 +					}
   4.242 +				else if(c > '\u07FF')
   4.243 +					{
   4.244 +					byteLength += 3;
   4.245 +					}
   4.246 +				else
   4.247 +					{
   4.248 +					byteLength += 2;
   4.249 +					}
   4.250 +				}
   4.251 +			data[length] = (byte) (byteLength >>> 8);
   4.252 +			data[length + 1] = (byte) byteLength;
   4.253 +			if(length + 2 + byteLength > data.length)
   4.254 +				{
   4.255 +				length = len;
   4.256 +				enlarge(2 + byteLength);
   4.257 +				data = this.data;
   4.258 +				}
   4.259 +			for(int j = i; j < charLength; ++j)
   4.260 +				{
   4.261 +				c = s.charAt(j);
   4.262 +				if(c >= '\001' && c <= '\177')
   4.263 +					{
   4.264 +					data[len++] = (byte) c;
   4.265 +					}
   4.266 +				else if(c > '\u07FF')
   4.267 +					{
   4.268 +					data[len++] = (byte) (0xE0 | c >> 12 & 0xF);
   4.269 +					data[len++] = (byte) (0x80 | c >> 6 & 0x3F);
   4.270 +					data[len++] = (byte) (0x80 | c & 0x3F);
   4.271 +					}
   4.272 +				else
   4.273 +					{
   4.274 +					data[len++] = (byte) (0xC0 | c >> 6 & 0x1F);
   4.275 +					data[len++] = (byte) (0x80 | c & 0x3F);
   4.276 +					}
   4.277 +				}
   4.278 +			break;
   4.279 +			}
   4.280 +		}
   4.281 +	length = len;
   4.282 +	return this;
   4.283 +}
   4.284 +
   4.285 +/**
   4.286 + * Puts an array of bytes into this byte vector. The byte vector is
   4.287 + * automatically enlarged if necessary.
   4.288 + *
   4.289 + * @param b   an array of bytes. May be <tt>null</tt> to put <tt>len</tt>
   4.290 + *            null bytes into this byte vector.
   4.291 + * @param off index of the fist byte of b that must be copied.
   4.292 + * @param len number of bytes of b that must be copied.
   4.293 + * @return this byte vector.
   4.294 + */
   4.295 +public ByteVector putByteArray(final byte[] b, final int off, final int len){
   4.296 +	if(length + len > data.length)
   4.297 +		{
   4.298 +		enlarge(len);
   4.299 +		}
   4.300 +	if(b != null)
   4.301 +		{
   4.302 +		System.arraycopy(b, off, data, length, len);
   4.303 +		}
   4.304 +	length += len;
   4.305 +	return this;
   4.306 +}
   4.307 +
   4.308 +/**
   4.309 + * Enlarge this byte vector so that it can receive n more bytes.
   4.310 + *
   4.311 + * @param size number of additional bytes that this byte vector should be
   4.312 + *             able to receive.
   4.313 + */
   4.314 +private void enlarge(final int size){
   4.315 +	int length1 = 2 * data.length;
   4.316 +	int length2 = length + size;
   4.317 +	byte[] newData = new byte[length1 > length2 ? length1 : length2];
   4.318 +	System.arraycopy(data, 0, newData, 0, length);
   4.319 +	data = newData;
   4.320 +}
   4.321 +}

     5.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.2 +++ b/src/clojure/asm/ClassAdapter.java	Sat Aug 21 06:25:44 2010 -0400
     5.3 @@ -0,0 +1,115 @@
     5.4 +/***
     5.5 + * ASM: a very small and fast Java bytecode manipulation framework
     5.6 + * Copyright (c) 2000-2005 INRIA, France Telecom
     5.7 + * All rights reserved.
     5.8 + *
     5.9 + * Redistribution and use in source and binary forms, with or without
    5.10 + * modification, are permitted provided that the following conditions
    5.11 + * are met:
    5.12 + * 1. Redistributions of source code must retain the above copyright
    5.13 + *    notice, this list of conditions and the following disclaimer.
    5.14 + * 2. Redistributions in binary form must reproduce the above copyright
    5.15 + *    notice, this list of conditions and the following disclaimer in the
    5.16 + *    documentation and/or other materials provided with the distribution.
    5.17 + * 3. Neither the name of the copyright holders nor the names of its
    5.18 + *    contributors may be used to endorse or promote products derived from
    5.19 + *    this software without specific prior written permission.
    5.20 + *
    5.21 + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    5.22 + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    5.23 + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    5.24 + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
    5.25 + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    5.26 + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    5.27 + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    5.28 + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    5.29 + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    5.30 + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
    5.31 + * THE POSSIBILITY OF SUCH DAMAGE.
    5.32 + */
    5.33 +package clojure.asm;
    5.34 +
    5.35 +/**
    5.36 + * An empty {@link ClassVisitor} that delegates to another {@link ClassVisitor}.
    5.37 + * This class can be used as a super class to quickly implement usefull class
    5.38 + * adapter classes, just by overriding the necessary methods.
    5.39 + *
    5.40 + * @author Eric Bruneton
    5.41 + */
    5.42 +public class ClassAdapter implements ClassVisitor{
    5.43 +
    5.44 +/**
    5.45 + * The {@link ClassVisitor} to which this adapter delegates calls.
    5.46 + */
    5.47 +protected ClassVisitor cv;
    5.48 +
    5.49 +/**
    5.50 + * Constructs a new {@link ClassAdapter} object.
    5.51 + *
    5.52 + * @param cv the class visitor to which this adapter must delegate calls.
    5.53 + */
    5.54 +public ClassAdapter(final ClassVisitor cv){
    5.55 +	this.cv = cv;
    5.56 +}
    5.57 +
    5.58 +public void visit(
    5.59 +		final int version,
    5.60 +		final int access,
    5.61 +		final String name,
    5.62 +		final String signature,
    5.63 +		final String superName,
    5.64 +		final String[] interfaces){
    5.65 +	cv.visit(version, access, name, signature, superName, interfaces);
    5.66 +}
    5.67 +
    5.68 +public void visitSource(final String source, final String debug){
    5.69 +	cv.visitSource(source, debug);
    5.70 +}
    5.71 +
    5.72 +public void visitOuterClass(
    5.73 +		final String owner,
    5.74 +		final String name,
    5.75 +		final String desc){
    5.76 +	cv.visitOuterClass(owner, name, desc);
    5.77 +}
    5.78 +
    5.79 +public AnnotationVisitor visitAnnotation(
    5.80 +		final String desc,
    5.81 +		final boolean visible){
    5.82 +	return cv.visitAnnotation(desc, visible);
    5.83 +}
    5.84 +
    5.85 +public void visitAttribute(final Attribute attr){
    5.86 +	cv.visitAttribute(attr);
    5.87 +}
    5.88 +
    5.89 +public void visitInnerClass(
    5.90 +		final String name,
    5.91 +		final String outerName,
    5.92 +		final String innerName,
    5.93 +		final int access){
    5.94 +	cv.visitInnerClass(name, outerName, innerName, access);
    5.95 +}
    5.96 +
    5.97 +public FieldVisitor visitField(
    5.98 +		final int access,
    5.99 +		final String name,
   5.100 +		final String desc,
   5.101 +		final String signature,
   5.102 +		final Object value){
   5.103 +	return cv.visitField(access, name, desc, signature, value);
   5.104 +}
   5.105 +
   5.106 +public MethodVisitor visitMethod(
   5.107 +		final int access,
   5.108 +		final String name,
   5.109 +		final String desc,
   5.110 +		final String signature,
   5.111 +		final String[] exceptions){
   5.112 +	return cv.visitMethod(access, name, desc, signature, exceptions);
   5.113 +}
   5.114 +
   5.115 +public void visitEnd(){
   5.116 +	cv.visitEnd();
   5.117 +}
   5.118 +}

     6.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.2 +++ b/src/clojure/asm/ClassReader.java	Sat Aug 21 06:25:44 2010 -0400
     6.3 @@ -0,0 +1,2224 @@
     6.4 +/***
     6.5 + * ASM: a very small and fast Java bytecode manipulation framework
     6.6 + * Copyright (c) 2000-2005 INRIA, France Telecom
     6.7 + * All rights reserved.
     6.8 + *
     6.9 + * Redistribution and use in source and binary forms, with or without
    6.10 + * modification, are permitted provided that the following conditions
    6.11 + * are met:
    6.12 + * 1. Redistributions of source code must retain the above copyright
    6.13 + *    notice, this list of conditions and the following disclaimer.
    6.14 + * 2. Redistributions in binary form must reproduce the above copyright
    6.15 + *    notice, this list of conditions and the following disclaimer in the
    6.16 + *    documentation and/or other materials provided with the distribution.
    6.17 + * 3. Neither the name of the copyright holders nor the names of its
    6.18 + *    contributors may be used to endorse or promote products derived from
    6.19 + *    this software without specific prior written permission.
    6.20 + *
    6.21 + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    6.22 + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    6.23 + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    6.24 + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
    6.25 + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    6.26 + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    6.27 + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    6.28 + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    6.29 + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    6.30 + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
    6.31 + * THE POSSIBILITY OF SUCH DAMAGE.
    6.32 + */
    6.33 +package clojure.asm;
    6.34 +
    6.35 +import java.io.InputStream;
    6.36 +import java.io.IOException;
    6.37 +
    6.38 +/**
    6.39 + * A Java class parser to make a {@link ClassVisitor} visit an existing class.
    6.40 + * This class parses a byte array conforming to the Java class file format and
    6.41 + * calls the appropriate visit methods of a given class visitor for each field,
    6.42 + * method and bytecode instruction encountered.
    6.43 + *
    6.44 + * @author Eric Bruneton
    6.45 + * @author Eugene Kuleshov
    6.46 + */
    6.47 +public class ClassReader{
    6.48 +
    6.49 +/**
    6.50 + * Flag to skip method code. If this class is set <code>CODE</code>
    6.51 + * attribute won't be visited. This can be used, for example, to retrieve
    6.52 + * annotations for methods and method parameters.
    6.53 + */
    6.54 +public final static int SKIP_CODE = 1;
    6.55 +
    6.56 +/**
    6.57 + * Flag to skip the debug information in the class. If this flag is set the
    6.58 + * debug information of the class is not visited, i.e. the
    6.59 + * {@link MethodVisitor#visitLocalVariable visitLocalVariable} and
    6.60 + * {@link MethodVisitor#visitLineNumber visitLineNumber} methods will not be
    6.61 + * called.
    6.62 + */
    6.63 +public final static int SKIP_DEBUG = 2;
    6.64 +
    6.65 +/**
    6.66 + * Flag to skip the stack map frames in the class. If this flag is set the
    6.67 + * stack map frames of the class is not visited, i.e. the
    6.68 + * {@link MethodVisitor#visitFrame visitFrame} method will not be called.
    6.69 + * This flag is useful when the {@link ClassWriter#COMPUTE_FRAMES} option is
    6.70 + * used: it avoids visiting frames that will be ignored and recomputed from
    6.71 + * scratch in the class writer.
    6.72 + */
    6.73 +public final static int SKIP_FRAMES = 4;
    6.74 +
    6.75 +/**
    6.76 + * Flag to expand the stack map frames. By default stack map frames are
    6.77 + * visited in their original format (i.e. "expanded" for classes whose
    6.78 + * version is less than V1_6, and "compressed" for the other classes). If
    6.79 + * this flag is set, stack map frames are always visited in expanded format
    6.80 + * (this option adds a decompression/recompression step in ClassReader and
    6.81 + * ClassWriter which degrades performances quite a lot).
    6.82 + */
    6.83 +public final static int EXPAND_FRAMES = 8;
    6.84 +
    6.85 +/**
    6.86 + * The class to be parsed. <i>The content of this array must not be
    6.87 + * modified. This field is intended for {@link Attribute} sub classes, and
    6.88 + * is normally not needed by class generators or adapters.</i>
    6.89 + */
    6.90 +public final byte[] b;
    6.91 +
    6.92 +/**
    6.93 + * The start index of each constant pool item in {@link #b b}, plus one.
    6.94 + * The one byte offset skips the constant pool item tag that indicates its
    6.95 + * type.
    6.96 + */
    6.97 +private final int[] items;
    6.98 +
    6.99 +/**
   6.100 + * The String objects corresponding to the CONSTANT_Utf8 items. This cache
   6.101 + * avoids multiple parsing of a given CONSTANT_Utf8 constant pool item,
   6.102 + * which GREATLY improves performances (by a factor 2 to 3). This caching
   6.103 + * strategy could be extended to all constant pool items, but its benefit
   6.104 + * would not be so great for these items (because they are much less
   6.105 + * expensive to parse than CONSTANT_Utf8 items).
   6.106 + */
   6.107 +private final String[] strings;
   6.108 +
   6.109 +/**
   6.110 + * Maximum length of the strings contained in the constant pool of the
   6.111 + * class.
   6.112 + */
   6.113 +private final int maxStringLength;
   6.114 +
   6.115 +/**
   6.116 + * Start index of the class header information (access, name...) in
   6.117 + * {@link #b b}.
   6.118 + */
   6.119 +public final int header;
   6.120 +
   6.121 +// ------------------------------------------------------------------------
   6.122 +// Constructors
   6.123 +// ------------------------------------------------------------------------
   6.124 +
   6.125 +/**
   6.126 + * Constructs a new {@link ClassReader} object.
   6.127 + *
   6.128 + * @param b the bytecode of the class to be read.
   6.129 + */
   6.130 +public ClassReader(final byte[] b){
   6.131 +	this(b, 0, b.length);
   6.132 +}
   6.133 +
   6.134 +/**
   6.135 + * Constructs a new {@link ClassReader} object.
   6.136 + *
   6.137 + * @param b   the bytecode of the class to be read.
   6.138 + * @param off the start offset of the class data.
   6.139 + * @param len the length of the class data.
   6.140 + */
   6.141 +public ClassReader(final byte[] b, final int off, final int len){
   6.142 +	this.b = b;
   6.143 +	// parses the constant pool
   6.144 +	items = new int[readUnsignedShort(off + 8)];
   6.145 +	int n = items.length;
   6.146 +	strings = new String[n];
   6.147 +	int max = 0;
   6.148 +	int index = off + 10;
   6.149 +	for(int i = 1; i < n; ++i)
   6.150 +		{
   6.151 +		items[i] = index + 1;
   6.152 +		int size;
   6.153 +		switch(b[index])
   6.154 +			{
   6.155 +			case ClassWriter.FIELD:
   6.156 +			case ClassWriter.METH:
   6.157 +			case ClassWriter.IMETH:
   6.158 +			case ClassWriter.INT:
   6.159 +			case ClassWriter.FLOAT:
   6.160 +			case ClassWriter.NAME_TYPE:
   6.161 +				size = 5;
   6.162 +				break;
   6.163 +			case ClassWriter.LONG:
   6.164 +			case ClassWriter.DOUBLE:
   6.165 +				size = 9;
   6.166 +				++i;
   6.167 +				break;
   6.168 +			case ClassWriter.UTF8:
   6.169 +				size = 3 + readUnsignedShort(index + 1);
   6.170 +				if(size > max)
   6.171 +					{
   6.172 +					max = size;
   6.173 +					}
   6.174 +				break;
   6.175 +				// case ClassWriter.CLASS:
   6.176 +				// case ClassWriter.STR:
   6.177 +			default:
   6.178 +				size = 3;
   6.179 +				break;
   6.180 +			}
   6.181 +		index += size;
   6.182 +		}
   6.183 +	maxStringLength = max;
   6.184 +	// the class header information starts just after the constant pool
   6.185 +	header = index;
   6.186 +}
   6.187 +
   6.188 +/**
   6.189 + * Returns the class's access flags (see {@link Opcodes}). This value may
   6.190 + * not reflect Deprecated and Synthetic flags when bytecode is before 1.5
   6.191 + * and those flags are represented by attributes.
   6.192 + *
   6.193 + * @return the class access flags
   6.194 + * @see ClassVisitor#visit(int,int,String,String,String,String[])
   6.195 + */
   6.196 +public int getAccess(){
   6.197 +	return readUnsignedShort(header);
   6.198 +}
   6.199 +
   6.200 +/**
   6.201 + * Returns the internal name of the class (see
   6.202 + * {@link Type#getInternalName() getInternalName}).
   6.203 + *
   6.204 + * @return the internal class name
   6.205 + * @see ClassVisitor#visit(int,int,String,String,String,String[])
   6.206 + */
   6.207 +public String getClassName(){
   6.208 +	return readClass(header + 2, new char[maxStringLength]);
   6.209 +}
   6.210 +
   6.211 +/**
   6.212 + * Returns the internal of name of the super class (see
   6.213 + * {@link Type#getInternalName() getInternalName}). For interfaces, the
   6.214 + * super class is {@link Object}.
   6.215 + *
   6.216 + * @return the internal name of super class, or <tt>null</tt> for
   6.217 + *         {@link Object} class.
   6.218 + * @see ClassVisitor#visit(int,int,String,String,String,String[])
   6.219 + */
   6.220 +public String getSuperName(){
   6.221 +	int n = items[readUnsignedShort(header + 4)];
   6.222 +	return n == 0 ? null : readUTF8(n, new char[maxStringLength]);
   6.223 +}
   6.224 +
   6.225 +/**
   6.226 + * Returns the internal names of the class's interfaces (see
   6.227 + * {@link Type#getInternalName() getInternalName}).
   6.228 + *
   6.229 + * @return the array of internal names for all implemented interfaces or
   6.230 + *         <tt>null</tt>.
   6.231 + * @see ClassVisitor#visit(int,int,String,String,String,String[])
   6.232 + */
   6.233 +public String[] getInterfaces(){
   6.234 +	int index = header + 6;
   6.235 +	int n = readUnsignedShort(index);
   6.236 +	String[] interfaces = new String[n];
   6.237 +	if(n > 0)
   6.238 +		{
   6.239 +		char[] buf = new char[maxStringLength];
   6.240 +		for(int i = 0; i < n; ++i)
   6.241 +			{
   6.242 +			index += 2;
   6.243 +			interfaces[i] = readClass(index, buf);
   6.244 +			}
   6.245 +		}
   6.246 +	return interfaces;
   6.247 +}
   6.248 +
   6.249 +/**
   6.250 + * Copies the constant pool data into the given {@link ClassWriter}. Should
   6.251 + * be called before the {@link #accept(ClassVisitor,int)} method.
   6.252 + *
   6.253 + * @param classWriter the {@link ClassWriter} to copy constant pool into.
   6.254 + */
   6.255 +void copyPool(final ClassWriter classWriter){
   6.256 +	char[] buf = new char[maxStringLength];
   6.257 +	int ll = items.length;
   6.258 +	Item[] items2 = new Item[ll];
   6.259 +	for(int i = 1; i < ll; i++)
   6.260 +		{
   6.261 +		int index = items[i];
   6.262 +		int tag = b[index - 1];
   6.263 +		Item item = new Item(i);
   6.264 +		int nameType;
   6.265 +		switch(tag)
   6.266 +			{
   6.267 +			case ClassWriter.FIELD:
   6.268 +			case ClassWriter.METH:
   6.269 +			case ClassWriter.IMETH:
   6.270 +				nameType = items[readUnsignedShort(index + 2)];
   6.271 +				item.set(tag,
   6.272 +				         readClass(index, buf),
   6.273 +				         readUTF8(nameType, buf),
   6.274 +				         readUTF8(nameType + 2, buf));
   6.275 +				break;
   6.276 +
   6.277 +			case ClassWriter.INT:
   6.278 +				item.set(readInt(index));
   6.279 +				break;
   6.280 +
   6.281 +			case ClassWriter.FLOAT:
   6.282 +				item.set(Float.intBitsToFloat(readInt(index)));
   6.283 +				break;
   6.284 +
   6.285 +			case ClassWriter.NAME_TYPE:
   6.286 +				item.set(tag,
   6.287 +				         readUTF8(index, buf),
   6.288 +				         readUTF8(index + 2, buf),
   6.289 +				         null);
   6.290 +				break;
   6.291 +
   6.292 +			case ClassWriter.LONG:
   6.293 +				item.set(readLong(index));
   6.294 +				++i;
   6.295 +				break;
   6.296 +
   6.297 +			case ClassWriter.DOUBLE:
   6.298 +				item.set(Double.longBitsToDouble(readLong(index)));
   6.299 +				++i;
   6.300 +				break;
   6.301 +
   6.302 +			case ClassWriter.UTF8:
   6.303 +			{
   6.304 +			String s = strings[i];
   6.305 +			if(s == null)
   6.306 +				{
   6.307 +				index = items[i];
   6.308 +				s = strings[i] = readUTF(index + 2,
   6.309 +				                         readUnsignedShort(index),
   6.310 +				                         buf);
   6.311 +				}
   6.312 +			item.set(tag, s, null, null);
   6.313 +			}
   6.314 +			break;
   6.315 +
   6.316 +			// case ClassWriter.STR:
   6.317 +			// case ClassWriter.CLASS:
   6.318 +			default:
   6.319 +				item.set(tag, readUTF8(index, buf), null, null);
   6.320 +				break;
   6.321 +			}
   6.322 +
   6.323 +		int index2 = item.hashCode % items2.length;
   6.324 +		item.next = items2[index2];
   6.325 +		items2[index2] = item;
   6.326 +		}
   6.327 +
   6.328 +	int off = items[1] - 1;
   6.329 +	classWriter.pool.putByteArray(b, off, header - off);
   6.330 +	classWriter.items = items2;
   6.331 +	classWriter.threshold = (int) (0.75d * ll);
   6.332 +	classWriter.index = ll;
   6.333 +}
   6.334 +
   6.335 +/**
   6.336 + * Constructs a new {@link ClassReader} object.
   6.337 + *
   6.338 + * @param is an input stream from which to read the class.
   6.339 + * @throws IOException if a problem occurs during reading.
   6.340 + */
   6.341 +public ClassReader(final InputStream is) throws IOException{
   6.342 +	this(readClass(is));
   6.343 +}
   6.344 +
   6.345 +/**
   6.346 + * Constructs a new {@link ClassReader} object.
   6.347 + *
   6.348 + * @param name the fully qualified name of the class to be read.
   6.349 + * @throws IOException if an exception occurs during reading.
   6.350 + */
   6.351 +public ClassReader(final String name) throws IOException{
   6.352 +	this(ClassLoader.getSystemResourceAsStream(name.replace('.', '/')
   6.353 +	                                           + ".class"));
   6.354 +}
   6.355 +
   6.356 +/**
   6.357 + * Reads the bytecode of a class.
   6.358 + *
   6.359 + * @param is an input stream from which to read the class.
   6.360 + * @return the bytecode read from the given input stream.
   6.361 + * @throws IOException if a problem occurs during reading.
   6.362 + */
   6.363 +private static byte[] readClass(final InputStream is) throws IOException{
   6.364 +	if(is == null)
   6.365 +		{
   6.366 +		throw new IOException("Class not found");
   6.367 +		}
   6.368 +	byte[] b = new byte[is.available()];
   6.369 +	int len = 0;
   6.370 +	while(true)
   6.371 +		{
   6.372 +		int n = is.read(b, len, b.length - len);
   6.373 +		if(n == -1)
   6.374 +			{
   6.375 +			if(len < b.length)
   6.376 +				{
   6.377 +				byte[] c = new byte[len];
   6.378 +				System.arraycopy(b, 0, c, 0, len);
   6.379 +				b = c;
   6.380 +				}
   6.381 +			return b;
   6.382 +			}
   6.383 +		len += n;
   6.384 +		if(len == b.length)
   6.385 +			{
   6.386 +			byte[] c = new byte[b.length + 1000];
   6.387 +			System.arraycopy(b, 0, c, 0, len);
   6.388 +			b = c;
   6.389 +			}
   6.390 +		}
   6.391 +}
   6.392 +
   6.393 +// ------------------------------------------------------------------------
   6.394 +// Public methods
   6.395 +// ------------------------------------------------------------------------
   6.396 +
   6.397 +/**
   6.398 + * Makes the given visitor visit the Java class of this {@link ClassReader}.
   6.399 + * This class is the one specified in the constructor (see
   6.400 + * {@link #ClassReader(byte[]) ClassReader}).
   6.401 + *
   6.402 + * @param classVisitor the visitor that must visit this class.
   6.403 + * @param flags        option flags that can be used to modify the default behavior
   6.404 + *                     of this class. See {@link #SKIP_DEBUG}, {@link #EXPAND_FRAMES}.
   6.405 + */
   6.406 +public void accept(final ClassVisitor classVisitor, final int flags){
   6.407 +	accept(classVisitor, new Attribute[0], flags);
   6.408 +}
   6.409 +
   6.410 +/**
   6.411 + * Makes the given visitor visit the Java class of this {@link ClassReader}.
   6.412 + * This class is the one specified in the constructor (see
   6.413 + * {@link #ClassReader(byte[]) ClassReader}).
   6.414 + *
   6.415 + * @param classVisitor the visitor that must visit this class.
   6.416 + * @param attrs        prototypes of the attributes that must be parsed during the
   6.417 + *                     visit of the class. Any attribute whose type is not equal to the
   6.418 + *                     type of one the prototypes will not be parsed: its byte array
   6.419 + *                     value will be passed unchanged to the ClassWriter. <i>This may
   6.420 + *                     corrupt it if this value contains references to the constant pool,
   6.421 + *                     or has syntactic or semantic links with a class element that has
   6.422 + *                     been transformed by a class adapter between the reader and the
   6.423 + *                     writer</i>.
   6.424 + * @param flags        option flags that can be used to modify the default behavior
   6.425 + *                     of this class. See {@link #SKIP_DEBUG}, {@link #EXPAND_FRAMES}.
   6.426 + */
   6.427 +public void accept(
   6.428 +		final ClassVisitor classVisitor,
   6.429 +		final Attribute[] attrs,
   6.430 +		final int flags){
   6.431 +	byte[] b = this.b; // the bytecode array
   6.432 +	char[] c = new char[maxStringLength]; // buffer used to read strings
   6.433 +	int i, j, k; // loop variables
   6.434 +	int u, v, w; // indexes in b
   6.435 +	Attribute attr;
   6.436 +
   6.437 +	int access;
   6.438 +	String name;
   6.439 +	String desc;
   6.440 +	String attrName;
   6.441 +	String signature;
   6.442 +	int anns = 0;
   6.443 +	int ianns = 0;
   6.444 +	Attribute cattrs = null;
   6.445 +
   6.446 +	// visits the header
   6.447 +	u = header;
   6.448 +	access = readUnsignedShort(u);
   6.449 +	name = readClass(u + 2, c);
   6.450 +	v = items[readUnsignedShort(u + 4)];
   6.451 +	String superClassName = v == 0 ? null : readUTF8(v, c);
   6.452 +	String[] implementedItfs = new String[readUnsignedShort(u + 6)];
   6.453 +	w = 0;
   6.454 +	u += 8;
   6.455 +	for(i = 0; i < implementedItfs.length; ++i)
   6.456 +		{
   6.457 +		implementedItfs[i] = readClass(u, c);
   6.458 +		u += 2;
   6.459 +		}
   6.460 +
   6.461 +	boolean skipCode = (flags & SKIP_CODE) != 0;
   6.462 +	boolean skipDebug = (flags & SKIP_DEBUG) != 0;
   6.463 +	boolean unzip = (flags & EXPAND_FRAMES) != 0;
   6.464 +
   6.465 +	// skips fields and methods
   6.466 +	v = u;
   6.467 +	i = readUnsignedShort(v);
   6.468 +	v += 2;
   6.469 +	for(; i > 0; --i)
   6.470 +		{
   6.471 +		j = readUnsignedShort(v + 6);
   6.472 +		v += 8;
   6.473 +		for(; j > 0; --j)
   6.474 +			{
   6.475 +			v += 6 + readInt(v + 2);
   6.476 +			}
   6.477 +		}
   6.478 +	i = readUnsignedShort(v);
   6.479 +	v += 2;
   6.480 +	for(; i > 0; --i)
   6.481 +		{
   6.482 +		j = readUnsignedShort(v + 6);
   6.483 +		v += 8;
   6.484 +		for(; j > 0; --j)
   6.485 +			{
   6.486 +			v += 6 + readInt(v + 2);
   6.487 +			}
   6.488 +		}
   6.489 +	// reads the class's attributes
   6.490 +	signature = null;
   6.491 +	String sourceFile = null;
   6.492 +	String sourceDebug = null;
   6.493 +	String enclosingOwner = null;
   6.494 +	String enclosingName = null;
   6.495 +	String enclosingDesc = null;
   6.496 +
   6.497 +	i = readUnsignedShort(v);
   6.498 +	v += 2;
   6.499 +	for(; i > 0; --i)
   6.500 +		{
   6.501 +		attrName = readUTF8(v, c);
   6.502 +		// tests are sorted in decreasing frequency order
   6.503 +		// (based on frequencies observed on typical classes)
   6.504 +		if(attrName.equals("SourceFile"))
   6.505 +			{
   6.506 +			sourceFile = readUTF8(v + 6, c);
   6.507 +			}
   6.508 +		else if(attrName.equals("InnerClasses"))
   6.509 +			{
   6.510 +			w = v + 6;
   6.511 +			}
   6.512 +		else if(attrName.equals("EnclosingMethod"))
   6.513 +			{
   6.514 +			enclosingOwner = readClass(v + 6, c);
   6.515 +			int item = readUnsignedShort(v + 8);
   6.516 +			if(item != 0)
   6.517 +				{
   6.518 +				enclosingName = readUTF8(items[item], c);
   6.519 +				enclosingDesc = readUTF8(items[item] + 2, c);
   6.520 +				}
   6.521 +			}
   6.522 +		else if(attrName.equals("Signature"))
   6.523 +			{
   6.524 +			signature = readUTF8(v + 6, c);
   6.525 +			}
   6.526 +		else if(attrName.equals("RuntimeVisibleAnnotations"))
   6.527 +			{
   6.528 +			anns = v + 6;
   6.529 +			}
   6.530 +		else if(attrName.equals("Deprecated"))
   6.531 +			{
   6.532 +			access |= Opcodes.ACC_DEPRECATED;
   6.533 +			}
   6.534 +		else if(attrName.equals("Synthetic"))
   6.535 +			{
   6.536 +			access |= Opcodes.ACC_SYNTHETIC;
   6.537 +			}
   6.538 +		else if(attrName.equals("SourceDebugExtension"))
   6.539 +			{
   6.540 +			int len = readInt(v + 2);
   6.541 +			sourceDebug = readUTF(v + 6, len, new char[len]);
   6.542 +			}
   6.543 +		else if(attrName.equals("RuntimeInvisibleAnnotations"))
   6.544 +			{
   6.545 +			ianns = v + 6;
   6.546 +			}
   6.547 +		else
   6.548 +			{
   6.549 +			attr = readAttribute(attrs,
   6.550 +			                     attrName,
   6.551 +			                     v + 6,
   6.552 +			                     readInt(v + 2),
   6.553 +			                     c,
   6.554 +			                     -1,
   6.555 +			                     null);
   6.556 +			if(attr != null)
   6.557 +				{
   6.558 +				attr.next = cattrs;
   6.559 +				cattrs = attr;
   6.560 +				}
   6.561 +			}
   6.562 +		v += 6 + readInt(v + 2);
   6.563 +		}
   6.564 +	// calls the visit method
   6.565 +	classVisitor.visit(readInt(4),
   6.566 +	                   access,
   6.567 +	                   name,
   6.568 +	                   signature,
   6.569 +	                   superClassName,
   6.570 +	                   implementedItfs);
   6.571 +
   6.572 +	// calls the visitSource method
   6.573 +	if(!skipDebug && (sourceFile != null || sourceDebug != null))
   6.574 +		{
   6.575 +		classVisitor.visitSource(sourceFile, sourceDebug);
   6.576 +		}
   6.577 +
   6.578 +	// calls the visitOuterClass method
   6.579 +	if(enclosingOwner != null)
   6.580 +		{
   6.581 +		classVisitor.visitOuterClass(enclosingOwner,
   6.582 +		                             enclosingName,
   6.583 +		                             enclosingDesc);
   6.584 +		}
   6.585 +
   6.586 +	// visits the class annotations
   6.587 +	for(i = 1; i >= 0; --i)
   6.588 +		{
   6.589 +		v = i == 0 ? ianns : anns;
   6.590 +		if(v != 0)
   6.591 +			{
   6.592 +			j = readUnsignedShort(v);
   6.593 +			v += 2;
   6.594 +			for(; j > 0; --j)
   6.595 +				{
   6.596 +				v = readAnnotationValues(v + 2,
   6.597 +				                         c,
   6.598 +				                         true,
   6.599 +				                         classVisitor.visitAnnotation(readUTF8(v, c), i != 0));
   6.600 +				}
   6.601 +			}
   6.602 +		}
   6.603 +
   6.604 +	// visits the class attributes
   6.605 +	while(cattrs != null)
   6.606 +		{
   6.607 +		attr = cattrs.next;
   6.608 +		cattrs.next = null;
   6.609 +		classVisitor.visitAttribute(cattrs);
   6.610 +		cattrs = attr;
   6.611 +		}
   6.612 +
   6.613 +	// calls the visitInnerClass method
   6.614 +	if(w != 0)
   6.615 +		{
   6.616 +		i = readUnsignedShort(w);
   6.617 +		w += 2;
   6.618 +		for(; i > 0; --i)
   6.619 +			{
   6.620 +			classVisitor.visitInnerClass(readUnsignedShort(w) == 0
   6.621 +			                             ? null
   6.622 +			                             : readClass(w, c), readUnsignedShort(w + 2) == 0
   6.623 +			                                                ? null
   6.624 +			                                                : readClass(w + 2, c), readUnsignedShort(w + 4) == 0
   6.625 +			                                                                       ? null
   6.626 +			                                                                       : readUTF8(w + 4, c),
   6.627 +			                                                                       readUnsignedShort(w + 6));
   6.628 +			w += 8;
   6.629 +			}
   6.630 +		}
   6.631 +
   6.632 +	// visits the fields
   6.633 +	i = readUnsignedShort(u);
   6.634 +	u += 2;
   6.635 +	for(; i > 0; --i)
   6.636 +		{
   6.637 +		access = readUnsignedShort(u);
   6.638 +		name = readUTF8(u + 2, c);
   6.639 +		desc = readUTF8(u + 4, c);
   6.640 +		// visits the field's attributes and looks for a ConstantValue
   6.641 +		// attribute
   6.642 +		int fieldValueItem = 0;
   6.643 +		signature = null;
   6.644 +		anns = 0;
   6.645 +		ianns = 0;
   6.646 +		cattrs = null;
   6.647 +
   6.648 +		j = readUnsignedShort(u + 6);
   6.649 +		u += 8;
   6.650 +		for(; j > 0; --j)
   6.651 +			{
   6.652 +			attrName = readUTF8(u, c);
   6.653 +			// tests are sorted in decreasing frequency order
   6.654 +			// (based on frequencies observed on typical classes)
   6.655 +			if(attrName.equals("ConstantValue"))
   6.656 +				{
   6.657 +				fieldValueItem = readUnsignedShort(u + 6);
   6.658 +				}
   6.659 +			else if(attrName.equals("Signature"))
   6.660 +				{
   6.661 +				signature = readUTF8(u + 6, c);
   6.662 +				}
   6.663 +			else if(attrName.equals("Deprecated"))
   6.664 +				{
   6.665 +				access |= Opcodes.ACC_DEPRECATED;
   6.666 +				}
   6.667 +			else if(attrName.equals("Synthetic"))
   6.668 +				{
   6.669 +				access |= Opcodes.ACC_SYNTHETIC;
   6.670 +				}
   6.671 +			else if(attrName.equals("RuntimeVisibleAnnotations"))
   6.672 +				{
   6.673 +				anns = u + 6;
   6.674 +				}
   6.675 +			else if(attrName.equals("RuntimeInvisibleAnnotations"))
   6.676 +				{
   6.677 +				ianns = u + 6;
   6.678 +				}
   6.679 +			else
   6.680 +				{
   6.681 +				attr = readAttribute(attrs,
   6.682 +				                     attrName,
   6.683 +				                     u + 6,
   6.684 +				                     readInt(u + 2),
   6.685 +				                     c,
   6.686 +				                     -1,
   6.687 +				                     null);
   6.688 +				if(attr != null)
   6.689 +					{
   6.690 +					attr.next = cattrs;
   6.691 +					cattrs = attr;
   6.692 +					}
   6.693 +				}
   6.694 +			u += 6 + readInt(u + 2);
   6.695 +			}
   6.696 +		// visits the field
   6.697 +		FieldVisitor fv = classVisitor.visitField(access,
   6.698 +		                                          name,
   6.699 +		                                          desc,
   6.700 +		                                          signature,
   6.701 +		                                          fieldValueItem == 0 ? null : readConst(fieldValueItem, c));
   6.702 +		// visits the field annotations and attributes
   6.703 +		if(fv != null)
   6.704 +			{
   6.705 +			for(j = 1; j >= 0; --j)
   6.706 +				{
   6.707 +				v = j == 0 ? ianns : anns;
   6.708 +				if(v != 0)
   6.709 +					{
   6.710 +					k = readUnsignedShort(v);
   6.711 +					v += 2;
   6.712 +					for(; k > 0; --k)
   6.713 +						{
   6.714 +						v = readAnnotationValues(v + 2,
   6.715 +						                         c,
   6.716 +						                         true,
   6.717 +						                         fv.visitAnnotation(readUTF8(v, c), j != 0));
   6.718 +						}
   6.719 +					}
   6.720 +				}
   6.721 +			while(cattrs != null)
   6.722 +				{
   6.723 +				attr = cattrs.next;
   6.724 +				cattrs.next = null;
   6.725 +				fv.visitAttribute(cattrs);
   6.726 +				cattrs = attr;
   6.727 +				}
   6.728 +			fv.visitEnd();
   6.729 +			}
   6.730 +		}
   6.731 +
   6.732 +	// visits the methods
   6.733 +	i = readUnsignedShort(u);
   6.734 +	u += 2;
   6.735 +	for(; i > 0; --i)
   6.736 +		{
   6.737 +		int u0 = u + 6;
   6.738 +		access = readUnsignedShort(u);
   6.739 +		name = readUTF8(u + 2, c);
   6.740 +		desc = readUTF8(u + 4, c);
   6.741 +		signature = null;
   6.742 +		anns = 0;
   6.743 +		ianns = 0;
   6.744 +		int dann = 0;
   6.745 +		int mpanns = 0;
   6.746 +		int impanns = 0;
   6.747 +		cattrs = null;
   6.748 +		v = 0;
   6.749 +		w = 0;
   6.750 +
   6.751 +		// looks for Code and Exceptions attributes
   6.752 +		j = readUnsignedShort(u + 6);
   6.753 +		u += 8;
   6.754 +		for(; j > 0; --j)
   6.755 +			{
   6.756 +			attrName = readUTF8(u, c);
   6.757 +			int attrSize = readInt(u + 2);
   6.758 +			u += 6;
   6.759 +			// tests are sorted in decreasing frequency order
   6.760 +			// (based on frequencies observed on typical classes)
   6.761 +			if(attrName.equals("Code"))
   6.762 +				{
   6.763 +				if(!skipCode)
   6.764 +					{
   6.765 +					v = u;
   6.766 +					}
   6.767 +				}
   6.768 +			else if(attrName.equals("Exceptions"))
   6.769 +				{
   6.770 +				w = u;
   6.771 +				}
   6.772 +			else if(attrName.equals("Signature"))
   6.773 +				{
   6.774 +				signature = readUTF8(u, c);
   6.775 +				}
   6.776 +			else if(attrName.equals("Deprecated"))
   6.777 +				{
   6.778 +				access |= Opcodes.ACC_DEPRECATED;
   6.779 +				}
   6.780 +			else if(attrName.equals("RuntimeVisibleAnnotations"))
   6.781 +				{
   6.782 +				anns = u;
   6.783 +				}
   6.784 +			else if(attrName.equals("AnnotationDefault"))
   6.785 +				{
   6.786 +				dann = u;
   6.787 +				}
   6.788 +			else if(attrName.equals("Synthetic"))
   6.789 +				{
   6.790 +				access |= Opcodes.ACC_SYNTHETIC;
   6.791 +				}
   6.792 +			else if(attrName.equals("RuntimeInvisibleAnnotations"))
   6.793 +				{
   6.794 +				ianns = u;
   6.795 +				}
   6.796 +			else if(attrName.equals("RuntimeVisibleParameterAnnotations"))
   6.797 +				{
   6.798 +				mpanns = u;
   6.799 +				}
   6.800 +			else if(attrName.equals("RuntimeInvisibleParameterAnnotations"))
   6.801 +				{
   6.802 +				impanns = u;
   6.803 +				}
   6.804 +			else
   6.805 +				{
   6.806 +				attr = readAttribute(attrs,
   6.807 +				                     attrName,
   6.808 +				                     u,
   6.809 +				                     attrSize,
   6.810 +				                     c,
   6.811 +				                     -1,
   6.812 +				                     null);
   6.813 +				if(attr != null)
   6.814 +					{
   6.815 +					attr.next = cattrs;
   6.816 +					cattrs = attr;
   6.817 +					}
   6.818 +				}
   6.819 +			u += attrSize;
   6.820 +			}
   6.821 +		// reads declared exceptions
   6.822 +		String[] exceptions;
   6.823 +		if(w == 0)
   6.824 +			{
   6.825 +			exceptions = null;
   6.826 +			}
   6.827 +		else
   6.828 +			{
   6.829 +			exceptions = new String[readUnsignedShort(w)];
   6.830 +			w += 2;
   6.831 +			for(j = 0; j < exceptions.length; ++j)
   6.832 +				{
   6.833 +				exceptions[j] = readClass(w, c);
   6.834 +				w += 2;
   6.835 +				}
   6.836 +			}
   6.837 +
   6.838 +		// visits the method's code, if any
   6.839 +		MethodVisitor mv = classVisitor.visitMethod(access,
   6.840 +		                                            name,
   6.841 +		                                            desc,
   6.842 +		                                            signature,
   6.843 +		                                            exceptions);
   6.844 +
   6.845 +		if(mv != null)
   6.846 +			{
   6.847 +			/*
   6.848 +							 * if the returned MethodVisitor is in fact a MethodWriter, it
   6.849 +							 * means there is no method adapter between the reader and the
   6.850 +							 * writer. If, in addition, the writer's constant pool was
   6.851 +							 * copied from this reader (mw.cw.cr == this), and the signature
   6.852 +							 * and exceptions of the method have not been changed, then it
   6.853 +							 * is possible to skip all visit events and just copy the
   6.854 +							 * original code of the method to the writer (the access, name
   6.855 +							 * and descriptor can have been changed, this is not important
   6.856 +							 * since they are not copied as is from the reader).
   6.857 +							 */
   6.858 +			if(mv instanceof MethodWriter)
   6.859 +				{
   6.860 +				MethodWriter mw = (MethodWriter) mv;
   6.861 +				if(mw.cw.cr == this)
   6.862 +					{
   6.863 +					if(signature == mw.signature)
   6.864 +						{
   6.865 +						boolean sameExceptions = false;
   6.866 +						if(exceptions == null)
   6.867 +							{
   6.868 +							sameExceptions = mw.exceptionCount == 0;
   6.869 +							}
   6.870 +						else
   6.871 +							{
   6.872 +							if(exceptions.length == mw.exceptionCount)
   6.873 +								{
   6.874 +								sameExceptions = true;
   6.875 +								for(j = exceptions.length - 1; j >= 0; --j)
   6.876 +									{
   6.877 +									w -= 2;
   6.878 +									if(mw.exceptions[j] != readUnsignedShort(w))
   6.879 +										{
   6.880 +										sameExceptions = false;
   6.881 +										break;
   6.882 +										}
   6.883 +									}
   6.884 +								}
   6.885 +							}
   6.886 +						if(sameExceptions)
   6.887 +							{
   6.888 +							/*
   6.889 +															 * we do not copy directly the code into
   6.890 +															 * MethodWriter to save a byte array copy
   6.891 +															 * operation. The real copy will be done in
   6.892 +															 * ClassWriter.toByteArray().
   6.893 +															 */
   6.894 +							mw.classReaderOffset = u0;
   6.895 +							mw.classReaderLength = u - u0;
   6.896 +							continue;
   6.897 +							}
   6.898 +						}
   6.899 +					}
   6.900 +				}
   6.901 +
   6.902 +			if(dann != 0)
   6.903 +				{
   6.904 +				AnnotationVisitor dv = mv.visitAnnotationDefault();
   6.905 +				readAnnotationValue(dann, c, null, dv);
   6.906 +				if(dv != null)
   6.907 +					{
   6.908 +					dv.visitEnd();
   6.909 +					}
   6.910 +				}
   6.911 +			for(j = 1; j >= 0; --j)
   6.912 +				{
   6.913 +				w = j == 0 ? ianns : anns;
   6.914 +				if(w != 0)
   6.915 +					{
   6.916 +					k = readUnsignedShort(w);
   6.917 +					w += 2;
   6.918 +					for(; k > 0; --k)
   6.919 +						{
   6.920 +						w = readAnnotationValues(w + 2,
   6.921 +						                         c,
   6.922 +						                         true,
   6.923 +						                         mv.visitAnnotation(readUTF8(w, c), j != 0));
   6.924 +						}
   6.925 +					}
   6.926 +				}
   6.927 +			if(mpanns != 0)
   6.928 +				{
   6.929 +				readParameterAnnotations(mpanns, c, true, mv);
   6.930 +				}
   6.931 +			if(impanns != 0)
   6.932 +				{
   6.933 +				readParameterAnnotations(impanns, c, false, mv);
   6.934 +				}
   6.935 +			while(cattrs != null)
   6.936 +				{
   6.937 +				attr = cattrs.next;
   6.938 +				cattrs.next = null;
   6.939 +				mv.visitAttribute(cattrs);
   6.940 +				cattrs = attr;
   6.941 +				}
   6.942 +			}
   6.943 +
   6.944 +		if(mv != null && v != 0)
   6.945 +			{
   6.946 +			int maxStack = readUnsignedShort(v);
   6.947 +			int maxLocals = readUnsignedShort(v + 2);
   6.948 +			int codeLength = readInt(v + 4);
   6.949 +			v += 8;
   6.950 +
   6.951 +			int codeStart = v;
   6.952 +			int codeEnd = v + codeLength;
   6.953 +
   6.954 +			mv.visitCode();
   6.955 +
   6.956 +			// 1st phase: finds the labels
   6.957 +			int label;
   6.958 +			Label[] labels = new Label[codeLength + 1];
   6.959 +			while(v < codeEnd)
   6.960 +				{
   6.961 +				int opcode = b[v] & 0xFF;
   6.962 +				switch(ClassWriter.TYPE[opcode])
   6.963 +					{
   6.964 +					case ClassWriter.NOARG_INSN:
   6.965 +					case ClassWriter.IMPLVAR_INSN:
   6.966 +						v += 1;
   6.967 +						break;
   6.968 +					case ClassWriter.LABEL_INSN:
   6.969 +						label = v - codeStart + readShort(v + 1);
   6.970 +						if(labels[label] == null)
   6.971 +							{
   6.972 +							labels[label] = new Label();
   6.973 +							}
   6.974 +						v += 3;
   6.975 +						break;
   6.976 +					case ClassWriter.LABELW_INSN:
   6.977 +						label = v - codeStart + readInt(v + 1);
   6.978 +						if(labels[label] == null)
   6.979 +							{
   6.980 +							labels[label] = new Label();
   6.981 +							}
   6.982 +						v += 5;
   6.983 +						break;
   6.984 +					case ClassWriter.WIDE_INSN:
   6.985 +						opcode = b[v + 1] & 0xFF;
   6.986 +						if(opcode == Opcodes.IINC)
   6.987 +							{
   6.988 +							v += 6;
   6.989 +							}
   6.990 +						else
   6.991 +							{
   6.992 +							v += 4;
   6.993 +							}
   6.994 +						break;
   6.995 +					case ClassWriter.TABL_INSN:
   6.996 +						// skips 0 to 3 padding bytes
   6.997 +						w = v - codeStart;
   6.998 +						v = v + 4 - (w & 3);
   6.999 +						// reads instruction
  6.1000 +						label = w + readInt(v);
  6.1001 +						if(labels[label] == null)
  6.1002 +							{
  6.1003 +							labels[label] = new Label();
  6.1004 +							}
  6.1005 +						j = readInt(v + 8) - readInt(v + 4) + 1;
  6.1006 +						v += 12;
  6.1007 +						for(; j > 0; --j)
  6.1008 +							{
  6.1009 +							label = w + readInt(v);
  6.1010 +							v += 4;
  6.1011 +							if(labels[label] == null)
  6.1012 +								{
  6.1013 +								labels[label] = new Label();
  6.1014 +								}
  6.1015 +							}
  6.1016 +						break;
  6.1017 +					case ClassWriter.LOOK_INSN:
  6.1018 +						// skips 0 to 3 padding bytes
  6.1019 +						w = v - codeStart;
  6.1020 +						v = v + 4 - (w & 3);
  6.1021 +						// reads instruction
  6.1022 +						label = w + readInt(v);
  6.1023 +						if(labels[label] == null)
  6.1024 +							{
  6.1025 +							labels[label] = new Label();
  6.1026 +							}
  6.1027 +						j = readInt(v + 4);
  6.1028 +						v += 8;
  6.1029 +						for(; j > 0; --j)
  6.1030 +							{
  6.1031 +							label = w + readInt(v + 4);
  6.1032 +							v += 8;
  6.1033 +							if(labels[label] == null)
  6.1034 +								{
  6.1035 +								labels[label] = new Label();
  6.1036 +								}
  6.1037 +							}
  6.1038 +						break;
  6.1039 +					case ClassWriter.VAR_INSN:
  6.1040 +					case ClassWriter.SBYTE_INSN:
  6.1041 +					case ClassWriter.LDC_INSN:
  6.1042 +						v += 2;
  6.1043 +						break;
  6.1044 +					case ClassWriter.SHORT_INSN:
  6.1045 +					case ClassWriter.LDCW_INSN:
  6.1046 +					case ClassWriter.FIELDORMETH_INSN:
  6.1047 +					case ClassWriter.TYPE_INSN:
  6.1048 +					case ClassWriter.IINC_INSN:
  6.1049 +						v += 3;
  6.1050 +						break;
  6.1051 +					case ClassWriter.ITFMETH_INSN:
  6.1052 +						v += 5;
  6.1053 +						break;
  6.1054 +						// case MANA_INSN:
  6.1055 +					default:
  6.1056 +						v += 4;
  6.1057 +						break;
  6.1058 +					}
  6.1059 +				}
  6.1060 +			// parses the try catch entries
  6.1061 +			j = readUnsignedShort(v);
  6.1062 +			v += 2;
  6.1063 +			for(; j > 0; --j)
  6.1064 +				{
  6.1065 +				label = readUnsignedShort(v);
  6.1066 +				Label start = labels[label];
  6.1067 +				if(start == null)
  6.1068 +					{
  6.1069 +					labels[label] = start = new Label();
  6.1070 +					}
  6.1071 +				label = readUnsignedShort(v + 2);
  6.1072 +				Label end = labels[label];
  6.1073 +				if(end == null)
  6.1074 +					{
  6.1075 +					labels[label] = end = new Label();
  6.1076 +					}
  6.1077 +				label = readUnsignedShort(v + 4);
  6.1078 +				Label handler = labels[label];
  6.1079 +				if(handler == null)
  6.1080 +					{
  6.1081 +					labels[label] = handler = new Label();
  6.1082 +					}
  6.1083 +				int type = readUnsignedShort(v + 6);
  6.1084 +				if(type == 0)
  6.1085 +					{
  6.1086 +					mv.visitTryCatchBlock(start, end, handler, null);
  6.1087 +					}
  6.1088 +				else
  6.1089 +					{
  6.1090 +					mv.visitTryCatchBlock(start,
  6.1091 +					                      end,
  6.1092 +					                      handler,
  6.1093 +					                      readUTF8(items[type], c));
  6.1094 +					}
  6.1095 +				v += 8;
  6.1096 +				}
  6.1097 +			// parses the local variable, line number tables, and code
  6.1098 +			// attributes
  6.1099 +			int varTable = 0;
  6.1100 +			int varTypeTable = 0;
  6.1101 +			int stackMap = 0;
  6.1102 +			int frameCount = 0;
  6.1103 +			int frameMode = 0;
  6.1104 +			int frameOffset = 0;
  6.1105 +			int frameLocalCount = 0;
  6.1106 +			int frameLocalDiff = 0;
  6.1107 +			int frameStackCount = 0;
  6.1108 +			Object[] frameLocal = null;
  6.1109 +			Object[] frameStack = null;
  6.1110 +			boolean zip = true;
  6.1111 +			cattrs = null;
  6.1112 +			j = readUnsignedShort(v);
  6.1113 +			v += 2;
  6.1114 +			for(; j > 0; --j)
  6.1115 +				{
  6.1116 +				attrName = readUTF8(v, c);
  6.1117 +				if(attrName.equals("LocalVariableTable"))
  6.1118 +					{
  6.1119 +					if(!skipDebug)
  6.1120 +						{
  6.1121 +						varTable = v + 6;
  6.1122 +						k = readUnsignedShort(v + 6);
  6.1123 +						w = v + 8;
  6.1124 +						for(; k > 0; --k)
  6.1125 +							{
  6.1126 +							label = readUnsignedShort(w);
  6.1127 +							if(labels[label] == null)
  6.1128 +								{
  6.1129 +								labels[label] = new Label(true);
  6.1130 +								}
  6.1131 +							label += readUnsignedShort(w + 2);
  6.1132 +							if(labels[label] == null)
  6.1133 +								{
  6.1134 +								labels[label] = new Label(true);
  6.1135 +								}
  6.1136 +							w += 10;
  6.1137 +							}
  6.1138 +						}
  6.1139 +					}
  6.1140 +				else if(attrName.equals("LocalVariableTypeTable"))
  6.1141 +					{
  6.1142 +					varTypeTable = v + 6;
  6.1143 +					}
  6.1144 +				else if(attrName.equals("LineNumberTable"))
  6.1145 +					{
  6.1146 +					if(!skipDebug)
  6.1147 +						{
  6.1148 +						k = readUnsignedShort(v + 6);
  6.1149 +						w = v + 8;
  6.1150 +						for(; k > 0; --k)
  6.1151 +							{
  6.1152 +							label = readUnsignedShort(w);
  6.1153 +							if(labels[label] == null)
  6.1154 +								{
  6.1155 +								labels[label] = new Label(true);
  6.1156 +								}
  6.1157 +							labels[label].line = readUnsignedShort(w + 2);
  6.1158 +							w += 4;
  6.1159 +							}
  6.1160 +						}
  6.1161 +					}
  6.1162 +				else if(attrName.equals("StackMapTable"))
  6.1163 +					{
  6.1164 +					if((flags & SKIP_FRAMES) == 0)
  6.1165 +						{
  6.1166 +						stackMap = v + 8;
  6.1167 +						frameCount = readUnsignedShort(v + 6);
  6.1168 +						}
  6.1169 +					/*
  6.1170 +											 * here we do not extract the labels corresponding to
  6.1171 +											 * the attribute content. This would require a full
  6.1172 +											 * parsing of the attribute, which would need to be
  6.1173 +											 * repeated in the second phase (see below). Instead the
  6.1174 +											 * content of the attribute is read one frame at a time
  6.1175 +											 * (i.e. after a frame has been visited, the next frame
  6.1176 +											 * is read), and the labels it contains are also
  6.1177 +											 * extracted one frame at a time. Thanks to the ordering
  6.1178 +											 * of frames, having only a "one frame lookahead" is not
  6.1179 +											 * a problem, i.e. it is not possible to see an offset
  6.1180 +											 * smaller than the offset of the current insn and for
  6.1181 +											 * which no Label exist.
  6.1182 +											 */
  6.1183 +					// TODO true for frame offsets,
  6.1184 +					// but for UNINITIALIZED type offsets?
  6.1185 +					}
  6.1186 +				else if(attrName.equals("StackMap"))
  6.1187 +					{
  6.1188 +					if((flags & SKIP_FRAMES) == 0)
  6.1189 +						{
  6.1190 +						stackMap = v + 8;
  6.1191 +						frameCount = readUnsignedShort(v + 6);
  6.1192 +						zip = false;
  6.1193 +						}
  6.1194 +					/*
  6.1195 +											 * IMPORTANT! here we assume that the frames are
  6.1196 +											 * ordered, as in the StackMapTable attribute, although
  6.1197 +											 * this is not guaranteed by the attribute format.
  6.1198 +											 */
  6.1199 +					}
  6.1200 +				else
  6.1201 +					{
  6.1202 +					for(k = 0; k < attrs.length; ++k)
  6.1203 +						{
  6.1204 +						if(attrs[k].type.equals(attrName))
  6.1205 +							{
  6.1206 +							attr = attrs[k].read(this,
  6.1207 +							                     v + 6,
  6.1208 +							                     readInt(v + 2),
  6.1209 +							                     c,
  6.1210 +							                     codeStart - 8,
  6.1211 +							                     labels);
  6.1212 +							if(attr != null)
  6.1213 +								{
  6.1214 +								attr.next = cattrs;
  6.1215 +								cattrs = attr;
  6.1216 +								}
  6.1217 +							}
  6.1218 +						}
  6.1219 +					}
  6.1220 +				v += 6 + readInt(v + 2);
  6.1221 +				}
  6.1222 +
  6.1223 +			// 2nd phase: visits each instruction
  6.1224 +			if(stackMap != 0)
  6.1225 +				{
  6.1226 +				// creates the very first (implicit) frame from the method
  6.1227 +				// descriptor
  6.1228 +				frameLocal = new Object[maxLocals];
  6.1229 +				frameStack = new Object[maxStack];
  6.1230 +				if(unzip)
  6.1231 +					{
  6.1232 +					int local = 0;
  6.1233 +					if((access & Opcodes.ACC_STATIC) == 0)
  6.1234 +						{
  6.1235 +						if(name.equals("<init>"))
  6.1236 +							{
  6.1237 +							frameLocal[local++] = Opcodes.UNINITIALIZED_THIS;
  6.1238 +							}
  6.1239 +						else
  6.1240 +							{
  6.1241 +							frameLocal[local++] = readClass(header + 2, c);
  6.1242 +							}
  6.1243 +						}
  6.1244 +					j = 1;
  6.1245 +					loop:
  6.1246 +					while(true)
  6.1247 +						{
  6.1248 +						k = j;
  6.1249 +						switch(desc.charAt(j++))
  6.1250 +							{
  6.1251 +							case'Z':
  6.1252 +							case'C':
  6.1253 +							case'B':
  6.1254 +							case'S':
  6.1255 +							case'I':
  6.1256 +								frameLocal[local++] = Opcodes.INTEGER;
  6.1257 +								break;
  6.1258 +							case'F':
  6.1259 +								frameLocal[local++] = Opcodes.FLOAT;
  6.1260 +								break;
  6.1261 +							case'J':
  6.1262 +								frameLocal[local++] = Opcodes.LONG;
  6.1263 +								break;
  6.1264 +							case'D':
  6.1265 +								frameLocal[local++] = Opcodes.DOUBLE;
  6.1266 +								break;
  6.1267 +							case'[':
  6.1268 +								while(desc.charAt(j) == '[')
  6.1269 +									{
  6.1270 +									++j;
  6.1271 +									}
  6.1272 +								if(desc.charAt(j) == 'L')
  6.1273 +									{
  6.1274 +									++j;
  6.1275 +									while(desc.charAt(j) != ';')
  6.1276 +										{
  6.1277 +										++j;
  6.1278 +										}
  6.1279 +									}
  6.1280 +								frameLocal[local++] = desc.substring(k, ++j);
  6.1281 +								break;
  6.1282 +							case'L':
  6.1283 +								while(desc.charAt(j) != ';')
  6.1284 +									{
  6.1285 +									++j;
  6.1286 +									}
  6.1287 +								frameLocal[local++] = desc.substring(k + 1,
  6.1288 +								                                     j++);
  6.1289 +								break;
  6.1290 +							default:
  6.1291 +								break loop;
  6.1292 +							}
  6.1293 +						}
  6.1294 +					frameLocalCount = local;
  6.1295 +					}
  6.1296 +				/*
  6.1297 +									 * for the first explicit frame the offset is not
  6.1298 +									 * offset_delta + 1 but only offset_delta; setting the
  6.1299 +									 * implicit frame offset to -1 allow the use of the
  6.1300 +									 * "offset_delta + 1" rule in all cases
  6.1301 +									 */
  6.1302 +				frameOffset = -1;
  6.1303 +				}
  6.1304 +			v = codeStart;
  6.1305 +			Label l;
  6.1306 +			while(v < codeEnd)
  6.1307 +				{
  6.1308 +				w = v - codeStart;
  6.1309 +
  6.1310 +				l = labels[w];
  6.1311 +				if(l != null)
  6.1312 +					{
  6.1313 +					mv.visitLabel(l);
  6.1314 +					if(!skipDebug && l.line > 0)
  6.1315 +						{
  6.1316 +						mv.visitLineNumber(l.line, l);
  6.1317 +						}
  6.1318 +					}
  6.1319 +
  6.1320 +				while(frameLocal != null
  6.1321 +				      && (frameOffset == w || frameOffset == -1))
  6.1322 +					{
  6.1323 +					// if there is a frame for this offset,
  6.1324 +					// makes the visitor visit it,
  6.1325 +					// and reads the next frame if there is one.
  6.1326 +					if(!zip || unzip)
  6.1327 +						{
  6.1328 +						mv.visitFrame(Opcodes.F_NEW,
  6.1329 +						              frameLocalCount,
  6.1330 +						              frameLocal,
  6.1331 +						              frameStackCount,
  6.1332 +						              frameStack);
  6.1333 +						}
  6.1334 +					else if(frameOffset != -1)
  6.1335 +						{
  6.1336 +						mv.visitFrame(frameMode,
  6.1337 +						              frameLocalDiff,
  6.1338 +						              frameLocal,
  6.1339 +						              frameStackCount,
  6.1340 +						              frameStack);
  6.1341 +						}
  6.1342 +
  6.1343 +					if(frameCount > 0)
  6.1344 +						{
  6.1345 +						int tag, delta, n;
  6.1346 +						if(zip)
  6.1347 +							{
  6.1348 +							tag = b[stackMap++] & 0xFF;
  6.1349 +							}
  6.1350 +						else
  6.1351 +							{
  6.1352 +							tag = MethodWriter.FULL_FRAME;
  6.1353 +							frameOffset = -1;
  6.1354 +							}
  6.1355 +						frameLocalDiff = 0;
  6.1356 +						if(tag < MethodWriter.SAME_LOCALS_1_STACK_ITEM_FRAME)
  6.1357 +							{
  6.1358 +							delta = tag;
  6.1359 +							frameMode = Opcodes.F_SAME;
  6.1360 +							frameStackCount = 0;
  6.1361 +							}
  6.1362 +						else if(tag < MethodWriter.RESERVED)
  6.1363 +							{
  6.1364 +							delta = tag
  6.1365 +							        - MethodWriter.SAME_LOCALS_1_STACK_ITEM_FRAME;
  6.1366 +							stackMap = readFrameType(frameStack,
  6.1367 +							                         0,
  6.1368 +							                         stackMap,
  6.1369 +							                         c,
  6.1370 +							                         labels);
  6.1371 +							frameMode = Opcodes.F_SAME1;
  6.1372 +							frameStackCount = 1;
  6.1373 +							}
  6.1374 +						else
  6.1375 +							{
  6.1376 +							delta = readUnsignedShort(stackMap);
  6.1377 +							stackMap += 2;
  6.1378 +							if(tag == MethodWriter.SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED)
  6.1379 +								{
  6.1380 +								stackMap = readFrameType(frameStack,
  6.1381 +								                         0,
  6.1382 +								                         stackMap,
  6.1383 +								                         c,
  6.1384 +								                         labels);
  6.1385 +								frameMode = Opcodes.F_SAME1;
  6.1386 +								frameStackCount = 1;
  6.1387 +								}
  6.1388 +							else if(tag >= MethodWriter.CHOP_FRAME
  6.1389 +							        && tag < MethodWriter.SAME_FRAME_EXTENDED)
  6.1390 +								{
  6.1391 +								frameMode = Opcodes.F_CHOP;
  6.1392 +								frameLocalDiff = MethodWriter.SAME_FRAME_EXTENDED
  6.1393 +								                 - tag;
  6.1394 +								frameLocalCount -= frameLocalDiff;
  6.1395 +								frameStackCount = 0;
  6.1396 +								}
  6.1397 +							else if(tag == MethodWriter.SAME_FRAME_EXTENDED)
  6.1398 +								{
  6.1399 +								frameMode = Opcodes.F_SAME;
  6.1400 +								frameStackCount = 0;
  6.1401 +								}
  6.1402 +							else if(tag < MethodWriter.FULL_FRAME)
  6.1403 +								{
  6.1404 +								j = unzip ? frameLocalCount : 0;
  6.1405 +								for(k = tag
  6.1406 +								        - MethodWriter.SAME_FRAME_EXTENDED; k > 0; k--)
  6.1407 +									{
  6.1408 +									stackMap = readFrameType(frameLocal,
  6.1409 +									                         j++,
  6.1410 +									                         stackMap,
  6.1411 +									                         c,
  6.1412 +									                         labels);
  6.1413 +									}
  6.1414 +								frameMode = Opcodes.F_APPEND;
  6.1415 +								frameLocalDiff = tag
  6.1416 +								                 - MethodWriter.SAME_FRAME_EXTENDED;
  6.1417 +								frameLocalCount += frameLocalDiff;
  6.1418 +								frameStackCount = 0;
  6.1419 +								}
  6.1420 +							else
  6.1421 +								{ // if (tag == FULL_FRAME) {
  6.1422 +								frameMode = Opcodes.F_FULL;
  6.1423 +								n = frameLocalDiff = frameLocalCount = readUnsignedShort(stackMap);
  6.1424 +								stackMap += 2;
  6.1425 +								for(j = 0; n > 0; n--)
  6.1426 +									{
  6.1427 +									stackMap = readFrameType(frameLocal,
  6.1428 +									                         j++,
  6.1429 +									                         stackMap,
  6.1430 +									                         c,
  6.1431 +									                         labels);
  6.1432 +									}
  6.1433 +								n = frameStackCount = readUnsignedShort(stackMap);
  6.1434 +								stackMap += 2;
  6.1435 +								for(j = 0; n > 0; n--)
  6.1436 +									{
  6.1437 +									stackMap = readFrameType(frameStack,
  6.1438 +									                         j++,
  6.1439 +									                         stackMap,
  6.1440 +									                         c,
  6.1441 +									                         labels);
  6.1442 +									}
  6.1443 +								}
  6.1444 +							}
  6.1445 +						frameOffset += delta + 1;
  6.1446 +						if(labels[frameOffset] == null)
  6.1447 +							{
  6.1448 +							labels[frameOffset] = new Label();
  6.1449 +							}
  6.1450 +
  6.1451 +						--frameCount;
  6.1452 +						}
  6.1453 +					else
  6.1454 +						{
  6.1455 +						frameLocal = null;
  6.1456 +						}
  6.1457 +					}
  6.1458 +
  6.1459 +				int opcode = b[v] & 0xFF;
  6.1460 +				switch(ClassWriter.TYPE[opcode])
  6.1461 +					{
  6.1462 +					case ClassWriter.NOARG_INSN:
  6.1463 +						mv.visitInsn(opcode);
  6.1464 +						v += 1;
  6.1465 +						break;
  6.1466 +					case ClassWriter.IMPLVAR_INSN:
  6.1467 +						if(opcode > Opcodes.ISTORE)
  6.1468 +							{
  6.1469 +							opcode -= 59; // ISTORE_0
  6.1470 +							mv.visitVarInsn(Opcodes.ISTORE + (opcode >> 2),
  6.1471 +							                opcode & 0x3);
  6.1472 +							}
  6.1473 +						else
  6.1474 +							{
  6.1475 +							opcode -= 26; // ILOAD_0
  6.1476 +							mv.visitVarInsn(Opcodes.ILOAD + (opcode >> 2),
  6.1477 +							                opcode & 0x3);
  6.1478 +							}
  6.1479 +						v += 1;
  6.1480 +						break;
  6.1481 +					case ClassWriter.LABEL_INSN:
  6.1482 +						mv.visitJumpInsn(opcode, labels[w
  6.1483 +						                                + readShort(v + 1)]);
  6.1484 +						v += 3;
  6.1485 +						break;
  6.1486 +					case ClassWriter.LABELW_INSN:
  6.1487 +						mv.visitJumpInsn(opcode - 33, labels[w
  6.1488 +						                                     + readInt(v + 1)]);
  6.1489 +						v += 5;
  6.1490 +						break;
  6.1491 +					case ClassWriter.WIDE_INSN:
  6.1492 +						opcode = b[v + 1] & 0xFF;
  6.1493 +						if(opcode == Opcodes.IINC)
  6.1494 +							{
  6.1495 +							mv.visitIincInsn(readUnsignedShort(v + 2),
  6.1496 +							                 readShort(v + 4));
  6.1497 +							v += 6;
  6.1498 +							}
  6.1499 +						else
  6.1500 +							{
  6.1501 +							mv.visitVarInsn(opcode,
  6.1502 +							                readUnsignedShort(v + 2));
  6.1503 +							v += 4;
  6.1504 +							}
  6.1505 +						break;
  6.1506 +					case ClassWriter.TABL_INSN:
  6.1507 +						// skips 0 to 3 padding bytes
  6.1508 +						v = v + 4 - (w & 3);
  6.1509 +						// reads instruction
  6.1510 +						label = w + readInt(v);
  6.1511 +						int min = readInt(v + 4);
  6.1512 +						int max = readInt(v + 8);
  6.1513 +						v += 12;
  6.1514 +						Label[] table = new Label[max - min + 1];
  6.1515 +						for(j = 0; j < table.length; ++j)
  6.1516 +							{
  6.1517 +							table[j] = labels[w + readInt(v)];
  6.1518 +							v += 4;
  6.1519 +							}
  6.1520 +						mv.visitTableSwitchInsn(min,
  6.1521 +						                        max,
  6.1522 +						                        labels[label],
  6.1523 +						                        table);
  6.1524 +						break;
  6.1525 +					case ClassWriter.LOOK_INSN:
  6.1526 +						// skips 0 to 3 padding bytes
  6.1527 +						v = v + 4 - (w & 3);
  6.1528 +						// reads instruction
  6.1529 +						label = w + readInt(v);
  6.1530 +						j = readInt(v + 4);
  6.1531 +						v += 8;
  6.1532 +						int[] keys = new int[j];
  6.1533 +						Label[] values = new Label[j];
  6.1534 +						for(j = 0; j < keys.length; ++j)
  6.1535 +							{
  6.1536 +							keys[j] = readInt(v);
  6.1537 +							values[j] = labels[w + readInt(v + 4)];
  6.1538 +							v += 8;
  6.1539 +							}
  6.1540 +						mv.visitLookupSwitchInsn(labels[label],
  6.1541 +						                         keys,
  6.1542 +						                         values);
  6.1543 +						break;
  6.1544 +					case ClassWriter.VAR_INSN:
  6.1545 +						mv.visitVarInsn(opcode, b[v + 1] & 0xFF);
  6.1546 +						v += 2;
  6.1547 +						break;
  6.1548 +					case ClassWriter.SBYTE_INSN:
  6.1549 +						mv.visitIntInsn(opcode, b[v + 1]);
  6.1550 +						v += 2;
  6.1551 +						break;
  6.1552 +					case ClassWriter.SHORT_INSN:
  6.1553 +						mv.visitIntInsn(opcode, readShort(v + 1));
  6.1554 +						v += 3;
  6.1555 +						break;
  6.1556 +					case ClassWriter.LDC_INSN:
  6.1557 +						mv.visitLdcInsn(readConst(b[v + 1] & 0xFF, c));
  6.1558 +						v += 2;
  6.1559 +						break;
  6.1560 +					case ClassWriter.LDCW_INSN:
  6.1561 +						mv.visitLdcInsn(readConst(readUnsignedShort(v + 1),
  6.1562 +						                          c));
  6.1563 +						v += 3;
  6.1564 +						break;
  6.1565 +					case ClassWriter.FIELDORMETH_INSN:
  6.1566 +					case ClassWriter.ITFMETH_INSN:
  6.1567 +						int cpIndex = items[readUnsignedShort(v + 1)];
  6.1568 +						String iowner = readClass(cpIndex, c);
  6.1569 +						cpIndex = items[readUnsignedShort(cpIndex + 2)];
  6.1570 +						String iname = readUTF8(cpIndex, c);
  6.1571 +						String idesc = readUTF8(cpIndex + 2, c);
  6.1572 +						if(opcode < Opcodes.INVOKEVIRTUAL)
  6.1573 +							{
  6.1574 +							mv.visitFieldInsn(opcode, iowner, iname, idesc);
  6.1575 +							}
  6.1576 +						else
  6.1577 +							{
  6.1578 +							mv.visitMethodInsn(opcode, iowner, iname, idesc);
  6.1579 +							}
  6.1580 +						if(opcode == Opcodes.INVOKEINTERFACE)
  6.1581 +							{
  6.1582 +							v += 5;
  6.1583 +							}
  6.1584 +						else
  6.1585 +							{
  6.1586 +							v += 3;
  6.1587 +							}
  6.1588 +						break;
  6.1589 +					case ClassWriter.TYPE_INSN:
  6.1590 +						mv.visitTypeInsn(opcode, readClass(v + 1, c));
  6.1591 +						v += 3;
  6.1592 +						break;
  6.1593 +					case ClassWriter.IINC_INSN:
  6.1594 +						mv.visitIincInsn(b[v + 1] & 0xFF, b[v + 2]);
  6.1595 +						v += 3;
  6.1596 +						break;
  6.1597 +						// case MANA_INSN:
  6.1598 +					default:
  6.1599 +						mv.visitMultiANewArrayInsn(readClass(v + 1, c),
  6.1600 +						                           b[v + 3] & 0xFF);
  6.1601 +						v += 4;
  6.1602 +						break;
  6.1603 +					}
  6.1604 +				}
  6.1605 +			l = labels[codeEnd - codeStart];
  6.1606 +			if(l != null)
  6.1607 +				{
  6.1608 +				mv.visitLabel(l);
  6.1609 +				}
  6.1610 +			// visits the local variable tables
  6.1611 +			if(!skipDebug && varTable != 0)
  6.1612 +				{
  6.1613 +				int[] typeTable = null;
  6.1614 +				if(varTypeTable != 0)
  6.1615 +					{
  6.1616 +					k = readUnsignedShort(varTypeTable) * 3;
  6.1617 +					w = varTypeTable + 2;
  6.1618 +					typeTable = new int[k];
  6.1619 +					while(k > 0)
  6.1620 +						{
  6.1621 +						typeTable[--k] = w + 6; // signature
  6.1622 +						typeTable[--k] = readUnsignedShort(w + 8); // index
  6.1623 +						typeTable[--k] = readUnsignedShort(w); // start
  6.1624 +						w += 10;
  6.1625 +						}
  6.1626 +					}
  6.1627 +				k = readUnsignedShort(varTable);
  6.1628 +				w = varTable + 2;
  6.1629 +				for(; k > 0; --k)
  6.1630 +					{
  6.1631 +					int start = readUnsignedShort(w);
  6.1632 +					int length = readUnsignedShort(w + 2);
  6.1633 +					int index = readUnsignedShort(w + 8);
  6.1634 +					String vsignature = null;
  6.1635 +					if(typeTable != null)
  6.1636 +						{
  6.1637 +						for(int a = 0; a < typeTable.length; a += 3)
  6.1638 +							{
  6.1639 +							if(typeTable[a] == start
  6.1640 +							   && typeTable[a + 1] == index)
  6.1641 +								{
  6.1642 +								vsignature = readUTF8(typeTable[a + 2], c);
  6.1643 +								break;
  6.1644 +								}
  6.1645 +							}
  6.1646 +						}
  6.1647 +					mv.visitLocalVariable(readUTF8(w + 4, c),
  6.1648 +					                      readUTF8(w + 6, c),
  6.1649 +					                      vsignature,
  6.1650 +					                      labels[start],
  6.1651 +					                      labels[start + length],
  6.1652 +					                      index);
  6.1653 +					w += 10;
  6.1654 +					}
  6.1655 +				}
  6.1656 +			// visits the other attributes
  6.1657 +			while(cattrs != null)
  6.1658 +				{
  6.1659 +				attr = cattrs.next;
  6.1660 +				cattrs.next = null;
  6.1661 +				mv.visitAttribute(cattrs);
  6.1662 +				cattrs = attr;
  6.1663 +				}
  6.1664 +			// visits the max stack and max locals values
  6.1665 +			mv.visitMaxs(maxStack, maxLocals);
  6.1666 +			}
  6.1667 +
  6.1668 +		if(mv != null)
  6.1669 +			{
  6.1670 +			mv.visitEnd();
  6.1671 +			}
  6.1672 +		}
  6.1673 +
  6.1674 +	// visits the end of the class
  6.1675 +	classVisitor.visitEnd();
  6.1676 +}
  6.1677 +
  6.1678 +/**
  6.1679 + * Reads parameter annotations and makes the given visitor visit them.
  6.1680 + *
  6.1681 + * @param v       start offset in {@link #b b} of the annotations to be read.
  6.1682 + * @param buf     buffer to be used to call {@link #readUTF8 readUTF8},
  6.1683 + *                {@link #readClass(int,char[]) readClass} or
  6.1684 + *                {@link #readConst readConst}.
  6.1685 + * @param visible <tt>true</tt> if the annotations to be read are visible
  6.1686 + *                at runtime.
  6.1687 + * @param mv      the visitor that must visit the annotations.
  6.1688 + */
  6.1689 +private void readParameterAnnotations(
  6.1690 +		int v,
  6.1691 +		final char[] buf,
  6.1692 +		final boolean visible,
  6.1693 +		final MethodVisitor mv){
  6.1694 +	int n = b[v++] & 0xFF;
  6.1695 +	for(int i = 0; i < n; ++i)
  6.1696 +		{
  6.1697 +		int j = readUnsignedShort(v);
  6.1698 +		v += 2;
  6.1699 +		for(; j > 0; --j)
  6.1700 +			{
  6.1701 +			v = readAnnotationValues(v + 2,
  6.1702 +			                         buf,
  6.1703 +			                         true,
  6.1704 +			                         mv.visitParameterAnnotation(i,
  6.1705 +			                                                     readUTF8(v, buf),
  6.1706 +			                                                     visible));
  6.1707 +			}
  6.1708 +		}
  6.1709 +}
  6.1710 +
  6.1711 +/**
  6.1712 + * Reads the values of an annotation and makes the given visitor visit them.
  6.1713 + *
  6.1714 + * @param v     the start offset in {@link #b b} of the values to be read
  6.1715 + *              (including the unsigned short that gives the number of values).
  6.1716 + * @param buf   buffer to be used to call {@link #readUTF8 readUTF8},
  6.1717 + *              {@link #readClass(int,char[]) readClass} or
  6.1718 + *              {@link #readConst readConst}.
  6.1719 + * @param named if the annotation values are named or not.
  6.1720 + * @param av    the visitor that must visit the values.
  6.1721 + * @return the end offset of the annotation values.
  6.1722 + */
  6.1723 +private int readAnnotationValues(
  6.1724 +		int v,
  6.1725 +		final char[] buf,
  6.1726 +		final boolean named,
  6.1727 +		final AnnotationVisitor av){
  6.1728 +	int i = readUnsignedShort(v);
  6.1729 +	v += 2;
  6.1730 +	if(named)
  6.1731 +		{
  6.1732 +		for(; i > 0; --i)
  6.1733 +			{
  6.1734 +			v = readAnnotationValue(v + 2, buf, readUTF8(v, buf), av);
  6.1735 +			}
  6.1736 +		}
  6.1737 +	else
  6.1738 +		{
  6.1739 +		for(; i > 0; --i)
  6.1740 +			{
  6.1741 +			v = readAnnotationValue(v, buf, null, av);
  6.1742 +			}
  6.1743 +		}
  6.1744 +	if(av != null)
  6.1745 +		{
  6.1746 +		av.visitEnd();
  6.1747 +		}
  6.1748 +	return v;
  6.1749 +}
  6.1750 +
  6.1751 +/**
  6.1752 + * Reads a value of an annotation and makes the given visitor visit it.
  6.1753 + *
  6.1754 + * @param v    the start offset in {@link #b b} of the value to be read (<i>not
  6.1755 + *             including the value name constant pool index</i>).
  6.1756 + * @param buf  buffer to be used to call {@link #readUTF8 readUTF8},
  6.1757 + *             {@link #readClass(int,char[]) readClass} or
  6.1758 + *             {@link #readConst readConst}.
  6.1759 + * @param name the name of the value to be read.
  6.1760 + * @param av   the visitor that must visit the value.
  6.1761 + * @return the end offset of the annotation value.
  6.1762 + */
  6.1763 +private int readAnnotationValue(
  6.1764 +		int v,
  6.1765 +		final char[] buf,
  6.1766 +		final String name,
  6.1767 +		final AnnotationVisitor av){
  6.1768 +	int i;
  6.1769 +	if(av == null)
  6.1770 +		{
  6.1771 +		switch(b[v] & 0xFF)
  6.1772 +			{
  6.1773 +			case'e': // enum_const_value
  6.1774 +				return v + 5;
  6.1775 +			case'@': // annotation_value
  6.1776 +				return readAnnotationValues(v + 3, buf, true, null);
  6.1777 +			case'[': // array_value
  6.1778 +				return readAnnotationValues(v + 1, buf, false, null);
  6.1779 +			default:
  6.1780 +				return v + 3;
  6.1781 +			}
  6.1782 +		}
  6.1783 +	switch(b[v++] & 0xFF)
  6.1784 +		{
  6.1785 +		case'I': // pointer to CONSTANT_Integer
  6.1786 +		case'J': // pointer to CONSTANT_Long
  6.1787 +		case'F': // pointer to CONSTANT_Float
  6.1788 +		case'D': // pointer to CONSTANT_Double
  6.1789 +			av.visit(name, readConst(readUnsignedShort(v), buf));
  6.1790 +			v += 2;
  6.1791 +			break;
  6.1792 +		case'B': // pointer to CONSTANT_Byte
  6.1793 +			av.visit(name,
  6.1794 +			         new Byte((byte) readInt(items[readUnsignedShort(v)])));
  6.1795 +			v += 2;
  6.1796 +			break;
  6.1797 +		case'Z': // pointer to CONSTANT_Boolean
  6.1798 +			av.visit(name, readInt(items[readUnsignedShort(v)]) == 0
  6.1799 +			               ? Boolean.FALSE
  6.1800 +			               : Boolean.TRUE);
  6.1801 +			v += 2;
  6.1802 +			break;
  6.1803 +		case'S': // pointer to CONSTANT_Short
  6.1804 +			av.visit(name,
  6.1805 +			         new Short((short) readInt(items[readUnsignedShort(v)])));
  6.1806 +			v += 2;
  6.1807 +			break;
  6.1808 +		case'C': // pointer to CONSTANT_Char
  6.1809 +			av.visit(name,
  6.1810 +			         new Character((char) readInt(items[readUnsignedShort(v)])));
  6.1811 +			v += 2;
  6.1812 +			break;
  6.1813 +		case's': // pointer to CONSTANT_Utf8
  6.1814 +			av.visit(name, readUTF8(v, buf));
  6.1815 +			v += 2;
  6.1816 +			break;
  6.1817 +		case'e': // enum_const_value
  6.1818 +			av.visitEnum(name, readUTF8(v, buf), readUTF8(v + 2, buf));
  6.1819 +			v += 4;
  6.1820 +			break;
  6.1821 +		case'c': // class_info
  6.1822 +			av.visit(name, Type.getType(readUTF8(v, buf)));
  6.1823 +			v += 2;
  6.1824 +			break;
  6.1825 +		case'@': // annotation_value
  6.1826 +			v = readAnnotationValues(v + 2,
  6.1827 +			                         buf,
  6.1828 +			                         true,
  6.1829 +			                         av.visitAnnotation(name, readUTF8(v, buf)));
  6.1830 +			break;
  6.1831 +		case'[': // array_value
  6.1832 +			int size = readUnsignedShort(v);
  6.1833 +			v += 2;
  6.1834 +			if(size == 0)
  6.1835 +				{
  6.1836 +				return readAnnotationValues(v - 2,
  6.1837 +				                            buf,
  6.1838 +				                            false,
  6.1839 +				                            av.visitArray(name));
  6.1840 +				}
  6.1841 +			switch(this.b[v++] & 0xFF)
  6.1842 +				{
  6.1843 +				case'B':
  6.1844 +					byte[] bv = new byte[size];
  6.1845 +					for(i = 0; i < size; i++)
  6.1846 +						{
  6.1847 +						bv[i] = (byte) readInt(items[readUnsignedShort(v)]);
  6.1848 +						v += 3;
  6.1849 +						}
  6.1850 +					av.visit(name, bv);
  6.1851 +					--v;
  6.1852 +					break;
  6.1853 +				case'Z':
  6.1854 +					boolean[] zv = new boolean[size];
  6.1855 +					for(i = 0; i < size; i++)
  6.1856 +						{
  6.1857 +						zv[i] = readInt(items[readUnsignedShort(v)]) != 0;
  6.1858 +						v += 3;
  6.1859 +						}
  6.1860 +					av.visit(name, zv);
  6.1861 +					--v;
  6.1862 +					break;
  6.1863 +				case'S':
  6.1864 +					short[] sv = new short[size];
  6.1865 +					for(i = 0; i < size; i++)
  6.1866 +						{
  6.1867 +						sv[i] = (short) readInt(items[readUnsignedShort(v)]);
  6.1868 +						v += 3;
  6.1869 +						}
  6.1870 +					av.visit(name, sv);
  6.1871 +					--v;
  6.1872 +					break;
  6.1873 +				case'C':
  6.1874 +					char[] cv = new char[size];
  6.1875 +					for(i = 0; i < size; i++)
  6.1876 +						{
  6.1877 +						cv[i] = (char) readInt(items[readUnsignedShort(v)]);
  6.1878 +						v += 3;
  6.1879 +						}
  6.1880 +					av.visit(name, cv);
  6.1881 +					--v;
  6.1882 +					break;
  6.1883 +				case'I':
  6.1884 +					int[] iv = new int[size];
  6.1885 +					for(i = 0; i < size; i++)
  6.1886 +						{
  6.1887 +						iv[i] = readInt(items[readUnsignedShort(v)]);
  6.1888 +						v += 3;
  6.1889 +						}
  6.1890 +					av.visit(name, iv);
  6.1891 +					--v;
  6.1892 +					break;
  6.1893 +				case'J':
  6.1894 +					long[] lv = new long[size];
  6.1895 +					for(i = 0; i < size; i++)
  6.1896 +						{
  6.1897 +						lv[i] = readLong(items[readUnsignedShort(v)]);
  6.1898 +						v += 3;
  6.1899 +						}
  6.1900 +					av.visit(name, lv);
  6.1901 +					--v;
  6.1902 +					break;
  6.1903 +				case'F':
  6.1904 +					float[] fv = new float[size];
  6.1905 +					for(i = 0; i < size; i++)
  6.1906 +						{
  6.1907 +						fv[i] = Float.intBitsToFloat(readInt(items[readUnsignedShort(v)]));
  6.1908 +						v += 3;
  6.1909 +						}
  6.1910 +					av.visit(name, fv);
  6.1911 +					--v;
  6.1912 +					break;
  6.1913 +				case'D':
  6.1914 +					double[] dv = new double[size];
  6.1915 +					for(i = 0; i < size; i++)
  6.1916 +						{
  6.1917 +						dv[i] = Double.longBitsToDouble(readLong(items[readUnsignedShort(v)]));
  6.1918 +						v += 3;
  6.1919 +						}
  6.1920 +					av.visit(name, dv);
  6.1921 +					--v;
  6.1922 +					break;
  6.1923 +				default:
  6.1924 +					v = readAnnotationValues(v - 3,
  6.1925 +					                         buf,
  6.1926 +					                         false,
  6.1927 +					                         av.visitArray(name));
  6.1928 +				}
  6.1929 +		}
  6.1930 +	return v;
  6.1931 +}
  6.1932 +
  6.1933 +private int readFrameType(
  6.1934 +		final Object[] frame,
  6.1935 +		final int index,
  6.1936 +		int v,
  6.1937 +		final char[] buf,
  6.1938 +		final Label[] labels){
  6.1939 +	int type = b[v++] & 0xFF;
  6.1940 +	switch(type)
  6.1941 +		{
  6.1942 +		case 0:
  6.1943 +			frame[index] = Opcodes.TOP;
  6.1944 +			break;
  6.1945 +		case 1:
  6.1946 +			frame[index] = Opcodes.INTEGER;
  6.1947 +			break;
  6.1948 +		case 2:
  6.1949 +			frame[index] = Opcodes.FLOAT;
  6.1950 +			break;
  6.1951 +		case 3:
  6.1952 +			frame[index] = Opcodes.DOUBLE;
  6.1953 +			break;
  6.1954 +		case 4:
  6.1955 +			frame[index] = Opcodes.LONG;
  6.1956 +			break;
  6.1957 +		case 5:
  6.1958 +			frame[index] = Opcodes.NULL;
  6.1959 +			break;
  6.1960 +		case 6:
  6.1961 +			frame[index] = Opcodes.UNINITIALIZED_THIS;
  6.1962 +			break;
  6.1963 +		case 7: // Object
  6.1964 +			frame[index] = readClass(v, buf);
  6.1965 +			v += 2;
  6.1966 +			break;
  6.1967 +		default: // Uninitialized
  6.1968 +			int offset = readUnsignedShort(v);
  6.1969 +			if(labels[offset] == null)
  6.1970 +				{
  6.1971 +				labels[offset] = new Label();
  6.1972 +				}
  6.1973 +			frame[index] = labels[offset];
  6.1974 +			v += 2;
  6.1975 +		}
  6.1976 +	return v;
  6.1977 +}
  6.1978 +
  6.1979 +/**
  6.1980 + * Reads an attribute in {@link #b b}.
  6.1981 + *
  6.1982 + * @param attrs   prototypes of the attributes that must be parsed during the
  6.1983 + *                visit of the class. Any attribute whose type is not equal to the
  6.1984 + *                type of one the prototypes is ignored (i.e. an empty
  6.1985 + *                {@link Attribute} instance is returned).
  6.1986 + * @param type    the type of the attribute.
  6.1987 + * @param off     index of the first byte of the attribute's content in
  6.1988 + *                {@link #b b}. The 6 attribute header bytes, containing the type
  6.1989 + *                and the length of the attribute, are not taken into account here
  6.1990 + *                (they have already been read).
  6.1991 + * @param len     the length of the attribute's content.
  6.1992 + * @param buf     buffer to be used to call {@link #readUTF8 readUTF8},
  6.1993 + *                {@link #readClass(int,char[]) readClass} or
  6.1994 + *                {@link #readConst readConst}.
  6.1995 + * @param codeOff index of the first byte of code's attribute content in
  6.1996 + *                {@link #b b}, or -1 if the attribute to be read is not a code
  6.1997 + *                attribute. The 6 attribute header bytes, containing the type and
  6.1998 + *                the length of the attribute, are not taken into account here.
  6.1999 + * @param labels  the labels of the method's code, or <tt>null</tt> if the
  6.2000 + *                attribute to be read is not a code attribute.
  6.2001 + * @return the attribute that has been read, or <tt>null</tt> to skip this
  6.2002 + *         attribute.
  6.2003 + */
  6.2004 +private Attribute readAttribute(
  6.2005 +		final Attribute[] attrs,
  6.2006 +		final String type,
  6.2007 +		final int off,
  6.2008 +		final int len,
  6.2009 +		final char[] buf,
  6.2010 +		final int codeOff,
  6.2011 +		final Label[] labels){
  6.2012 +	for(int i = 0; i < attrs.length; ++i)
  6.2013 +		{
  6.2014 +		if(attrs[i].type.equals(type))
  6.2015 +			{
  6.2016 +			return attrs[i].read(this, off, len, buf, codeOff, labels);
  6.2017 +			}
  6.2018 +		}
  6.2019 +	return new Attribute(type).read(this, off, len, null, -1, null);
  6.2020 +}
  6.2021 +
  6.2022 +// ------------------------------------------------------------------------
  6.2023 +// Utility methods: low level parsing
  6.2024 +// ------------------------------------------------------------------------
  6.2025 +
  6.2026 +/**
  6.2027 + * Returns the start index of the constant pool item in {@link #b b}, plus
  6.2028 + * one. <i>This method is intended for {@link Attribute} sub classes, and is
  6.2029 + * normally not needed by class generators or adapters.</i>
  6.2030 + *
  6.2031 + * @param item the index a constant pool item.
  6.2032 + * @return the start index of the constant pool item in {@link #b b}, plus
  6.2033 + *         one.
  6.2034 + */
  6.2035 +public int getItem(final int item){
  6.2036 +	return items[item];
  6.2037 +}
  6.2038 +
  6.2039 +/**
  6.2040 + * Reads a byte value in {@link #b b}. <i>This method is intended for
  6.2041 + * {@link Attribute} sub classes, and is normally not needed by class
  6.2042 + * generators or adapters.</i>
  6.2043 + *
  6.2044 + * @param index the start index of the value to be read in {@link #b b}.
  6.2045 + * @return the read value.
  6.2046 + */
  6.2047 +public int readByte(final int index){
  6.2048 +	return b[index] & 0xFF;
  6.2049 +}
  6.2050 +
  6.2051 +/**
  6.2052 + * Reads an unsigned short value in {@link #b b}. <i>This method is
  6.2053 + * intended for {@link Attribute} sub classes, and is normally not needed by
  6.2054 + * class generators or adapters.</i>
  6.2055 + *
  6.2056 + * @param index the start index of the value to be read in {@link #b b}.
  6.2057 + * @return the read value.
  6.2058 + */
  6.2059 +public int readUnsignedShort(final int index){
  6.2060 +	byte[] b = this.b;
  6.2061 +	return ((b[index] & 0xFF) << 8) | (b[index + 1] & 0xFF);
  6.2062 +}
  6.2063 +
  6.2064 +/**
  6.2065 + * Reads a signed short value in {@link #b b}. <i>This method is intended
  6.2066 + * for {@link Attribute} sub classes, and is normally not needed by class
  6.2067 + * generators or adapters.</i>
  6.2068 + *
  6.2069 + * @param index the start index of the value to be read in {@link #b b}.
  6.2070 + * @return the read value.
  6.2071 + */
  6.2072 +public short readShort(final int index){
  6.2073 +	byte[] b = this.b;
  6.2074 +	return (short) (((b[index] & 0xFF) << 8) | (b[index + 1] & 0xFF));
  6.2075 +}
  6.2076 +
  6.2077 +/**
  6.2078 + * Reads a signed int value in {@link #b b}. <i>This method is intended for
  6.2079 + * {@link Attribute} sub classes, and is normally not needed by class
  6.2080 + * generators or adapters.</i>
  6.2081 + *
  6.2082 + * @param index the start index of the value to be read in {@link #b b}.
  6.2083 + * @return the read value.
  6.2084 + */
  6.2085 +public int readInt(final int index){
  6.2086 +	byte[] b = this.b;
  6.2087 +	return ((b[index] & 0xFF) << 24) | ((b[index + 1] & 0xFF) << 16)
  6.2088 +	       | ((b[index + 2] & 0xFF) << 8) | (b[index + 3] & 0xFF);
  6.2089 +}
  6.2090 +
  6.2091 +/**
  6.2092 + * Reads a signed long value in {@link #b b}. <i>This method is intended
  6.2093 + * for {@link Attribute} sub classes, and is normally not needed by class
  6.2094 + * generators or adapters.</i>
  6.2095 + *
  6.2096 + * @param index the start index of the value to be read in {@link #b b}.
  6.2097 + * @return the read value.
  6.2098 + */
  6.2099 +public long readLong(final int index){
  6.2100 +	long l1 = readInt(index);
  6.2101 +	long l0 = readInt(index + 4) & 0xFFFFFFFFL;
  6.2102 +	return (l1 << 32) | l0;
  6.2103 +}
  6.2104 +
  6.2105 +/**
  6.2106 + * Reads an UTF8 string constant pool item in {@link #b b}. <i>This method
  6.2107 + * is intended for {@link Attribute} sub classes, and is normally not needed
  6.2108 + * by class generators or adapters.</i>
  6.2109 + *
  6.2110 + * @param index the start index of an unsigned short value in {@link #b b},
  6.2111 + *              whose value is the index of an UTF8 constant pool item.
  6.2112 + * @param buf   buffer to be used to read the item. This buffer must be
  6.2113 + *              sufficiently large. It is not automatically resized.
  6.2114 + * @return the String corresponding to the specified UTF8 item.
  6.2115 + */
  6.2116 +public String readUTF8(int index, final char[] buf){
  6.2117 +	int item = readUnsignedShort(index);
  6.2118 +	String s = strings[item];
  6.2119 +	if(s != null)
  6.2120 +		{
  6.2121 +		return s;
  6.2122 +		}
  6.2123 +	index = items[item];
  6.2124 +	return strings[item] = readUTF(index + 2, readUnsignedShort(index), buf);
  6.2125 +}
  6.2126 +
  6.2127 +/**
  6.2128 + * Reads UTF8 string in {@link #b b}.
  6.2129 + *
  6.2130 + * @param index  start offset of the UTF8 string to be read.
  6.2131 + * @param utfLen length of the UTF8 string to be read.
  6.2132 + * @param buf    buffer to be used to read the string. This buffer must be
  6.2133 + *               sufficiently large. It is not automatically resized.
  6.2134 + * @return the String corresponding to the specified UTF8 string.
  6.2135 + */
  6.2136 +private String readUTF(int index, final int utfLen, final char[] buf){
  6.2137 +	int endIndex = index + utfLen;
  6.2138 +	byte[] b = this.b;
  6.2139 +	int strLen = 0;
  6.2140 +	int c, d, e;
  6.2141 +	while(index < endIndex)
  6.2142 +		{
  6.2143 +		c = b[index++] & 0xFF;
  6.2144 +		switch(c >> 4)
  6.2145 +			{
  6.2146 +			case 0:
  6.2147 +			case 1:
  6.2148 +			case 2:
  6.2149 +			case 3:
  6.2150 +			case 4:
  6.2151 +			case 5:
  6.2152 +			case 6:
  6.2153 +			case 7:
  6.2154 +				// 0xxxxxxx
  6.2155 +				buf[strLen++] = (char) c;
  6.2156 +				break;
  6.2157 +			case 12:
  6.2158 +			case 13:
  6.2159 +				// 110x xxxx 10xx xxxx
  6.2160 +				d = b[index++];
  6.2161 +				buf[strLen++] = (char) (((c & 0x1F) << 6) | (d & 0x3F));
  6.2162 +				break;
  6.2163 +			default:
  6.2164 +				// 1110 xxxx 10xx xxxx 10xx xxxx
  6.2165 +				d = b[index++];
  6.2166 +				e = b[index++];
  6.2167 +				buf[strLen++] = (char) (((c & 0x0F) << 12)
  6.2168 +				                        | ((d & 0x3F) << 6) | (e & 0x3F));
  6.2169 +				break;
  6.2170 +			}
  6.2171 +		}
  6.2172 +	return new String(buf, 0, strLen);
  6.2173 +}
  6.2174 +
  6.2175 +/**
  6.2176 + * Reads a class constant pool item in {@link #b b}. <i>This method is
  6.2177 + * intended for {@link Attribute} sub classes, and is normally not needed by
  6.2178 + * class generators or adapters.</i>
  6.2179 + *
  6.2180 + * @param index the start index of an unsigned short value in {@link #b b},
  6.2181 + *              whose value is the index of a class constant pool item.
  6.2182 + * @param buf   buffer to be used to read the item. This buffer must be
  6.2183 + *              sufficiently large. It is not automatically resized.
  6.2184 + * @return the String corresponding to the specified class item.
  6.2185 + */
  6.2186 +public String readClass(final int index, final char[] buf){
  6.2187 +	// computes the start index of the CONSTANT_Class item in b
  6.2188 +	// and reads the CONSTANT_Utf8 item designated by
  6.2189 +	// the first two bytes of this CONSTANT_Class item
  6.2190 +	return readUTF8(items[readUnsignedShort(index)], buf);
  6.2191 +}
  6.2192 +
  6.2193 +/**
  6.2194 + * Reads a numeric or string constant pool item in {@link #b b}. <i>This
  6.2195 + * method is intended for {@link Attribute} sub classes, and is normally not
  6.2196 + * needed by class generators or adapters.</i>
  6.2197 + *
  6.2198 + * @param item the index of a constant pool item.
  6.2199 + * @param buf  buffer to be used to read the item. This buffer must be
  6.2200 + *             sufficiently large. It is not automatically resized.
  6.2201 + * @return the {@link Integer}, {@link Float}, {@link Long},
  6.2202 + *         {@link Double}, {@link String} or {@link Type} corresponding to
  6.2203 + *         the given constant pool item.
  6.2204 + */
  6.2205 +public Object readConst(final int item, final char[] buf){
  6.2206 +	int index = items[item];
  6.2207 +	switch(b[index - 1])
  6.2208 +		{
  6.2209 +		case ClassWriter.INT:
  6.2210 +			return new Integer(readInt(index));
  6.2211 +		case ClassWriter.FLOAT:
  6.2212 +			return new Float(Float.intBitsToFloat(readInt(index)));
  6.2213 +		case ClassWriter.LONG:
  6.2214 +			return new Long(readLong(index));
  6.2215 +		case ClassWriter.DOUBLE:
  6.2216 +			return new Double(Double.longBitsToDouble(readLong(index)));
  6.2217 +		case ClassWriter.CLASS:
  6.2218 +			String s = readUTF8(index, buf);
  6.2219 +			return s.charAt(0) == '['
  6.2220 +			       ? Type.getType(s)
  6.2221 +			       : Type.getObjectType(s);
  6.2222 +			// case ClassWriter.STR:
  6.2223 +		default:
  6.2224 +			return readUTF8(index, buf);
  6.2225 +		}
  6.2226 +}
  6.2227 +}